@design-edito/tools 0.0.33 → 0.1.2

package/agnostic/regexps/index.d.ts

@@ -0,0 +1,23 @@
+export declare namespace Regexps {
+    function mergeFlags(...flagStrs: string[]): string;
+    function setFlags(regexp: RegExp, _flags: string): RegExp;
+    function fromStart(regexp: RegExp, _flags?: string): RegExp;
+    function toEnd(regexp: RegExp, _flags?: string): RegExp;
+    function fromStartToEnd(regexp: RegExp, _flags?: string): RegExp;
+    function stringStartsWith(string: string, _regexp: RegExp): boolean;
+    function stringStartsWith(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
+    function stringStartsWith(string: string, _regexp: RegExp, returnMatches: false): boolean;
+    function stringStartsWith(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
+    function stringStartsWith(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
+    function stringEndsWith(string: string, _regexp: RegExp): boolean;
+    function stringEndsWith(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
+    function stringEndsWith(string: string, _regexp: RegExp, returnMatches: false): boolean;
+    function stringEndsWith(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
+    function stringEndsWith(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
+    function stringIs(string: string, _regexp: RegExp): boolean;
+    function stringIs(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
+    function stringIs(string: string, _regexp: RegExp, returnMatches: false): boolean;
+    function stringIs(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
+    function stringIs(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
+    function fromStrings(strings: string[]): RegExp;
+}

package/agnostic/regexps/index.js

@@ -0,0 +1,89 @@
+// src/agnostic/regexps/index.ts
+var Regexps;
+((Regexps2) => {
+  function mergeFlags(...flagStrs) {
+    const flagsSet = /* @__PURE__ */ new Set();
+    flagStrs.forEach(
+      (flagStr) => flagStr.split("").forEach((char) => flagsSet.add(char))
+    );
+    return Array.from(flagsSet.values()).join("");
+  }
+  Regexps2.mergeFlags = mergeFlags;
+  function setFlags(regexp, _flags) {
+    const flags = mergeFlags(regexp.flags, _flags);
+    return new RegExp(`${regexp.source}`, flags);
+  }
+  Regexps2.setFlags = setFlags;
+  function fromStart(regexp, _flags = "g") {
+    const flags = mergeFlags(regexp.flags, _flags);
+    return new RegExp(`^(${regexp.source})`, flags);
+  }
+  Regexps2.fromStart = fromStart;
+  function toEnd(regexp, _flags = "g") {
+    const flags = mergeFlags(regexp.flags, _flags);
+    return new RegExp(`(${regexp.source})$`, flags);
+  }
+  Regexps2.toEnd = toEnd;
+  function fromStartToEnd(regexp, _flags = "g") {
+    const flags = mergeFlags(regexp.flags, _flags);
+    return fromStart(toEnd(regexp, flags), flags);
+  }
+  Regexps2.fromStartToEnd = fromStartToEnd;
+  function stringStartsWith(string, _regexp, returnMatches = true, _flags = "g") {
+    const regexp = fromStart(_regexp, _flags);
+    return returnMatches ? string.match(regexp) : regexp.test(string);
+  }
+  Regexps2.stringStartsWith = stringStartsWith;
+  function stringEndsWith(string, _regexp, returnMatches = true, _flags = "g") {
+    const regexp = toEnd(_regexp, _flags);
+    return returnMatches ? string.match(regexp) : regexp.test(string);
+  }
+  Regexps2.stringEndsWith = stringEndsWith;
+  function stringIs(string, _regexp, returnMatches = false, _flags = "g") {
+    const regexp = fromStartToEnd(_regexp, _flags);
+    return returnMatches ? string.match(regexp) : regexp.test(string);
+  }
+  Regexps2.stringIs = stringIs;
+  function fromStrings(strings) {
+    const rootsMap = stringsToRootsMap(strings);
+    const source = sourceFromRootsMap(rootsMap, false);
+    const regexp = new RegExp(source);
+    return regexp;
+  }
+  Regexps2.fromStrings = fromStrings;
+  function escape(string) {
+    return string.replace(/\s/igm, "\\s").replace(/\n/igm, "\\n").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  function stringsToRootsMap(strings, rootsMap = /* @__PURE__ */ new Map()) {
+    const lengthSorted = strings.sort((strA, strB) => strA.length - strB.length);
+    lengthSorted.forEach((string) => {
+      const [firstChar, ...lastChars] = string.split("");
+      const isWordEnd = lastChars.length === 0;
+      if (firstChar === void 0) return;
+      const roots = Array.from(rootsMap.keys());
+      const foundRoot = roots.find((root) => new RegExp(`^(${escape(root)})`).test(string));
+      const subRootsMap = foundRoot !== void 0 ? rootsMap.get(foundRoot)?.subRootsMap : void 0;
+      if (foundRoot === void 0 || subRootsMap === void 0) {
+        const subRootsMap2 = /* @__PURE__ */ new Map();
+        stringsToRootsMap([lastChars.join("")], subRootsMap2);
+        return rootsMap.set(firstChar, { subRootsMap: subRootsMap2, isWordEnd });
+      }
+      stringsToRootsMap([lastChars.join("")], subRootsMap);
+    });
+    return rootsMap;
+  }
+  function sourceFromRootsMap(rootsMap, isOptional) {
+    const rootsMapEntries = Array.from(rootsMap.entries());
+    if (rootsMapEntries.length === 0) return "";
+    const regexpBody = rootsMapEntries.map(([root, rootData]) => {
+      return `${escape(root)}${sourceFromRootsMap(
+        rootData.subRootsMap,
+        rootData.isWordEnd
+      )}`;
+    }).join("|");
+    return isOptional ? `(${regexpBody})?` : `(${regexpBody})`;
+  }
+})(Regexps || (Regexps = {}));
+export {
+  Regexps
+};

package/agnostic/strings/char-codes/index.d.ts

@@ -0,0 +1,17 @@
+export declare namespace CharCodes {
+    type CharCode = number;
+    type B36CharCode = string;
+    function charCodeToB36(charCode: CharCode): B36CharCode;
+    function b36CharCodeToCharCode(b36CharCode: B36CharCode): CharCode;
+    function charToCharCode(char: string): CharCode;
+    function charToB36CharCode(char: string): B36CharCode;
+    function charFromCharCode(charCode: CharCode): string;
+    function charFromB36CharCode(b36CharCode: B36CharCode): string;
+    function toCharCodes(string: string): Array<CharCode>;
+    function toB36CharCodes(string: string): Array<B36CharCode>;
+    function fromCharCodes(charCodes: Array<CharCode>): string;
+    function fromB36CharCodes(b36CharCodes: Array<B36CharCode>): string;
+    function serialize(charCodes: Array<CharCode | B36CharCode>): string;
+    function deserialize(serializedCharCodes: string): Array<CharCode>;
+    function fromSerialized(serializedCharCodes: string): string;
+}

package/agnostic/strings/char-codes/index.js

@@ -0,0 +1,6 @@
+import {
+  CharCodes
+} from "../../../chunks/chunk-34U4HX4V.js";
+export {
+  CharCodes
+};

package/agnostic/strings/index.d.ts

@@ -0,0 +1,14 @@
+import { CharCodes as CharCodesNamespace } from './char-codes';
+import { matches as matchesFunc, matchesSome as matchesSomeFunc, matchesEvery as matchesEveryFunc } from './matches';
+import { replaceAll as replaceAllFunc } from './replace-all';
+import { normalizeIndent as normalizeIndentFunc } from './normalize-indent';
+import { toAlphanum as toAlphanumFunc } from './to-alphanum';
+export declare namespace Strings {
+    export import CharCodes = CharCodesNamespace;
+    const matches: typeof matchesFunc;
+    const matchesSome: typeof matchesSomeFunc;
+    const matchesEvery: typeof matchesEveryFunc;
+    const normalizeIndent: typeof normalizeIndentFunc;
+    const replaceAll: typeof replaceAllFunc;
+    const toAlphanum: typeof toAlphanumFunc;
+}

package/agnostic/strings/index.js

@@ -0,0 +1,32 @@
+import {
+  CharCodes
+} from "../../chunks/chunk-34U4HX4V.js";
+import {
+  normalizeIndent
+} from "../../chunks/chunk-JQXNEJAP.js";
+import {
+  replaceAll
+} from "../../chunks/chunk-MF56TTC5.js";
+import {
+  matches,
+  matchesEvery,
+  matchesSome
+} from "../../chunks/chunk-LQFKUNVQ.js";
+import {
+  toAlphanum
+} from "../../chunks/chunk-COVPTTAD.js";
+
+// src/agnostic/strings/index.ts
+var Strings;
+((Strings2) => {
+  Strings2.CharCodes = CharCodes;
+  Strings2.matches = matches;
+  Strings2.matchesSome = matchesSome;
+  Strings2.matchesEvery = matchesEvery;
+  Strings2.normalizeIndent = normalizeIndent;
+  Strings2.replaceAll = replaceAll;
+  Strings2.toAlphanum = toAlphanum;
+})(Strings || (Strings = {}));
+export {
+  Strings
+};

package/agnostic/strings/matches/index.d.ts

@@ -0,0 +1,3 @@
+export declare function matches(input: string, matcher: string | RegExp): boolean;
+export declare function matchesSome(input: string, matchers: string | RegExp | Array<string | RegExp>): boolean;
+export declare function matchesEvery(input: string, matchers: string | RegExp | Array<string | RegExp>): boolean;

package/agnostic/strings/matches/index.js

@@ -0,0 +1,10 @@
+import {
+  matches,
+  matchesEvery,
+  matchesSome
+} from "../../../chunks/chunk-LQFKUNVQ.js";
+export {
+  matches,
+  matchesEvery,
+  matchesSome
+};

package/agnostic/strings/normalize-indent/index.d.ts

@@ -0,0 +1 @@
+export declare function normalizeIndent(input: string, indentLevel?: number): string;

package/agnostic/strings/normalize-indent/index.js

@@ -0,0 +1,6 @@
+import {
+  normalizeIndent
+} from "../../../chunks/chunk-JQXNEJAP.js";
+export {
+  normalizeIndent
+};

package/{utils/agnostic → agnostic/strings}/replace-all/index.d.ts

@@ -1 +1 @@
-export default function replaceAll(input: string, pattern: string | RegExp, replacer: string | ((substring: string, ...args: any[]) => string), maxOps?: number): string;
+export declare function replaceAll(input: string, pattern: string | RegExp, replacer: string | ((substring: string, ...args: any[]) => string), maxOps?: number): string;

package/agnostic/strings/replace-all/index.js

@@ -0,0 +1,6 @@
+import {
+  replaceAll
+} from "../../../chunks/chunk-MF56TTC5.js";
+export {
+  replaceAll
+};

package/agnostic/strings/to-alphanum/index.d.ts

@@ -0,0 +1 @@
+export declare function toAlphanum(string: string, replacer?: string): string;

package/agnostic/strings/to-alphanum/index.js

@@ -0,0 +1,6 @@
+import {
+  toAlphanum
+} from "../../../chunks/chunk-COVPTTAD.js";
+export {
+  toAlphanum
+};

package/chunks/chunk-32IRF4OP.js

@@ -0,0 +1,9 @@
+// src/agnostic/numbers/round/index.ts
+function round(number, nbDecimals) {
+  const multiplier = Math.pow(10, nbDecimals);
+  return Math.round(number * multiplier) / multiplier;
+}
+
+export {
+  round
+};

package/chunks/chunk-34U4HX4V.js

@@ -0,0 +1,73 @@
+// src/agnostic/strings/char-codes/index.ts
+var CharCodes;
+((CharCodes2) => {
+  function charCodeToB36(charCode) {
+    if (charCode === null) return "\0";
+    return charCode.toString(36);
+  }
+  CharCodes2.charCodeToB36 = charCodeToB36;
+  function b36CharCodeToCharCode(b36CharCode) {
+    if (b36CharCode === null) return 0;
+    const charCode = parseInt(b36CharCode, 36);
+    if (!Number.isInteger(charCode)) return 0;
+    return charCode;
+  }
+  CharCodes2.b36CharCodeToCharCode = b36CharCodeToCharCode;
+  function charToCharCode(char) {
+    const charCode = char.charCodeAt(0);
+    if (!Number.isInteger(charCode)) return 0;
+    return charCode;
+  }
+  CharCodes2.charToCharCode = charToCharCode;
+  function charToB36CharCode(char) {
+    const charCode = charToCharCode(char);
+    return charCodeToB36(charCode);
+  }
+  CharCodes2.charToB36CharCode = charToB36CharCode;
+  function charFromCharCode(charCode) {
+    return String.fromCharCode(charCode);
+  }
+  CharCodes2.charFromCharCode = charFromCharCode;
+  function charFromB36CharCode(b36CharCode) {
+    const charCode = parseInt(b36CharCode, 36);
+    if (!Number.isInteger(charCode)) return "\0";
+    return charFromCharCode(charCode);
+  }
+  CharCodes2.charFromB36CharCode = charFromB36CharCode;
+  function toCharCodes(string) {
+    const chars = string.split("");
+    return chars.map(charToCharCode);
+  }
+  CharCodes2.toCharCodes = toCharCodes;
+  function toB36CharCodes(string) {
+    const chars = string.split("");
+    return chars.map(charToB36CharCode);
+  }
+  CharCodes2.toB36CharCodes = toB36CharCodes;
+  function fromCharCodes(charCodes) {
+    return charCodes.map(charFromCharCode).map((char) => char === null ? "\0" : char).join("");
+  }
+  CharCodes2.fromCharCodes = fromCharCodes;
+  function fromB36CharCodes(b36CharCodes) {
+    return b36CharCodes.map(charFromB36CharCode).map((char) => char === null ? "\0" : char).join("");
+  }
+  CharCodes2.fromB36CharCodes = fromB36CharCodes;
+  function serialize(charCodes) {
+    return charCodes.map((c) => typeof c === "string" ? c : charCodeToB36(c)).join(",");
+  }
+  CharCodes2.serialize = serialize;
+  function deserialize(serializedCharCodes) {
+    const b36CharCodes = serializedCharCodes.split("");
+    return b36CharCodes.map(b36CharCodeToCharCode);
+  }
+  CharCodes2.deserialize = deserialize;
+  function fromSerialized(serializedCharCodes) {
+    const charCodes = deserialize(serializedCharCodes);
+    return fromCharCodes(charCodes);
+  }
+  CharCodes2.fromSerialized = fromSerialized;
+})(CharCodes || (CharCodes = {}));
+
+export {
+  CharCodes
+};

package/chunks/chunk-4GDNHUCZ.js

@@ -0,0 +1,162 @@
+import {
+  wait
+} from "./chunk-DQNJQBC6.js";
+
+// src/agnostic/async/transitions/index.ts
+var Transitions;
+((Transitions2) => {
+  let Ease;
+  ((Ease2) => {
+    Ease2["LINEAR"] = "linear";
+    Ease2["EASE_IN_QUAD"] = "ease-in-quad";
+    Ease2["EASE_OUT_QUAD"] = "ease-out-quad";
+    Ease2["EASE_IN_OUT_QUAD"] = "ease-in-out-quad";
+    Ease2["EASE_IN_CUBIC"] = "ease-in-cubic";
+    Ease2["EASE_OUT_CUBIC"] = "ease-out-cubic";
+    Ease2["EASE_IN_OUT_CUBIC"] = "ease-in-out-cubic";
+    Ease2["EASE_IN_QUART"] = "ease-in-quart";
+    Ease2["EASE_OUT_QUART"] = "ease-out-quart";
+    Ease2["EASE_IN_OUT_QUART"] = "ease-in-out-quart";
+    Ease2["EASE_IN_QUINT"] = "ease-in-quint";
+    Ease2["EASE_OUT_QUINT"] = "ease-out-quint";
+    Ease2["EASE_IN_OUT_QUINT"] = "ease-in-out-quint";
+    Ease2["EASE_IN_SINE"] = "ease-in-sine";
+    Ease2["EASE_OUT_SINE"] = "ease-out-sine";
+    Ease2["EASE_IN_OUT_SINE"] = "ease-in-out-sine";
+    Ease2["EASE_IN_EXPO"] = "ease-in-expo";
+    Ease2["EASE_OUT_EXPO"] = "ease-out-expo";
+    Ease2["EASE_IN_OUT_EXPO"] = "ease-in-out-expo";
+    Ease2["EASE_IN_CIRC"] = "ease-in-circ";
+    Ease2["EASE_OUT_CIRC"] = "ease-out-circ";
+    Ease2["EASE_IN_OUT_CIRC"] = "ease-in-out-circ";
+    Ease2["EASE_IN_BACK"] = "ease-in-back";
+    Ease2["EASE_OUT_BACK"] = "ease-out-back";
+    Ease2["EASE_IN_OUT_BACK"] = "ease-in-out-back";
+    Ease2["EASE_IN_ELASTIC"] = "ease-in-elastic";
+    Ease2["EASE_OUT_ELASTIC"] = "ease-out-elastic";
+    Ease2["EASE_IN_OUT_ELASTIC"] = "ease-in-out-elastic";
+    Ease2["EASE_IN_BOUNCE"] = "ease-in-bounce";
+    Ease2["EASE_OUT_BOUNCE"] = "ease-out-bounce";
+    Ease2["EASE_IN_OUT_BOUNCE"] = "ease-in-out-bounce";
+  })(Ease = Transitions2.Ease || (Transitions2.Ease = {}));
+  async function transition(to, durationMs, callbackOrEase, callback) {
+    const ease = typeof callbackOrEase === "string" ? callbackOrEase : "linear" /* LINEAR */;
+    const easing = Transitions2.easings[ease];
+    if (easing === void 0) return;
+    const actualCallback = callback ?? (typeof callbackOrEase === "function" ? callbackOrEase : void 0);
+    if (actualCallback === void 0) return;
+    const start = Date.now();
+    const timeTable = new Array(to).fill(null).map((_, step) => {
+      const progression = (step + 1) / to;
+      const eased = easing(progression);
+      const time = start + eased * durationMs;
+      return { time, step: eased * to };
+    });
+    for (const { time, step } of timeTable) {
+      const now = Date.now();
+      const delay = time - now;
+      if (delay <= 0) actualCallback(step, time);
+      else {
+        await wait(delay);
+        actualCallback(step, time);
+      }
+    }
+  }
+  Transitions2.transition = transition;
+  const pow = Math.pow;
+  const sqrt = Math.sqrt;
+  const sin = Math.sin;
+  const cos = Math.cos;
+  const PI = Math.PI;
+  const c1 = 1.70158;
+  const c2 = c1 * 1.525;
+  const c3 = c1 + 1;
+  const c4 = 2 * PI / 3;
+  const c5 = 2 * PI / 4.5;
+  const bounceOut = function(x) {
+    const n1 = 7.5625;
+    const d1 = 2.75;
+    if (x < 1 / d1) return n1 * x * x;
+    if (x < 2 / d1) return n1 * (x -= 1.5 / d1) * x + 0.75;
+    if (x < 2.5 / d1) return n1 * (x -= 2.25 / d1) * x + 0.9375;
+    return n1 * (x -= 2.625 / d1) * x + 0.984375;
+  };
+  Transitions2.easingFunctions = {
+    linear: (x) => x,
+    easeInQuad: (x) => x * x,
+    easeOutQuad: (x) => 1 - (1 - x) * (1 - x),
+    easeInOutQuad: (x) => x < 0.5 ? 2 * x * x : 1 - pow(-2 * x + 2, 2) / 2,
+    easeInCubic: (x) => x * x * x,
+    easeOutCubic: (x) => 1 - pow(1 - x, 3),
+    easeInOutCubic: (x) => x < 0.5 ? 4 * x * x * x : 1 - pow(-2 * x + 2, 3) / 2,
+    easeInQuart: (x) => x * x * x * x,
+    easeOutQuart: (x) => 1 - pow(1 - x, 4),
+    easeInOutQuart: (x) => x < 0.5 ? 8 * x * x * x * x : 1 - pow(-2 * x + 2, 4) / 2,
+    easeInQuint: (x) => x * x * x * x * x,
+    easeOutQuint: (x) => 1 - pow(1 - x, 5),
+    easeInOutQuint: (x) => x < 0.5 ? 16 * x * x * x * x * x : 1 - pow(-2 * x + 2, 5) / 2,
+    easeInSine: (x) => 1 - cos(x * PI / 2),
+    easeOutSine: (x) => sin(x * PI / 2),
+    easeInOutSine: (x) => -(cos(PI * x) - 1) / 2,
+    easeInExpo: (x) => x === 0 ? 0 : pow(2, 10 * x - 10),
+    easeOutExpo: (x) => x === 1 ? 1 : 1 - pow(2, -10 * x),
+    easeInOutExpo: (x) => {
+      return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? pow(2, 20 * x - 10) / 2 : (2 - pow(2, -20 * x + 10)) / 2;
+    },
+    easeInCirc: (x) => 1 - sqrt(1 - pow(x, 2)),
+    easeOutCirc: (x) => sqrt(1 - pow(x - 1, 2)),
+    easeInOutCirc: (x) => x < 0.5 ? (1 - sqrt(1 - pow(2 * x, 2))) / 2 : (sqrt(1 - pow(-2 * x + 2, 2)) + 1) / 2,
+    easeInBack: (x) => c3 * x * x * x - c1 * x * x,
+    easeOutBack: (x) => 1 + c3 * pow(x - 1, 3) + c1 * pow(x - 1, 2),
+    easeInOutBack: (x) => x < 0.5 ? pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2) / 2 : (pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2,
+    easeInElastic: (x) => {
+      return x === 0 ? 0 : x === 1 ? 1 : -pow(2, 10 * x - 10) * sin((x * 10 - 10.75) * c4);
+    },
+    easeOutElastic: (x) => {
+      return x === 0 ? 0 : x === 1 ? 1 : pow(2, -10 * x) * sin((x * 10 - 0.75) * c4) + 1;
+    },
+    easeInOutElastic: (x) => {
+      return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? -(pow(2, 20 * x - 10) * sin((20 * x - 11.125) * c5)) / 2 : pow(2, -20 * x + 10) * sin((20 * x - 11.125) * c5) / 2 + 1;
+    },
+    easeInBounce: (x) => 1 - bounceOut(1 - x),
+    easeOutBounce: bounceOut,
+    easeInOutBounce: (x) => x < 0.5 ? (1 - bounceOut(1 - 2 * x)) / 2 : (1 + bounceOut(2 * x - 1)) / 2
+  };
+  Transitions2.easings = {
+    ["linear" /* LINEAR */]: Transitions2.easingFunctions.linear,
+    ["ease-in-quad" /* EASE_IN_QUAD */]: Transitions2.easingFunctions.easeInQuad,
+    ["ease-out-quad" /* EASE_OUT_QUAD */]: Transitions2.easingFunctions.easeOutQuad,
+    ["ease-in-out-quad" /* EASE_IN_OUT_QUAD */]: Transitions2.easingFunctions.easeInOutQuad,
+    ["ease-in-cubic" /* EASE_IN_CUBIC */]: Transitions2.easingFunctions.easeInCubic,
+    ["ease-out-cubic" /* EASE_OUT_CUBIC */]: Transitions2.easingFunctions.easeOutCubic,
+    ["ease-in-out-cubic" /* EASE_IN_OUT_CUBIC */]: Transitions2.easingFunctions.easeInOutCubic,
+    ["ease-in-quart" /* EASE_IN_QUART */]: Transitions2.easingFunctions.easeInQuart,
+    ["ease-out-quart" /* EASE_OUT_QUART */]: Transitions2.easingFunctions.easeOutQuart,
+    ["ease-in-out-quart" /* EASE_IN_OUT_QUART */]: Transitions2.easingFunctions.easeInOutQuart,
+    ["ease-in-quint" /* EASE_IN_QUINT */]: Transitions2.easingFunctions.easeInQuint,
+    ["ease-out-quint" /* EASE_OUT_QUINT */]: Transitions2.easingFunctions.easeOutQuint,
+    ["ease-in-out-quint" /* EASE_IN_OUT_QUINT */]: Transitions2.easingFunctions.easeInOutQuint,
+    ["ease-in-sine" /* EASE_IN_SINE */]: Transitions2.easingFunctions.easeInSine,
+    ["ease-out-sine" /* EASE_OUT_SINE */]: Transitions2.easingFunctions.easeOutSine,
+    ["ease-in-out-sine" /* EASE_IN_OUT_SINE */]: Transitions2.easingFunctions.easeInOutSine,
+    ["ease-in-expo" /* EASE_IN_EXPO */]: Transitions2.easingFunctions.easeInExpo,
+    ["ease-out-expo" /* EASE_OUT_EXPO */]: Transitions2.easingFunctions.easeOutExpo,
+    ["ease-in-out-expo" /* EASE_IN_OUT_EXPO */]: Transitions2.easingFunctions.easeInOutExpo,
+    ["ease-in-circ" /* EASE_IN_CIRC */]: Transitions2.easingFunctions.easeInCirc,
+    ["ease-out-circ" /* EASE_OUT_CIRC */]: Transitions2.easingFunctions.easeOutCirc,
+    ["ease-in-out-circ" /* EASE_IN_OUT_CIRC */]: Transitions2.easingFunctions.easeInOutCirc,
+    ["ease-in-back" /* EASE_IN_BACK */]: Transitions2.easingFunctions.easeInBack,
+    ["ease-out-back" /* EASE_OUT_BACK */]: Transitions2.easingFunctions.easeOutBack,
+    ["ease-in-out-back" /* EASE_IN_OUT_BACK */]: Transitions2.easingFunctions.easeInOutBack,
+    ["ease-in-elastic" /* EASE_IN_ELASTIC */]: Transitions2.easingFunctions.easeInElastic,
+    ["ease-out-elastic" /* EASE_OUT_ELASTIC */]: Transitions2.easingFunctions.easeOutElastic,
+    ["ease-in-out-elastic" /* EASE_IN_OUT_ELASTIC */]: Transitions2.easingFunctions.easeInOutElastic,
+    ["ease-in-bounce" /* EASE_IN_BOUNCE */]: Transitions2.easingFunctions.easeInBounce,
+    ["ease-out-bounce" /* EASE_OUT_BOUNCE */]: Transitions2.easingFunctions.easeOutBounce,
+    ["ease-in-out-bounce" /* EASE_IN_OUT_BOUNCE */]: Transitions2.easingFunctions.easeInOutBounce
+  };
+})(Transitions || (Transitions = {}));
+
+export {
+  Transitions
+};

package/chunks/chunk-4QQBKBYH.js

@@ -0,0 +1,59 @@
+import {
+  isFalsy
+} from "./chunk-QXAJXTXV.js";
+
+// src/agnostic/misc/cast/index.ts
+var Cast;
+((Cast2) => {
+  function toBoolean(value) {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "string") {
+      if (value.toLowerCase().trim() === "true") return true;
+      return false;
+    }
+    return !isFalsy(value);
+  }
+  Cast2.toBoolean = toBoolean;
+  function toNumber(value) {
+    if (typeof value === "number") return value;
+    if (typeof value === "string") return parseFloat(value);
+    return 0;
+  }
+  Cast2.toNumber = toNumber;
+  function toString(value) {
+    if (typeof value === "string") return value;
+    return String(value);
+  }
+  Cast2.toString = toString;
+  function toNull(_value) {
+    return null;
+  }
+  Cast2.toNull = toNull;
+  function toArray(value) {
+    if (Array.isArray(value)) return value;
+    if (typeof value === "object" && value !== null) return Object.entries(value).map((key, value2) => ({ key, value: value2 }));
+    return [value];
+  }
+  Cast2.toArray = toArray;
+  function toNumberArr(value) {
+    const arrValue = toArray(value);
+    return arrValue.map((val) => toNumber(val));
+  }
+  Cast2.toNumberArr = toNumberArr;
+  function toRecord(value) {
+    const record = {};
+    try {
+      Object.keys(value).forEach((key) => {
+        record[key] = value[key];
+      });
+    } catch (err) {
+      return record;
+    }
+    return record;
+  }
+  Cast2.toRecord = toRecord;
+})(Cast || (Cast = {}));
+
+export {
+  Cast
+};

package/chunks/chunk-4VC5PT5T.js

@@ -0,0 +1,13 @@
+// src/agnostic/async/timeout-call/index.ts
+function timeoutCall(callback, timeoutMs) {
+  return new Promise(async (resolve, reject) => {
+    const rejectTimeout = setTimeout(() => reject(false), timeoutMs);
+    const callbackResult = await callback();
+    clearTimeout(rejectTimeout);
+    return resolve(callbackResult);
+  });
+}
+
+export {
+  timeoutCall
+};