feature: vor und nachteile

praesentation/node_modules/@vueuse/math/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-PRESENT Anthony Fu<https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

praesentation/node_modules/@vueuse/math/README.md

@@ -0,0 +1,15 @@
+# @vueuse/math
+
+[![NPM version](https://img.shields.io/npm/v/@vueuse/math?color=a1b858)](https://www.npmjs.com/package/@vueuse/math)
+
+> This is an extension of [VueUse](https://github.com/vueuse/vueuse), enables math usage for composable functions.
+
+## Install
+
+```bash
+npm i @vueuse/math @vueuse/core
+```
+
+## License
+
+[MIT License](https://github.com/vueuse/vueuse/blob/master/LICENSE) © 2019-PRESENT [Anthony Fu](https://github.com/antfu)

praesentation/node_modules/@vueuse/math/index.cjs

@@ -0,0 +1,147 @@
+'use strict';
+
+var vue = require('vue');
+var shared = require('@vueuse/shared');
+
+function createGenericProjection(fromDomain, toDomain, projector) {
+  return (input) => {
+    return vue.computed(() => projector(vue.toValue(input), vue.toValue(fromDomain), vue.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 vue.computed(() => args.every((i) => vue.toValue(i)));
+}
+
+function logicNot(v) {
+  return vue.computed(() => !vue.toValue(v));
+}
+
+function logicOr(...args) {
+  return vue.computed(() => args.some((i) => vue.toValue(i)));
+}
+
+function useAbs(value) {
+  return vue.computed(() => Math.abs(vue.toValue(value)));
+}
+
+function toValueArgsFlat(args) {
+  return args.flatMap((i) => {
+    const v = vue.toValue(i);
+    if (Array.isArray(v))
+      return v.map((i2) => vue.toValue(i2));
+    return [v];
+  });
+}
+
+function useAverage(...args) {
+  return vue.computed(() => {
+    const array = toValueArgsFlat(args);
+    return array.reduce((sum, v) => sum += v, 0) / array.length;
+  });
+}
+
+function useCeil(value) {
+  return vue.computed(() => Math.ceil(vue.toValue(value)));
+}
+
+function useClamp(value, min, max) {
+  if (typeof value === "function" || vue.isReadonly(value))
+    return vue.computed(() => shared.clamp(vue.toValue(value), vue.toValue(min), vue.toValue(max)));
+  const _value = vue.ref(value);
+  return vue.computed({
+    get() {
+      return _value.value = shared.clamp(_value.value, vue.toValue(min), vue.toValue(max));
+    },
+    set(value2) {
+      _value.value = shared.clamp(value2, vue.toValue(min), vue.toValue(max));
+    }
+  });
+}
+
+function useFloor(value) {
+  return vue.computed(() => Math.floor(vue.toValue(value)));
+}
+
+function useMath(key, ...args) {
+  return shared.reactify(Math[key])(...args);
+}
+
+function useMax(...args) {
+  return vue.computed(() => {
+    const array = toValueArgsFlat(args);
+    return Math.max(...array);
+  });
+}
+
+function useMin(...args) {
+  return vue.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 vue.computed(() => {
+    var _a;
+    const _value = vue.toValue(value);
+    const _digits = vue.toValue(digits);
+    const power = 10 ** _digits;
+    return Math[((_a = vue.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 vue.computed(() => Math.round(vue.toValue(value)));
+}
+
+function useSum(...args) {
+  return vue.computed(() => toValueArgsFlat(args).reduce((sum, v) => sum += v, 0));
+}
+
+function useTrunc(value) {
+  return vue.computed(() => Math.trunc(vue.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;

praesentation/node_modules/@vueuse/math/index.d.cts

@@ -0,0 +1,114 @@
+import * as vue from 'vue';
+import { MaybeRefOrGetter, ComputedRef, Ref } from 'vue';
+import { MaybeRefOrGetter as MaybeRefOrGetter$1, ReadonlyRefOrGetter, ArgumentsType, Reactified } from '@vueuse/shared';
+
+type ProjectorFunction<F, T> = (input: F, from: readonly [F, F], to: readonly [T, T]) => T;
+type UseProjection<F, T> = (input: MaybeRefOrGetter<F>) => ComputedRef<T>;
+declare function createGenericProjection<F = number, T = number>(fromDomain: MaybeRefOrGetter<readonly [F, F]>, toDomain: MaybeRefOrGetter<readonly [T, T]>, projector: ProjectorFunction<F, T>): UseProjection<F, T>;
+
+declare function createProjection(fromDomain: MaybeRefOrGetter<readonly [number, number]>, toDomain: MaybeRefOrGetter<readonly [number, number]>, projector?: ProjectorFunction<number, number>): UseProjection<number, number>;
+
+/**
+ * `AND` conditions for refs.
+ *
+ * @see https://vueuse.org/logicAnd
+ */
+declare function logicAnd(...args: MaybeRefOrGetter<any>[]): ComputedRef<boolean>;
+
+/**
+ * `NOT` conditions for refs.
+ *
+ * @see https://vueuse.org/logicNot
+ */
+declare function logicNot(v: MaybeRefOrGetter$1<any>): ComputedRef<boolean>;
+
+/**
+ * `OR` conditions for refs.
+ *
+ * @see https://vueuse.org/logicOr
+ */
+declare function logicOr(...args: MaybeRefOrGetter<any>[]): ComputedRef<boolean>;
+
+/**
+ * Reactive `Math.abs`.
+ *
+ * @see https://vueuse.org/useAbs
+ */
+declare function useAbs(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+declare function useAverage(array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>): ComputedRef<number>;
+declare function useAverage(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>;
+
+/**
+ * Reactive `Math.ceil`.
+ *
+ * @see https://vueuse.org/useCeil
+ */
+declare function useCeil(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+declare function useClamp(value: ReadonlyRefOrGetter<number>, min: MaybeRefOrGetter<number>, max: MaybeRefOrGetter<number>): ComputedRef<number>;
+declare function useClamp(value: MaybeRefOrGetter<number>, min: MaybeRefOrGetter<number>, max: MaybeRefOrGetter<number>): Ref<number>;
+
+/**
+ * Reactive `Math.floor`
+ *
+ * @see https://vueuse.org/useFloor
+ */
+declare function useFloor(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+type UseMathKeys = keyof {
+    [K in keyof Math as Math[K] extends (...args: any) => any ? K : never]: unknown;
+};
+/**
+ * Reactive `Math` methods.
+ *
+ * @see https://vueuse.org/useMath
+ */
+declare function useMath<K extends keyof Math>(key: K, ...args: ArgumentsType<Reactified<Math[K], true>>): ReturnType<Reactified<Math[K], true>>;
+
+declare function useMax(array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>): ComputedRef<number>;
+declare function useMax(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>;
+
+declare function useMin(array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>): ComputedRef<number>;
+declare function useMin(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>;
+
+interface UsePrecisionOptions {
+    /**
+     * Method to use for rounding
+     *
+     * @default 'round'
+     */
+    math?: 'floor' | 'ceil' | 'round';
+}
+/**
+ * Reactively set the precision of a number.
+ *
+ * @see https://vueuse.org/usePrecision
+ */
+declare function usePrecision(value: MaybeRefOrGetter<number>, digits: MaybeRefOrGetter<number>, options?: MaybeRefOrGetter<UsePrecisionOptions>): ComputedRef<number>;
+
+/**
+ * Reactive numeric projection from one domain to another.
+ *
+ * @see https://vueuse.org/useProjection
+ */
+declare function useProjection(input: MaybeRefOrGetter<number>, fromDomain: MaybeRefOrGetter<readonly [number, number]>, toDomain: MaybeRefOrGetter<readonly [number, number]>, projector?: ProjectorFunction<number, number>): vue.ComputedRef<number>;
+
+/**
+ * Reactive `Math.round`.
+ *
+ * @see https://vueuse.org/useRound
+ */
+declare function useRound(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+declare function useSum(array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>): ComputedRef<number>;
+declare function useSum(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>;
+
+/**
+ * Reactive `Math.trunc`.
+ *
+ * @see https://vueuse.org/useTrunc
+ */
+declare function useTrunc(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+export { type ProjectorFunction, type UseMathKeys, type UsePrecisionOptions, type UseProjection, logicAnd as and, createGenericProjection, createProjection, logicAnd, logicNot, logicOr, logicNot as not, logicOr as or, useAbs, useAverage, useCeil, useClamp, useFloor, useMath, useMax, useMin, usePrecision, useProjection, useRound, useSum, useTrunc };

praesentation/node_modules/@vueuse/math/index.d.mts

@@ -0,0 +1,114 @@
+import * as vue from 'vue';
+import { MaybeRefOrGetter, ComputedRef, Ref } from 'vue';
+import { MaybeRefOrGetter as MaybeRefOrGetter$1, ReadonlyRefOrGetter, ArgumentsType, Reactified } from '@vueuse/shared';
+
+type ProjectorFunction<F, T> = (input: F, from: readonly [F, F], to: readonly [T, T]) => T;
+type UseProjection<F, T> = (input: MaybeRefOrGetter<F>) => ComputedRef<T>;
+declare function createGenericProjection<F = number, T = number>(fromDomain: MaybeRefOrGetter<readonly [F, F]>, toDomain: MaybeRefOrGetter<readonly [T, T]>, projector: ProjectorFunction<F, T>): UseProjection<F, T>;
+
+declare function createProjection(fromDomain: MaybeRefOrGetter<readonly [number, number]>, toDomain: MaybeRefOrGetter<readonly [number, number]>, projector?: ProjectorFunction<number, number>): UseProjection<number, number>;
+
+/**
+ * `AND` conditions for refs.
+ *
+ * @see https://vueuse.org/logicAnd
+ */
+declare function logicAnd(...args: MaybeRefOrGetter<any>[]): ComputedRef<boolean>;
+
+/**
+ * `NOT` conditions for refs.
+ *
+ * @see https://vueuse.org/logicNot
+ */
+declare function logicNot(v: MaybeRefOrGetter$1<any>): ComputedRef<boolean>;
+
+/**
+ * `OR` conditions for refs.
+ *
+ * @see https://vueuse.org/logicOr
+ */
+declare function logicOr(...args: MaybeRefOrGetter<any>[]): ComputedRef<boolean>;
+
+/**
+ * Reactive `Math.abs`.
+ *
+ * @see https://vueuse.org/useAbs
+ */
+declare function useAbs(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+declare function useAverage(array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>): ComputedRef<number>;
+declare function useAverage(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>;
+
+/**
+ * Reactive `Math.ceil`.
+ *
+ * @see https://vueuse.org/useCeil
+ */
+declare function useCeil(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+declare function useClamp(value: ReadonlyRefOrGetter<number>, min: MaybeRefOrGetter<number>, max: MaybeRefOrGetter<number>): ComputedRef<number>;
+declare function useClamp(value: MaybeRefOrGetter<number>, min: MaybeRefOrGetter<number>, max: MaybeRefOrGetter<number>): Ref<number>;
+
+/**
+ * Reactive `Math.floor`
+ *
+ * @see https://vueuse.org/useFloor
+ */
+declare function useFloor(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+type UseMathKeys = keyof {
+    [K in keyof Math as Math[K] extends (...args: any) => any ? K : never]: unknown;
+};
+/**
+ * Reactive `Math` methods.
+ *
+ * @see https://vueuse.org/useMath
+ */
+declare function useMath<K extends keyof Math>(key: K, ...args: ArgumentsType<Reactified<Math[K], true>>): ReturnType<Reactified<Math[K], true>>;
+
+declare function useMax(array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>): ComputedRef<number>;
+declare function useMax(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>;
+
+declare function useMin(array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>): ComputedRef<number>;
+declare function useMin(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>;
+
+interface UsePrecisionOptions {
+    /**
+     * Method to use for rounding
+     *
+     * @default 'round'
+     */
+    math?: 'floor' | 'ceil' | 'round';
+}
+/**
+ * Reactively set the precision of a number.
+ *
+ * @see https://vueuse.org/usePrecision
+ */
+declare function usePrecision(value: MaybeRefOrGetter<number>, digits: MaybeRefOrGetter<number>, options?: MaybeRefOrGetter<UsePrecisionOptions>): ComputedRef<number>;
+
+/**
+ * Reactive numeric projection from one domain to another.
+ *
+ * @see https://vueuse.org/useProjection
+ */
+declare function useProjection(input: MaybeRefOrGetter<number>, fromDomain: MaybeRefOrGetter<readonly [number, number]>, toDomain: MaybeRefOrGetter<readonly [number, number]>, projector?: ProjectorFunction<number, number>): vue.ComputedRef<number>;
+
+/**
+ * Reactive `Math.round`.
+ *
+ * @see https://vueuse.org/useRound
+ */
+declare function useRound(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+declare function useSum(array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>): ComputedRef<number>;
+declare function useSum(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>;
+
+/**
+ * Reactive `Math.trunc`.
+ *
+ * @see https://vueuse.org/useTrunc
+ */
+declare function useTrunc(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+export { type ProjectorFunction, type UseMathKeys, type UsePrecisionOptions, type UseProjection, logicAnd as and, createGenericProjection, createProjection, logicAnd, logicNot, logicOr, logicNot as not, logicOr as or, useAbs, useAverage, useCeil, useClamp, useFloor, useMath, useMax, useMin, usePrecision, useProjection, useRound, useSum, useTrunc };

praesentation/node_modules/@vueuse/math/index.d.ts

@@ -0,0 +1,114 @@
+import * as vue from 'vue';
+import { MaybeRefOrGetter, ComputedRef, Ref } from 'vue';
+import { MaybeRefOrGetter as MaybeRefOrGetter$1, ReadonlyRefOrGetter, ArgumentsType, Reactified } from '@vueuse/shared';
+
+type ProjectorFunction<F, T> = (input: F, from: readonly [F, F], to: readonly [T, T]) => T;
+type UseProjection<F, T> = (input: MaybeRefOrGetter<F>) => ComputedRef<T>;
+declare function createGenericProjection<F = number, T = number>(fromDomain: MaybeRefOrGetter<readonly [F, F]>, toDomain: MaybeRefOrGetter<readonly [T, T]>, projector: ProjectorFunction<F, T>): UseProjection<F, T>;
+
+declare function createProjection(fromDomain: MaybeRefOrGetter<readonly [number, number]>, toDomain: MaybeRefOrGetter<readonly [number, number]>, projector?: ProjectorFunction<number, number>): UseProjection<number, number>;
+
+/**
+ * `AND` conditions for refs.
+ *
+ * @see https://vueuse.org/logicAnd
+ */
+declare function logicAnd(...args: MaybeRefOrGetter<any>[]): ComputedRef<boolean>;
+
+/**
+ * `NOT` conditions for refs.
+ *
+ * @see https://vueuse.org/logicNot
+ */
+declare function logicNot(v: MaybeRefOrGetter$1<any>): ComputedRef<boolean>;
+
+/**
+ * `OR` conditions for refs.
+ *
+ * @see https://vueuse.org/logicOr
+ */
+declare function logicOr(...args: MaybeRefOrGetter<any>[]): ComputedRef<boolean>;
+
+/**
+ * Reactive `Math.abs`.
+ *
+ * @see https://vueuse.org/useAbs
+ */
+declare function useAbs(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+declare function useAverage(array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>): ComputedRef<number>;
+declare function useAverage(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>;
+
+/**
+ * Reactive `Math.ceil`.
+ *
+ * @see https://vueuse.org/useCeil
+ */
+declare function useCeil(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+declare function useClamp(value: ReadonlyRefOrGetter<number>, min: MaybeRefOrGetter<number>, max: MaybeRefOrGetter<number>): ComputedRef<number>;
+declare function useClamp(value: MaybeRefOrGetter<number>, min: MaybeRefOrGetter<number>, max: MaybeRefOrGetter<number>): Ref<number>;
+
+/**
+ * Reactive `Math.floor`
+ *
+ * @see https://vueuse.org/useFloor
+ */
+declare function useFloor(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+type UseMathKeys = keyof {
+    [K in keyof Math as Math[K] extends (...args: any) => any ? K : never]: unknown;
+};
+/**
+ * Reactive `Math` methods.
+ *
+ * @see https://vueuse.org/useMath
+ */
+declare function useMath<K extends keyof Math>(key: K, ...args: ArgumentsType<Reactified<Math[K], true>>): ReturnType<Reactified<Math[K], true>>;
+
+declare function useMax(array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>): ComputedRef<number>;
+declare function useMax(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>;
+
+declare function useMin(array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>): ComputedRef<number>;
+declare function useMin(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>;
+
+interface UsePrecisionOptions {
+    /**
+     * Method to use for rounding
+     *
+     * @default 'round'
+     */
+    math?: 'floor' | 'ceil' | 'round';
+}
+/**
+ * Reactively set the precision of a number.
+ *
+ * @see https://vueuse.org/usePrecision
+ */
+declare function usePrecision(value: MaybeRefOrGetter<number>, digits: MaybeRefOrGetter<number>, options?: MaybeRefOrGetter<UsePrecisionOptions>): ComputedRef<number>;
+
+/**
+ * Reactive numeric projection from one domain to another.
+ *
+ * @see https://vueuse.org/useProjection
+ */
+declare function useProjection(input: MaybeRefOrGetter<number>, fromDomain: MaybeRefOrGetter<readonly [number, number]>, toDomain: MaybeRefOrGetter<readonly [number, number]>, projector?: ProjectorFunction<number, number>): vue.ComputedRef<number>;
+
+/**
+ * Reactive `Math.round`.
+ *
+ * @see https://vueuse.org/useRound
+ */
+declare function useRound(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+declare function useSum(array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>): ComputedRef<number>;
+declare function useSum(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>;
+
+/**
+ * Reactive `Math.trunc`.
+ *
+ * @see https://vueuse.org/useTrunc
+ */
+declare function useTrunc(value: MaybeRefOrGetter<number>): ComputedRef<number>;
+
+export { type ProjectorFunction, type UseMathKeys, type UsePrecisionOptions, type UseProjection, logicAnd as and, createGenericProjection, createProjection, logicAnd, logicNot, logicOr, logicNot as not, logicOr as or, useAbs, useAverage, useCeil, useClamp, useFloor, useMath, useMax, useMin, usePrecision, useProjection, useRound, useSum, useTrunc };

praesentation/node_modules/@vueuse/math/index.iife.js

@@ -0,0 +1,147 @@
+(function (exports, vue, shared) {
+  'use strict';
+
+  function createGenericProjection(fromDomain, toDomain, projector) {
+    return (input) => {
+      return vue.computed(() => projector(vue.toValue(input), vue.toValue(fromDomain), vue.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 vue.computed(() => args.every((i) => vue.toValue(i)));
+  }
+
+  function logicNot(v) {
+    return vue.computed(() => !vue.toValue(v));
+  }
+
+  function logicOr(...args) {
+    return vue.computed(() => args.some((i) => vue.toValue(i)));
+  }
+
+  function useAbs(value) {
+    return vue.computed(() => Math.abs(vue.toValue(value)));
+  }
+
+  function toValueArgsFlat(args) {
+    return args.flatMap((i) => {
+      const v = vue.toValue(i);
+      if (Array.isArray(v))
+        return v.map((i2) => vue.toValue(i2));
+      return [v];
+    });
+  }
+
+  function useAverage(...args) {
+    return vue.computed(() => {
+      const array = toValueArgsFlat(args);
+      return array.reduce((sum, v) => sum += v, 0) / array.length;
+    });
+  }
+
+  function useCeil(value) {
+    return vue.computed(() => Math.ceil(vue.toValue(value)));
+  }
+
+  function useClamp(value, min, max) {
+    if (typeof value === "function" || vue.isReadonly(value))
+      return vue.computed(() => shared.clamp(vue.toValue(value), vue.toValue(min), vue.toValue(max)));
+    const _value = vue.ref(value);
+    return vue.computed({
+      get() {
+        return _value.value = shared.clamp(_value.value, vue.toValue(min), vue.toValue(max));
+      },
+      set(value2) {
+        _value.value = shared.clamp(value2, vue.toValue(min), vue.toValue(max));
+      }
+    });
+  }
+
+  function useFloor(value) {
+    return vue.computed(() => Math.floor(vue.toValue(value)));
+  }
+
+  function useMath(key, ...args) {
+    return shared.reactify(Math[key])(...args);
+  }
+
+  function useMax(...args) {
+    return vue.computed(() => {
+      const array = toValueArgsFlat(args);
+      return Math.max(...array);
+    });
+  }
+
+  function useMin(...args) {
+    return vue.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 vue.computed(() => {
+      var _a;
+      const _value = vue.toValue(value);
+      const _digits = vue.toValue(digits);
+      const power = 10 ** _digits;
+      return Math[((_a = vue.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 vue.computed(() => Math.round(vue.toValue(value)));
+  }
+
+  function useSum(...args) {
+    return vue.computed(() => toValueArgsFlat(args).reduce((sum, v) => sum += v, 0));
+  }
+
+  function useTrunc(value) {
+    return vue.computed(() => Math.trunc(vue.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 || {}, Vue, VueUse);

praesentation/node_modules/@vueuse/math/index.iife.min.js

@@ -0,0 +1 @@
+(function(o,n,a){"use strict";function l(t,u,e){return c=>n.computed(()=>e(n.toValue(c),n.toValue(t),n.toValue(u)))}function M(t,u,e){return(t-u[0])/(u[1]-u[0])*(e[1]-e[0])+e[0]}function s(t,u,e=M){return l(t,u,e)}function d(...t){return n.computed(()=>t.every(u=>n.toValue(u)))}function f(t){return n.computed(()=>!n.toValue(t))}function V(...t){return n.computed(()=>t.some(u=>n.toValue(u)))}function g(t){return n.computed(()=>Math.abs(n.toValue(t)))}function i(t){return t.flatMap(u=>{const e=n.toValue(u);return Array.isArray(e)?e.map(c=>n.toValue(c)):[e]})}function h(...t){return n.computed(()=>{const u=i(t);return u.reduce((e,c)=>e+=c,0)/u.length})}function P(t){return n.computed(()=>Math.ceil(n.toValue(t)))}function y(t,u,e){if(typeof t=="function"||n.isReadonly(t))return n.computed(()=>a.clamp(n.toValue(t),n.toValue(u),n.toValue(e)));const c=n.ref(t);return n.computed({get(){return c.value=a.clamp(c.value,n.toValue(u),n.toValue(e))},set(r){c.value=a.clamp(r,n.toValue(u),n.toValue(e))}})}function A(t){return n.computed(()=>Math.floor(n.toValue(t)))}function j(t,...u){return a.reactify(Math[t])(...u)}function p(...t){return n.computed(()=>{const u=i(t);return Math.max(...u)})}function _(...t){return n.computed(()=>{const u=i(t);return Math.min(...u)})}function C(t,u){const e=t.toString();if(t>0&&e.includes(".")){const r=10**e.split(".")[1].length;return t*r*u/r}else return t*u}function S(t,u,e){return n.computed(()=>{var c;const r=n.toValue(t),m=10**n.toValue(u);return Math[((c=n.toValue(e))==null?void 0:c.math)||"round"](C(r,m))/m})}function b(t,u,e,c){return s(u,e,c)(t)}function F(t){return n.computed(()=>Math.round(n.toValue(t)))}function N(...t){return n.computed(()=>i(t).reduce((u,e)=>u+=e,0))}function R(t){return n.computed(()=>Math.trunc(n.toValue(t)))}o.and=d,o.createGenericProjection=l,o.createProjection=s,o.logicAnd=d,o.logicNot=f,o.logicOr=V,o.not=f,o.or=V,o.useAbs=g,o.useAverage=h,o.useCeil=P,o.useClamp=y,o.useFloor=A,o.useMath=j,o.useMax=p,o.useMin=_,o.usePrecision=S,o.useProjection=b,o.useRound=F,o.useSum=N,o.useTrunc=R})(this.VueUse=this.VueUse||{},Vue,VueUse);

praesentation/node_modules/@vueuse/math/index.mjs

@@ -0,0 +1,125 @@
+import { computed, toValue, isReadonly, ref } from 'vue';
+import { clamp, reactify } from '@vueuse/shared';
+
+function createGenericProjection(fromDomain, toDomain, projector) {
+  return (input) => {
+    return computed(() => projector(toValue(input), toValue(fromDomain), 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 computed(() => args.every((i) => toValue(i)));
+}
+
+function logicNot(v) {
+  return computed(() => !toValue(v));
+}
+
+function logicOr(...args) {
+  return computed(() => args.some((i) => toValue(i)));
+}
+
+function useAbs(value) {
+  return computed(() => Math.abs(toValue(value)));
+}
+
+function toValueArgsFlat(args) {
+  return args.flatMap((i) => {
+    const v = toValue(i);
+    if (Array.isArray(v))
+      return v.map((i2) => toValue(i2));
+    return [v];
+  });
+}
+
+function useAverage(...args) {
+  return computed(() => {
+    const array = toValueArgsFlat(args);
+    return array.reduce((sum, v) => sum += v, 0) / array.length;
+  });
+}
+
+function useCeil(value) {
+  return computed(() => Math.ceil(toValue(value)));
+}
+
+function useClamp(value, min, max) {
+  if (typeof value === "function" || isReadonly(value))
+    return computed(() => clamp(toValue(value), toValue(min), toValue(max)));
+  const _value = ref(value);
+  return computed({
+    get() {
+      return _value.value = clamp(_value.value, toValue(min), toValue(max));
+    },
+    set(value2) {
+      _value.value = clamp(value2, toValue(min), toValue(max));
+    }
+  });
+}
+
+function useFloor(value) {
+  return computed(() => Math.floor(toValue(value)));
+}
+
+function useMath(key, ...args) {
+  return reactify(Math[key])(...args);
+}
+
+function useMax(...args) {
+  return computed(() => {
+    const array = toValueArgsFlat(args);
+    return Math.max(...array);
+  });
+}
+
+function useMin(...args) {
+  return 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 computed(() => {
+    var _a;
+    const _value = toValue(value);
+    const _digits = toValue(digits);
+    const power = 10 ** _digits;
+    return Math[((_a = 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 computed(() => Math.round(toValue(value)));
+}
+
+function useSum(...args) {
+  return computed(() => toValueArgsFlat(args).reduce((sum, v) => sum += v, 0));
+}
+
+function useTrunc(value) {
+  return computed(() => Math.trunc(toValue(value)));
+}
+
+export { logicAnd as and, createGenericProjection, createProjection, logicAnd, logicNot, logicOr, logicNot as not, logicOr as or, useAbs, useAverage, useCeil, useClamp, useFloor, useMath, useMax, useMin, usePrecision, useProjection, useRound, useSum, useTrunc };

praesentation/node_modules/@vueuse/math/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@vueuse/math",
+  "type": "module",
+  "version": "12.8.2",
+  "description": "Math functions for VueUse",
+  "author": "Anthony Fu <https://github.com/antfu>",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/antfu",
+  "homepage": "https://github.com/vueuse/vueuse/tree/main/packages/math#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vueuse/vueuse.git",
+    "directory": "packages/math"
+  },
+  "bugs": {
+    "url": "https://github.com/vueuse/vueuse/issues"
+  },
+  "keywords": [
+    "vue",
+    "vue-use",
+    "math",
+    "utils"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.cjs"
+    },
+    "./*": "./*"
+  },
+  "main": "./index.cjs",
+  "module": "./index.mjs",
+  "unpkg": "./index.iife.min.js",
+  "jsdelivr": "./index.iife.min.js",
+  "types": "./index.d.ts",
+  "files": [
+    "*.cjs",
+    "*.d.cts",
+    "*.d.mts",
+    "*.d.ts",
+    "*.js",
+    "*.mjs"
+  ],
+  "dependencies": {
+    "vue": "^3.5.13",
+    "@vueuse/shared": "12.8.2"
+  },
+  "scripts": {
+    "build": "rollup --config=rollup.config.ts --configPlugin=rollup-plugin-esbuild"
+  }
+}