��Root Mod By V1rus

Viewing: index.iife.js

var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
  if (VueDemi.install) {
    return VueDemi
  }
  if (!Vue) {
    console.error('[vue-demi] no Vue instance found, please be sure to import `vue` before `vue-demi`.')
    return VueDemi
  }

  // Vue 2.7
  if (Vue.version.slice(0, 4) === '2.7.') {
    for (var key in Vue) {
      VueDemi[key] = Vue[key]
    }
    VueDemi.isVue2 = true
    VueDemi.isVue3 = false
    VueDemi.install = function () {}
    VueDemi.Vue = Vue
    VueDemi.Vue2 = Vue
    VueDemi.version = Vue.version
    VueDemi.warn = Vue.util.warn
    VueDemi.hasInjectionContext = function() {
      return !!VueDemi.getCurrentInstance()
    }
    function createApp(rootComponent, rootProps) {
      var vm
      var provide = {}
      var app = {
        config: Vue.config,
        use: Vue.use.bind(Vue),
        mixin: Vue.mixin.bind(Vue),
        component: Vue.component.bind(Vue),
        provide: function (key, value) {
          provide[key] = value
          return this
        },
        directive: function (name, dir) {
          if (dir) {
            Vue.directive(name, dir)
            return app
          } else {
            return Vue.directive(name)
          }
        },
        mount: function (el, hydrating) {
          if (!vm) {
            vm = new Vue(Object.assign({ propsData: rootProps }, rootComponent, { provide: Object.assign(provide, rootComponent.provide) }))
            vm.$mount(el, hydrating)
            return vm
          } else {
            return vm
          }
        },
        unmount: function () {
          if (vm) {
            vm.$destroy()
            vm = undefined
          }
        },
      }
      return app
    }
    VueDemi.createApp = createApp
  }
  // Vue 2.6.x
  else if (Vue.version.slice(0, 2) === '2.') {
    if (VueCompositionAPI) {
      for (var key in VueCompositionAPI) {
        VueDemi[key] = VueCompositionAPI[key]
      }
      VueDemi.isVue2 = true
      VueDemi.isVue3 = false
      VueDemi.install = function () {}
      VueDemi.Vue = Vue
      VueDemi.Vue2 = Vue
      VueDemi.version = Vue.version
      VueDemi.hasInjectionContext = function() {
        return !!VueDemi.getCurrentInstance()
      }
    } else {
      console.error('[vue-demi] no VueCompositionAPI instance found, please be sure to import `@vue/composition-api` before `vue-demi`.')
    }
  }
  // Vue 3
  else if (Vue.version.slice(0, 2) === '3.') {
    for (var key in Vue) {
      VueDemi[key] = Vue[key]
    }
    VueDemi.isVue2 = false
    VueDemi.isVue3 = true
    VueDemi.install = function () {}
    VueDemi.Vue = Vue
    VueDemi.Vue2 = undefined
    VueDemi.version = Vue.version
    VueDemi.set = function (target, key, val) {
      if (Array.isArray(target)) {
        target.length = Math.max(target.length, key)
        target.splice(key, 1, val)
        return val
      }
      target[key] = val
      return val
    }
    VueDemi.del = function (target, key) {
      if (Array.isArray(target)) {
        target.splice(key, 1)
        return
      }
      delete target[key]
    }
  } else {
    console.error('[vue-demi] Vue version ' + Vue.version + ' is unsupported.')
  }
  return VueDemi
})(
  ((globalThis || self).VueDemi = (globalThis || self).VueDemi || (typeof VueDemi !== 'undefined' ? VueDemi : {})),
  (globalThis || self).Vue || (typeof Vue !== 'undefined' ? Vue : undefined),
  (globalThis || self).VueCompositionAPI || (typeof VueCompositionAPI !== 'undefined' ? VueCompositionAPI : undefined)
);
;
;(function (exports, vueDemi, shared) {
  'use strict';

  function createGenericProjection(fromDomain, toDomain, projector) {
    return (input) => {
      return vueDemi.computed(() => projector(shared.toValue(input), shared.toValue(fromDomain), shared.toValue(toDomain)));
    };
  }

  function defaultNumericProjector(input, from, to) {
    return (input - from[0]) / (from[1] - from[0]) * (to[1] - to[0]) + to[0];
  }
  function createProjection(fromDomain, toDomain, projector = defaultNumericProjector) {
    return createGenericProjection(fromDomain, toDomain, projector);
  }

  function logicAnd(...args) {
    return vueDemi.computed(() => args.every((i) => shared.toValue(i)));
  }

  function logicNot(v) {
    return vueDemi.computed(() => !shared.toValue(v));
  }

  function logicOr(...args) {
    return vueDemi.computed(() => args.some((i) => shared.toValue(i)));
  }

  function useAbs(value) {
    return vueDemi.computed(() => Math.abs(shared.toValue(value)));
  }

  function toValueArgsFlat(args) {
    return args.flatMap((i) => {
      const v = shared.toValue(i);
      if (Array.isArray(v))
        return v.map((i2) => shared.toValue(i2));
      return [v];
    });
  }

  function useAverage(...args) {
    return vueDemi.computed(() => {
      const array = toValueArgsFlat(args);
      return array.reduce((sum, v) => sum += v, 0) / array.length;
    });
  }

  function useCeil(value) {
    return vueDemi.computed(() => Math.ceil(shared.toValue(value)));
  }

  function useClamp(value, min, max) {
    if (typeof value === "function" || vueDemi.isReadonly(value))
      return vueDemi.computed(() => shared.clamp(shared.toValue(value), shared.toValue(min), shared.toValue(max)));
    const _value = vueDemi.ref(value);
    return vueDemi.computed({
      get() {
        return _value.value = shared.clamp(_value.value, shared.toValue(min), shared.toValue(max));
      },
      set(value2) {
        _value.value = shared.clamp(value2, shared.toValue(min), shared.toValue(max));
      }
    });
  }

  function useFloor(value) {
    return vueDemi.computed(() => Math.floor(shared.toValue(value)));
  }

  function useMath(key, ...args) {
    return shared.reactify(Math[key])(...args);
  }

  function useMax(...args) {
    return vueDemi.computed(() => {
      const array = toValueArgsFlat(args);
      return Math.max(...array);
    });
  }

  function useMin(...args) {
    return vueDemi.computed(() => {
      const array = toValueArgsFlat(args);
      return Math.min(...array);
    });
  }

  function accurateMultiply(value, power) {
    const valueStr = value.toString();
    if (value > 0 && valueStr.includes(".")) {
      const decimalPlaces = valueStr.split(".")[1].length;
      const multiplier = 10 ** decimalPlaces;
      return value * multiplier * power / multiplier;
    } else {
      return value * power;
    }
  }
  function usePrecision(value, digits, options) {
    return vueDemi.computed(() => {
      var _a;
      const _value = shared.toValue(value);
      const _digits = shared.toValue(digits);
      const power = 10 ** _digits;
      return Math[((_a = shared.toValue(options)) == null ? void 0 : _a.math) || "round"](accurateMultiply(_value, power)) / power;
    });
  }

  function useProjection(input, fromDomain, toDomain, projector) {
    return createProjection(fromDomain, toDomain, projector)(input);
  }

  function useRound(value) {
    return vueDemi.computed(() => Math.round(shared.toValue(value)));
  }

  function useSum(...args) {
    return vueDemi.computed(() => toValueArgsFlat(args).reduce((sum, v) => sum += v, 0));
  }

  function useTrunc(value) {
    return vueDemi.computed(() => Math.trunc(shared.toValue(value)));
  }

  exports.and = logicAnd;
  exports.createGenericProjection = createGenericProjection;
  exports.createProjection = createProjection;
  exports.logicAnd = logicAnd;
  exports.logicNot = logicNot;
  exports.logicOr = logicOr;
  exports.not = logicNot;
  exports.or = logicOr;
  exports.useAbs = useAbs;
  exports.useAverage = useAverage;
  exports.useCeil = useCeil;
  exports.useClamp = useClamp;
  exports.useFloor = useFloor;
  exports.useMath = useMath;
  exports.useMax = useMax;
  exports.useMin = useMin;
  exports.usePrecision = usePrecision;
  exports.useProjection = useProjection;
  exports.useRound = useRound;
  exports.useSum = useSum;
  exports.useTrunc = useTrunc;

})(this.VueUse = this.VueUse || {}, VueDemi, VueUse);
User / IP	: 216.73.217.78
Host / Server	: 195.214.235.115 / npln.ir
System	: Linux damavand.pws-dns.net 5.14.0-503.35.1.el9_5.x86_64 #1 SMP PREEMPT_DYNAMIC Fri Apr 4 05:23:43 EDT 2025 x86_64
���Root Mod By V1rus_Alfa

Viewing: index.iife.js

��Root Mod By V1rus_Alfa
