@semio/utils 0.0.0

package/dist/index.mjs

@@ -0,0 +1,883 @@
+// src/log.ts
+function log(value) {
+  console.log(value);
+}
+
+// src/namespace.ts
+function getLookup(namespace, id) {
+  return `${namespace === "default" ? "default." : `${namespace}.`}${id}`;
+}
+function getNamespace(lookup) {
+  if (lookup.includes(".")) {
+    return lookup.split(".")[0];
+  } else return "default";
+}
+function getId(lookup) {
+  if (lookup.includes(".")) {
+    return lookup.split(".")[1];
+  } else return lookup;
+}
+
+// src/player.ts
+function reset(player, stamp) {
+  const p = { ...player };
+  const nowVal = now();
+  p._currentTime = nowVal;
+  p._previousTime = nowVal;
+  p.stamp = stamp ? stamp : 0;
+  return p;
+}
+function now() {
+  return (typeof performance === "undefined" ? Date : performance).now();
+}
+function update(player, coldStart) {
+  const p = { ...player };
+  const duration = p.duration;
+  const t = now();
+  p._previousTime = coldStart ? t : p._currentTime;
+  p._currentTime = t;
+  const currentInBounds = p.stamp >= p.bounds[0] && p.stamp <= p.bounds[1];
+  const currentViewportCenter = (p.viewport[1] + p.viewport[0]) / 2;
+  const nearViewportCenterCurrent = Math.abs(p.stamp - currentViewportCenter) < 0.01;
+  const delta = (p._currentTime - p._previousTime) * p.timescale / duration;
+  const updatedStamp = p.stamp + delta;
+  const [start, end] = currentInBounds ? p.bounds : [0, 1];
+  let attachOverride = false;
+  if (updatedStamp > end) {
+    if (p.playback === "loop") {
+      p.stamp = start;
+    } else if (p.playback === "bounce") {
+      p.stamp = end;
+      p.timescale *= -1;
+    } else {
+      p.stamp = start;
+      p.running = false;
+    }
+    attachOverride = true;
+  } else if (currentInBounds && updatedStamp < start) {
+    if (p.playback === "loop") {
+      p.stamp = start;
+      if (p.timescale < 0) {
+        p.running = false;
+      }
+    } else if (p.playback === "bounce") {
+      p.stamp = start;
+      p.timescale *= -1;
+    } else {
+      p.stamp = start;
+      p.running = false;
+    }
+    attachOverride = true;
+  } else {
+    p.stamp = updatedStamp;
+  }
+  const newNearViewportCenter = Math.abs(p.stamp - currentViewportCenter) < 0.01;
+  const boundsInsideViewport = p.viewport[0] <= p.bounds[0] || p.viewport[1] >= p.bounds[1];
+  if (p.running && !boundsInsideViewport && (nearViewportCenterCurrent || newNearViewportCenter || attachOverride)) {
+    p.viewport = getFittedViewport(p.stamp, p.viewport);
+  } else if (p.running && !boundsInsideViewport && !newNearViewportCenter) {
+    const oomphOffset = currentViewportCenter < p.stamp ? delta : 0;
+    const idealViewport = getFittedViewport(p.stamp + oomphOffset, p.viewport);
+    p.viewport = [
+      p.viewport[0] * 0.6 + idealViewport[0] * 0.4,
+      p.viewport[1] * 0.6 + idealViewport[1] * 0.4
+    ];
+  }
+  return p;
+}
+function setBounds(player, bounds) {
+  const p = { ...player };
+  p.bounds = bounds;
+  return p;
+}
+function setViewport(player, viewport) {
+  const p = { ...player };
+  p.viewport = viewport;
+  return p;
+}
+function play(player, speed) {
+  const p = { ...player };
+  p.running = true;
+  p.timescale = speed ?? 1;
+  if (p.playback === "once" && p.stamp === p.bounds[1]) {
+    p.stamp = p.bounds[0];
+  }
+  return p;
+}
+function pause(player) {
+  const p = { ...player };
+  p.running = false;
+  p.timescale = 0;
+  return p;
+}
+function seek(player, stamp) {
+  const p = reset(player, stamp);
+  p.viewport = getFittedViewport(stamp, p.viewport);
+  return p;
+}
+function setDuration(player, duration) {
+  const p = { ...player };
+  p.duration = duration;
+  return p;
+}
+function newPlayer() {
+  return {
+    running: false,
+    _previousTime: now(),
+    _currentTime: now(),
+    stamp: 0,
+    timescale: 0,
+    bounds: [0, 1],
+    playback: "loop",
+    viewport: [0, 1],
+    duration: 1e3
+  };
+}
+var getFittedViewport = (playhead, proposedViewport) => {
+  const viewportWidth = proposedViewport[1] - proposedViewport[0];
+  const proposedLeft = playhead - viewportWidth / 2;
+  const proposedRight = playhead + viewportWidth / 2;
+  if (proposedLeft >= 0 && proposedRight <= 1) {
+    return [playhead - viewportWidth / 2, playhead + viewportWidth / 2];
+  } else if (proposedLeft < 0) {
+    return [0, viewportWidth];
+  } else {
+    return [1 - viewportWidth, 1];
+  }
+};
+
+// src/player-store.ts
+import { createContext } from "react";
+import { create } from "zustand";
+import { subscribeWithSelector } from "zustand/middleware";
+import { enableMapSet, produce } from "immer";
+import * as THREE from "three";
+THREE.Object3D.DEFAULT_UP.set(0, 0, 1);
+enableMapSet();
+var PlayerSlice = (set) => ({
+  player: newPlayer(),
+  // Set the duration of the player
+  updateDuration: (duration) => {
+    set(
+      produce((state) => {
+        state.player.duration = duration;
+      })
+    );
+  },
+  // Set the timescale of the animation playback
+  updateTimescale: (speed) => {
+    set(
+      produce((state) => {
+        state.player.timescale = speed;
+      })
+    );
+  },
+  // Set the time of the animation
+  resetPlayer: (time) => {
+    set((state) => ({ player: reset(state.player, time) }));
+  },
+  // Play the animation
+  playPlayer: (speed) => {
+    set((state) => ({ player: play(state.player, speed) }));
+  },
+  // Pause the animation
+  pausePlayer: () => {
+    set((state) => ({ player: pause(state.player) }));
+  },
+  // Update the timer
+  updatePlayer: (coldStart) => {
+    set((state) => ({
+      player: update(state.player, coldStart ?? false)
+    }));
+  },
+  // Set the player bounds
+  updatePlayerBounds: (start, end) => {
+    set((state) => ({
+      player: setBounds(state.player, [start, end])
+    }));
+  },
+  updatePlayerBound: (bound, time) => {
+    set((state) => {
+      const t = time ?? state.player.stamp;
+      if (bound === "start" && state.player.bounds[1] <= t) {
+        return {
+          player: setBounds(state.player, [state.player.bounds[1], t])
+        };
+      } else if (bound === "end" && state.player.bounds[0] >= t) {
+        return {
+          player: setBounds(state.player, [t, state.player.bounds[0]])
+        };
+      } else if (bound === "start") {
+        return {
+          player: setBounds(state.player, [t, state.player.bounds[1]])
+        };
+      } else {
+        return {
+          player: setBounds(state.player, [state.player.bounds[0], t])
+        };
+      }
+    });
+  },
+  // Set the player viewport
+  updatePlayerViewport: (start, end) => {
+    set((state) => ({
+      player: setViewport(state.player, [start, end])
+    }));
+  },
+  updatePlayerViewportCenter: (time) => {
+    set((state) => ({
+      player: seek(state.player, time ?? state.player.stamp)
+    }));
+  },
+  updatePlayerViewportBound: (bound, time) => {
+    set((state) => {
+      if (bound === "start" && state.player.viewport[1] <= time) {
+        return {
+          player: setViewport(state.player, [state.player.viewport[1], time])
+        };
+      } else if (bound === "end" && state.player.viewport[0] >= time) {
+        return {
+          player: setViewport(state.player, [time, state.player.viewport[0]])
+        };
+      } else if (bound === "start") {
+        return {
+          player: setViewport(state.player, [time, state.player.viewport[1]])
+        };
+      } else {
+        return {
+          player: setViewport(state.player, [state.player.viewport[0], time])
+        };
+      }
+    });
+  }
+});
+var usePlayerStore = create()(
+  subscribeWithSelector(PlayerSlice)
+);
+var PlayerContext = createContext(null);
+
+// src/animated-values.ts
+function instanceOfRawBoolean(object) {
+  return typeof object === "boolean";
+}
+function instanceOfRawNumber(object) {
+  return typeof object === "number";
+}
+function instanceOfRawString(object) {
+  return typeof object === "string";
+}
+function instanceOfRawVector3(object) {
+  return object.x !== void 0 && object.y !== void 0 && object.z !== void 0;
+}
+function instanceOfRawVector2(object) {
+  return object.x !== void 0 && object.y !== void 0;
+}
+function instanceOfRawEuler(object) {
+  return object.x !== void 0 && object.y !== void 0 && object.z !== void 0;
+}
+function instanceOfRawColor(object) {
+  return object.r !== void 0 && object.g !== void 0 && object.b !== void 0 || object.h !== void 0 && object.s !== void 0 && object.l !== void 0;
+}
+function instanceOfRawRGB(object) {
+  return object.r !== void 0 && object.g !== void 0 && object.b !== void 0;
+}
+function instanceOfRawHSL(object) {
+  return object.h !== void 0 && object.s !== void 0 && object.l !== void 0;
+}
+function isRawObject(value) {
+  if (instanceOfRawVector3(value) || instanceOfRawVector2(value) || instanceOfRawEuler(value) || instanceOfRawColor(value) || instanceOfRawRGB(value) || instanceOfRawHSL(value))
+    return true;
+  return false;
+}
+
+// src/time.ts
+var numberToDurationString = (duration) => {
+  let milliseconds = Math.floor(duration % 1e3 / 10).toString();
+  let seconds = Math.floor(duration / 1e3 % 60);
+  let minutes = Math.floor(duration / (1e3 * 60) % 60);
+  minutes = minutes < 10 ? `0${minutes.toString()}` : minutes;
+  seconds = seconds < 10 ? `0${seconds.toString()}` : seconds;
+  milliseconds = milliseconds.length === 1 ? `0${milliseconds}` : milliseconds;
+  return `${minutes.toString()}:${seconds.toString()}:${milliseconds}`;
+};
+
+// src/pairwise.ts
+function pairwise(arr) {
+  return arr.slice(1).map((_, i) => [arr[i], arr[i + 1]]);
+}
+
+// src/lazy.ts
+import { useState, useEffect } from "react";
+function useLazy(value, timeout) {
+  const [lazy, setLazy] = useState(value);
+  const [timeoutValue, setTimeoutValue] = useState(null);
+  useEffect(() => {
+    if (value) {
+      setLazy(value);
+      if (timeoutValue) {
+        clearTimeout(timeoutValue);
+      }
+    } else {
+      const timer = setTimeout(() => {
+        setLazy(value);
+        setTimeoutValue(timer);
+      }, timeout);
+      return () => {
+        if (timeoutValue) {
+          clearTimeout(timeoutValue);
+        }
+      };
+    }
+  }, [value, timeout, timeoutValue]);
+  return lazy;
+}
+
+// src/hexagon.ts
+function getHexagonPath(x, y, size, height) {
+  const path = [
+    `${x.toString()},${(y - height / 2).toString()}`,
+    `${x.toString()},${(y - size / 2).toString()}`,
+    `${(x + size * 0.433).toString()},${(y - size / 4).toString()}`,
+    `${(x + size * 0.433).toString()},${(y + size / 4).toString()}`,
+    `${x.toString()},${(y + size / 2).toString()}`,
+    `${x.toString()},${(y + height / 2).toString()}`,
+    `${x.toString()},${(y + size / 2).toString()}`,
+    `${(x - size * 0.433).toString()},${(y + size / 4).toString()}`,
+    `${(x - size * 0.433).toString()},${(y - size / 4).toString()}`,
+    `${x.toString()},${(y - size / 2).toString()}`
+  ].join("L");
+  return `M${path}Z`;
+}
+function getDegenerateHexagonPath(x, y, size, height) {
+  const path = [
+    `${x.toString()},${(y - height / 2).toString()}`,
+    `${x.toString()},${(y - size / 2).toString()}`,
+    `${x.toString()},${(y - size / 4).toString()}`,
+    `${x.toString()},${(y + size / 4).toString()}`,
+    `${x.toString()},${(y + size / 2).toString()}`,
+    `${x.toString()},${(y + height / 2).toString()}`,
+    `${x.toString()},${(y + size / 2).toString()}`,
+    `${x.toString()},${(y + size / 4).toString()}`,
+    `${x.toString()},${(y - size / 4).toString()}`,
+    `${x.toString()},${(y - size / 2).toString()}`
+  ].join("L");
+  return `M${path}Z`;
+}
+
+// src/closest-frame.ts
+function closestFrame(completion, count) {
+  const frameIdx = Math.round(completion * count);
+  return frameIdx / count;
+}
+
+// src/angles.ts
+var toDegrees = (radians) => radians * (180 / Math.PI);
+var toRadians = (degrees) => degrees * (Math.PI / 180);
+
+// src/colors.ts
+import Color from "color";
+var regex = /(\d+),\s*(\d+),\s*(\d+)/;
+var hexToRgba = (hex, alpha2) => {
+  const h = hex.replace(/^#/, "");
+  let r, g, b;
+  if (h.length === 3) {
+    r = parseInt(h[0] + h[0], 16);
+    g = parseInt(h[1] + h[1], 16);
+    b = parseInt(h[2] + h[2], 16);
+  } else if (h.length === 6) {
+    r = parseInt(h.substring(0, 2), 16);
+    g = parseInt(h.substring(2, 4), 16);
+    b = parseInt(h.substring(4, 6), 16);
+  } else {
+    throw new Error("Invalid HEX color.");
+  }
+  return `rgba(${r.toFixed(0)}, ${g.toFixed(0)}, ${b.toFixed(0)}, ${alpha2.toString()})`;
+};
+var rgbToRgba = (rgb, alpha2) => {
+  const result = regex.exec(rgb);
+  if (!result) {
+    throw new Error("Invalid RGB color.");
+  }
+  const r = parseInt(result[1]);
+  const g = parseInt(result[2]);
+  const b = parseInt(result[3]);
+  return `rgba(${r.toFixed()}, ${g.toFixed()}, ${b.toFixed()}, ${alpha2.toFixed(2)})`;
+};
+var hslToRgba = (hsl, alpha2) => {
+  const result = regex.exec(hsl);
+  if (!result) {
+    throw new Error("Invalid HSL color.");
+  }
+  const h = parseInt(result[1]) / 360;
+  const s = parseInt(result[2]) / 100;
+  const l = parseInt(result[3]) / 100;
+  let r, g, b;
+  if (s === 0) {
+    r = l;
+    g = l;
+    b = l;
+  } else {
+    const hue2rgb = (p2, q2, t) => {
+      let t1 = t;
+      if (t1 < 0) t1 += 1;
+      if (t1 > 1) t1 -= 1;
+      if (t1 < 1 / 6) return p2 + (q2 - p2) * 6 * t1;
+      if (t1 < 1 / 2) return q2;
+      if (t1 < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t1) * 6;
+      return p2;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  return `rgba(${Math.round(r * 255).toFixed(0)}, ${Math.round(g * 255).toFixed(0)}, ${Math.round(b * 255).toFixed(0)}, ${alpha2.toString()})`;
+};
+var alpha = (color, opacity) => {
+  if (color.startsWith("#")) {
+    return hexToRgba(color, opacity);
+  } else if (color.startsWith("rgb")) {
+    return rgbToRgba(color, opacity);
+  } else if (color.startsWith("hsl")) {
+    return hslToRgba(color, opacity);
+  } else {
+    throw new Error("Unsupported color format.");
+  }
+};
+function altColor(color, factor) {
+  if (factor > 0) {
+    return Color(color).lighten(factor).hex();
+  } else {
+    return Color(color).darken(-1 * factor).hex();
+  }
+}
+function hexToRgbArray(color) {
+  const c = Color(color);
+  return [c.red(), c.green(), c.blue()];
+}
+function rawRGBToHex({ r, g, b }) {
+  return Color({ r, g, b }).hex();
+}
+function rawHSLToHex({ h, s, l }) {
+  return Color({ h, s, l }).hex();
+}
+
+// src/use-deep.ts
+import { useRef } from "react";
+import deepEqual from "deep-equal";
+function useDeepSelector(selector) {
+  const prev = useRef();
+  return (state) => {
+    const next = selector(state);
+    return deepEqual(prev.current, next) ? prev.current : prev.current = next;
+  };
+}
+function useDeep(initializer, dependencies) {
+  const prevValue = useRef();
+  const prevDependencies = useRef([]);
+  return deepEqual(prevDependencies.current, dependencies) ? prevValue.current : prevValue.current = initializer();
+}
+
+// src/use-media-query.ts
+import { useState as useState2, useEffect as useEffect2 } from "react";
+var useMediaQuery = (query) => {
+  const [matches, setMatches] = useState2(false);
+  useEffect2(() => {
+    const mediaQueryList = window.matchMedia(query);
+    const documentChangeHandler = () => setMatches(mediaQueryList.matches);
+    setMatches(mediaQueryList.matches);
+    mediaQueryList.addEventListener("change", documentChangeHandler);
+    return () => {
+      mediaQueryList.removeEventListener("change", documentChangeHandler);
+    };
+  }, [query]);
+  return matches;
+};
+
+// src/json.ts
+function replacer(key, value) {
+  if (value instanceof Map) {
+    return {
+      dataType: "Map",
+      value: Array.from(value.entries())
+      // or with spread: value: [...value]
+    };
+  }
+  return value;
+}
+function isSerializedMap(value) {
+  return typeof value === "object" && value !== null && "dataType" in value && value.dataType === "Map" && Array.isArray(value.value);
+}
+function reviver(key, value) {
+  if (isSerializedMap(value)) {
+    return new Map(value.value);
+  }
+  return value;
+}
+function stringifyMapped(value) {
+  return JSON.stringify(value, replacer, 2);
+}
+function parseToMapped(json) {
+  return JSON.parse(json, reviver);
+}
+function parseJSONFileEvent(event, fn) {
+  const files = event.target.files;
+  if (files && files.length > 0) {
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      if (e.target?.result) {
+        const json = e.target.result;
+        const data = parseToMapped(json);
+        if (Array.isArray(data)) {
+          data.forEach((d) => {
+            fn(d);
+          });
+        } else {
+          fn(data);
+        }
+      }
+    };
+    reader.readAsText(files[0]);
+  }
+}
+
+// src/download.ts
+function downloadJSONFile(data, filename) {
+  const json = stringifyMapped(data);
+  const blob = new Blob([json], { type: "application/json" });
+  downloadBlob(blob, filename);
+}
+function downloadBlob(blob, filename) {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+}
+
+// src/points-to-path.ts
+function pointsToPath(points, close) {
+  if (close) {
+    return [
+      points.map((p, i) => `${i === 0 ? "M" : "L"} ${p[0].toString()} ${p[1].toString()}`).join(" "),
+      " Z"
+    ].join(" ");
+  } else {
+    return points.map((p, i) => `${i === 0 ? "M" : "L"} ${p[0].toString()} ${p[1].toString()}`).join(" ");
+  }
+}
+
+// src/euler.ts
+function eulerToRotationMatrix(euler) {
+  const [z, y, x] = euler;
+  const cz = Math.cos(z);
+  const sz = Math.sin(z);
+  const cy = Math.cos(y);
+  const sy = Math.sin(y);
+  const cx = Math.cos(x);
+  const sx = Math.sin(x);
+  return [
+    [cz * cy, cz * sy * sx - sz * cx, cz * sy * cx + sz * sx],
+    [sz * cy, sz * sy * sx + cz * cx, sz * sy * cx - cz * sx],
+    [-sy, cy * sx, cy * cx]
+  ];
+}
+function rotationMatrixToAngle(R) {
+  const trace = R[0][0] + R[1][1] + R[2][2];
+  return Math.acos((trace - 1) / 2);
+}
+function angularDistance(euler1, euler2) {
+  const R1 = eulerToRotationMatrix(euler1);
+  const R2 = eulerToRotationMatrix(euler2);
+  const R12 = [
+    [
+      R1[0][0] * R2[0][0] + R1[0][1] * R2[1][0] + R1[0][2] * R2[2][0],
+      R1[0][0] * R2[0][1] + R1[0][1] * R2[1][1] + R1[0][2] * R2[2][1],
+      R1[0][0] * R2[0][2] + R1[0][1] * R2[1][2] + R1[0][2] * R2[2][2]
+    ],
+    [
+      R1[1][0] * R2[0][0] + R1[1][1] * R2[1][0] + R1[1][2] * R2[2][0],
+      R1[1][0] * R2[0][1] + R1[1][1] * R2[1][1] + R1[1][2] * R2[2][1],
+      R1[1][0] * R2[0][2] + R1[1][1] * R2[1][2] + R1[1][2] * R2[2][2]
+    ],
+    [
+      R1[2][0] * R2[0][0] + R1[2][1] * R2[1][0] + R1[2][2] * R2[2][0],
+      R1[2][0] * R2[0][1] + R1[2][1] * R2[1][1] + R1[2][2] * R2[2][1],
+      R1[2][0] * R2[0][2] + R1[2][1] * R2[1][2] + R1[2][2] * R2[2][2]
+    ]
+  ];
+  return rotationMatrixToAngle(R12);
+}
+
+// src/overlapping-segments.ts
+function overlappingSegments(original) {
+  const output = [];
+  original.toSorted((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]).forEach(([start, end]) => {
+    const lastIndex = output.length - 1;
+    if (output.length > 0 && output[lastIndex][1] >= start) {
+      output[lastIndex][1] = Math.max(output[lastIndex][1], end);
+    } else {
+      output.push([start, end]);
+    }
+  });
+  return output;
+}
+
+// src/result.ts
+var Result = class _Result {
+  constructor(value, error) {
+    this.value = value;
+    this.error = error;
+  }
+  /**
+   * Creates a new Result instance with a success value
+   * @template T The type of the success value
+   * @template E The type of the error value
+   * @param value The success value
+   * @returns A new Result instance containing the success value
+   */
+  static Ok(value) {
+    return new _Result(value);
+  }
+  /**
+   * Creates a new Result instance with an error value
+   * @template T The type of the success value
+   * @template E The type of the error value
+   * @param error The error value
+   * @returns A new Result instance containing the error value
+   */
+  static Err(error) {
+    return new _Result(void 0, error);
+  }
+  /**
+   * Creates a new Result instance with an Error created from a string message
+   * @template T The type of the success value
+   * @param errorMessage The error message string
+   * @returns A new Result instance containing an Error with the given message
+   */
+  static ErrFromStr(errorMessage) {
+    const error = new Error(errorMessage);
+    return new _Result(void 0, error);
+  }
+  /**
+   * Maps the success value to a new value using the provided function
+   * @template U The type of the new success value
+   * @param fn The mapping function
+   * @returns A new Result with the mapped success value or the original error
+   */
+  map(fn) {
+    return this.isOk() ? _Result.Ok(fn(this.value)) : _Result.Err(this.error);
+  }
+  /**
+   * Maps the error value to a new error using the provided function
+   * @template F The type of the new error value
+   * @param fn The mapping function
+   * @returns A new Result with the mapped error value or the original success value
+   */
+  mapErr(fn) {
+    return this.isOk() ? _Result.Ok(this.value) : _Result.Err(fn(this.error));
+  }
+  /**
+   * Chains a computation that returns a Result
+   * @template U The type of the new success value
+   * @param fn The function to chain
+   * @returns The result of the chained function or the original error
+   */
+  andThen(fn) {
+    return this.isOk() ? fn(this.value) : _Result.Err(this.error);
+  }
+  /**
+   * Applies one of two functions depending on whether the Result is Ok or Err
+   * @template U The type of the return value
+   * @param ok The function to apply to the success value
+   * @param err The function to apply to the error value
+   * @returns The result of applying the appropriate function
+   */
+  match(ok, err) {
+    return this.isOk() ? ok(this.value) : err(this.error);
+  }
+  /**
+   * Checks if the Result contains a success value
+   * @returns true if the Result contains a success value, false otherwise
+   */
+  isOk() {
+    return this.error === void 0;
+  }
+  /**
+   * Checks if the Result contains an error value
+   * @returns true if the Result contains an error value, false otherwise
+   */
+  isErr() {
+    return this.error !== void 0;
+  }
+  /**
+   * Extracts the success value from the Result
+   * @throws Error if the Result contains an error value
+   * @returns The success value
+   */
+  unwrap() {
+    if (this.isErr()) {
+      throw new Error(`Tried to unwrap an Err value${this.error ? `: ${String(this.error)}` : ""}`);
+    }
+    return this.value;
+  }
+  /**
+   * Returns the success value or a default value if the Result contains an error
+   * @param defaultValue The value to return if the Result contains an error
+   * @returns The success value or the default value
+   */
+  unwrapOr(defaultValue) {
+    return this.isOk() ? this.value : defaultValue;
+  }
+  /**
+   * Extracts the error value from the Result
+   * @throws Error if the Result contains a success value
+   * @returns The error value
+   */
+  unwrapErr() {
+    if (this.isOk()) {
+      throw new Error("Tried to unwrap an Ok value");
+    }
+    return this.error;
+  }
+  /**
+   * Converts the Result to a string representation
+   * @returns A string representation of the Result
+   */
+  toString() {
+    return this.isOk() ? `Ok(${typeof this.value === "object" ? JSON.stringify(this.value) : String(this.value)})` : `Err(${typeof this.error === "object" ? JSON.stringify(this.error) : String(this.error)})`;
+  }
+};
+
+// src/progress.ts
+function incrementProgress(progress, message, increment = 1) {
+  return {
+    ...progress,
+    current: progress.current + increment,
+    message: message ?? progress.message
+  };
+}
+function composeProgress(progresses) {
+  let current = 0;
+  let total = 0;
+  let message = "";
+  progresses.forEach((progress) => {
+    current += progress.current;
+    total += progress.total;
+    if (progress.message) {
+      message += `${progress.message}
+`;
+    }
+  });
+  message = message.trim();
+  return { current, total, message };
+}
+function composeProgressiveResult(progressiveResults, expectedIds) {
+  const fullProgress = composeProgress(progressiveResults.map((pr) => pr.progress));
+  let fullResult;
+  if (progressiveResults.some((res) => res.result?.isErr() ?? true)) {
+    fullResult = Result.ErrFromStr("There was an error");
+  } else {
+    const metas = progressiveResults.flatMap((res) => {
+      const innerRes = res.result?.unwrap();
+      if (Array.isArray(innerRes)) return innerRes;
+      return [innerRes];
+    });
+    if (expectedIds) {
+      const data = expectedIds.map((id) => metas.find((m) => "id" in (m || {}) && m?.id === id));
+      if (fullProgress.current >= fullProgress.total && data.some((m) => m === void 0 || m === null)) {
+        fullResult = Result.ErrFromStr("Some documents not found");
+      } else {
+        fullResult = Result.Ok(data);
+      }
+    } else {
+      fullResult = Result.Ok(metas);
+    }
+  }
+  return { result: fullResult, progress: fullProgress };
+}
+
+// src/regex.ts
+var EMAIL = /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i;
+
+// src/map-deep-equal.ts
+import isDeepEqual from "fast-deep-equal";
+function isMapDeepEqual(map1, map2) {
+  if (map1.size !== map2.size) return false;
+  for (const [key, value] of map1.entries()) {
+    if (!map2.has(key)) return false;
+    const otherValue = map2.get(key);
+    if (!isDeepEqual(value, otherValue)) {
+      return false;
+    }
+  }
+  return true;
+}
+export {
+  EMAIL,
+  PlayerContext,
+  PlayerSlice,
+  Result,
+  alpha,
+  altColor,
+  angularDistance,
+  closestFrame,
+  composeProgress,
+  composeProgressiveResult,
+  downloadBlob,
+  downloadJSONFile,
+  eulerToRotationMatrix,
+  getDegenerateHexagonPath,
+  getHexagonPath,
+  getId,
+  getLookup,
+  getNamespace,
+  hexToRgbArray,
+  hexToRgba,
+  hslToRgba,
+  incrementProgress,
+  instanceOfRawBoolean,
+  instanceOfRawColor,
+  instanceOfRawEuler,
+  instanceOfRawHSL,
+  instanceOfRawNumber,
+  instanceOfRawRGB,
+  instanceOfRawString,
+  instanceOfRawVector2,
+  instanceOfRawVector3,
+  isMapDeepEqual,
+  isRawObject,
+  log,
+  newPlayer,
+  now,
+  numberToDurationString,
+  overlappingSegments,
+  pairwise,
+  parseJSONFileEvent,
+  parseToMapped,
+  pause,
+  play,
+  pointsToPath,
+  rawHSLToHex,
+  rawRGBToHex,
+  reset,
+  rgbToRgba,
+  rotationMatrixToAngle,
+  seek,
+  setBounds,
+  setDuration,
+  setViewport,
+  stringifyMapped,
+  toDegrees,
+  toRadians,
+  update,
+  useDeep,
+  useDeepSelector,
+  useLazy,
+  useMediaQuery,
+  usePlayerStore
+};