@zag-js/utils 1.34.1 → 1.35.0

package/dist/number.js

@@ -0,0 +1,202 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+
+// src/number.ts
+var number_exports = {};
+__export(number_exports, {
+  clampPercent: () => clampPercent,
+  clampValue: () => clampValue,
+  decrementValue: () => decrementValue,
+  getClosestValue: () => getClosestValue,
+  getClosestValueIndex: () => getClosestValueIndex,
+  getMaxValueAtIndex: () => getMaxValueAtIndex,
+  getMinValueAtIndex: () => getMinValueAtIndex,
+  getNextStepValue: () => getNextStepValue,
+  getPercentValue: () => getPercentValue,
+  getPreviousStepValue: () => getPreviousStepValue,
+  getValuePercent: () => getValuePercent,
+  getValueRanges: () => getValueRanges,
+  getValueSetterAtIndex: () => getValueSetterAtIndex,
+  getValueTransformer: () => getValueTransformer,
+  incrementValue: () => incrementValue,
+  isNaN: () => isNaN,
+  isValueAtMax: () => isValueAtMax,
+  isValueAtMin: () => isValueAtMin,
+  isValueWithinRange: () => isValueWithinRange,
+  mod: () => mod,
+  nan: () => nan,
+  roundToDpr: () => roundToDpr,
+  roundToStepPrecision: () => roundToStepPrecision,
+  roundValue: () => roundValue,
+  setValueAtIndex: () => setValueAtIndex,
+  snapValueToStep: () => snapValueToStep,
+  toFixedNumber: () => toFixedNumber,
+  toPx: () => toPx,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(number_exports);
+var { floor, abs, round, min, max, pow, sign } = Math;
+var isNaN = (v) => Number.isNaN(v);
+var nan = (v) => isNaN(v) ? 0 : v;
+var mod = (v, m) => (v % m + m) % m;
+var wrap = (v, vmax) => (v % vmax + vmax) % vmax;
+var getMinValueAtIndex = (i, v, vmin) => i === 0 ? vmin : v[i - 1];
+var getMaxValueAtIndex = (i, v, vmax) => i === v.length - 1 ? vmax : v[i + 1];
+var isValueAtMax = (v, vmax) => nan(v) >= vmax;
+var isValueAtMin = (v, vmin) => nan(v) <= vmin;
+var isValueWithinRange = (v, vmin, vmax) => {
+  const value = nan(v);
+  const minCheck = vmin == null || value >= vmin;
+  const maxCheck = vmax == null || value <= vmax;
+  return minCheck && maxCheck;
+};
+var roundValue = (v, vmin, step) => round((nan(v) - vmin) / step) * step + vmin;
+var clampValue = (v, vmin, vmax) => min(max(nan(v), vmin), vmax);
+var clampPercent = (v) => clampValue(v, 0, 1);
+var getValuePercent = (v, vmin, vmax) => (nan(v) - vmin) / (vmax - vmin);
+var getPercentValue = (p, vmin, vmax, step) => clampValue(roundValue(p * (vmax - vmin) + vmin, vmin, step), vmin, vmax);
+var roundToStepPrecision = (v, step) => {
+  let rv = v;
+  let ss = step.toString();
+  let pi = ss.indexOf(".");
+  let p = pi >= 0 ? ss.length - pi : 0;
+  if (p > 0) {
+    let pw = pow(10, p);
+    rv = round(rv * pw) / pw;
+  }
+  return rv;
+};
+var roundToDpr = (v, dpr) => typeof dpr === "number" ? floor(v * dpr + 0.5) / dpr : round(v);
+var snapValueToStep = (v, vmin, vmax, step) => {
+  const min2 = vmin != null ? Number(vmin) : 0;
+  const max2 = Number(vmax);
+  const remainder = (v - min2) % step;
+  let snapped = abs(remainder) * 2 >= step ? v + sign(remainder) * (step - abs(remainder)) : v - remainder;
+  snapped = roundToStepPrecision(snapped, step);
+  if (!isNaN(min2) && snapped < min2) {
+    snapped = min2;
+  } else if (!isNaN(max2) && snapped > max2) {
+    const stepsInRange = floor((max2 - min2) / step);
+    const largestValidStep = min2 + stepsInRange * step;
+    snapped = stepsInRange <= 0 || largestValidStep < min2 ? max2 : largestValidStep;
+  }
+  return roundToStepPrecision(snapped, step);
+};
+var setValueAtIndex = (vs, i, v) => {
+  if (vs[i] === v) return vs;
+  return [...vs.slice(0, i), v, ...vs.slice(i + 1)];
+};
+function getValueSetterAtIndex(index, ctx) {
+  const minValueAtIndex = getMinValueAtIndex(index, ctx.values, ctx.min);
+  const maxValueAtIndex = getMaxValueAtIndex(index, ctx.values, ctx.max);
+  let nextValues = ctx.values.slice();
+  return function setValue(value) {
+    let nextValue = snapValueToStep(value, minValueAtIndex, maxValueAtIndex, ctx.step);
+    nextValues = setValueAtIndex(nextValues, index, value);
+    nextValues[index] = nextValue;
+    return nextValues;
+  };
+}
+function getNextStepValue(index, ctx) {
+  const nextValue = ctx.values[index] + ctx.step;
+  return getValueSetterAtIndex(index, ctx)(nextValue);
+}
+function getPreviousStepValue(index, ctx) {
+  const nextValue = ctx.values[index] - ctx.step;
+  return getValueSetterAtIndex(index, ctx)(nextValue);
+}
+var getClosestValueIndex = (vs, t) => {
+  let i = vs.findIndex((v) => t - v < 0);
+  if (i === 0) return i;
+  if (i === -1) return vs.length - 1;
+  let vLeft = vs[i - 1];
+  let vRight = vs[i];
+  if (abs(vLeft - t) < abs(vRight - t)) return i - 1;
+  return i;
+};
+var getClosestValue = (vs, t) => vs[getClosestValueIndex(vs, t)];
+var getValueRanges = (vs, vmin, vmax, gap) => vs.map((v, i) => ({
+  min: i === 0 ? vmin : vs[i - 1] + gap,
+  max: i === vs.length - 1 ? vmax : vs[i + 1] - gap,
+  value: v
+}));
+var getValueTransformer = (va, vb) => {
+  const [a, b] = va;
+  const [c, d] = vb;
+  return (v) => a === b || c === d ? c : c + (d - c) / (b - a) * (v - a);
+};
+var toFixedNumber = (v, d = 0, b = 10) => {
+  const pow2 = Math.pow(b, d);
+  return round(v * pow2) / pow2;
+};
+var countDecimals = (value) => {
+  if (!Number.isFinite(value)) return 0;
+  let e = 1, p = 0;
+  while (Math.round(value * e) / e !== value) {
+    e *= 10;
+    p += 1;
+  }
+  return p;
+};
+var decimalOp = (a, op, b) => {
+  let result = op === "+" ? a + b : a - b;
+  if (a % 1 !== 0 || b % 1 !== 0) {
+    const multiplier = 10 ** Math.max(countDecimals(a), countDecimals(b));
+    a = Math.round(a * multiplier);
+    b = Math.round(b * multiplier);
+    result = op === "+" ? a + b : a - b;
+    result /= multiplier;
+  }
+  return result;
+};
+var incrementValue = (v, s) => decimalOp(nan(v), "+", s);
+var decrementValue = (v, s) => decimalOp(nan(v), "-", s);
+var toPx = (v) => typeof v === "number" ? `${v}px` : v;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clampPercent,
+  clampValue,
+  decrementValue,
+  getClosestValue,
+  getClosestValueIndex,
+  getMaxValueAtIndex,
+  getMinValueAtIndex,
+  getNextStepValue,
+  getPercentValue,
+  getPreviousStepValue,
+  getValuePercent,
+  getValueRanges,
+  getValueSetterAtIndex,
+  getValueTransformer,
+  incrementValue,
+  isNaN,
+  isValueAtMax,
+  isValueAtMin,
+  isValueWithinRange,
+  mod,
+  nan,
+  roundToDpr,
+  roundToStepPrecision,
+  roundValue,
+  setValueAtIndex,
+  snapValueToStep,
+  toFixedNumber,
+  toPx,
+  wrap
+});

package/dist/number.mjs

@@ -0,0 +1,151 @@
+import "./chunk-MXGZDBDQ.mjs";
+
+// src/number.ts
+var { floor, abs, round, min, max, pow, sign } = Math;
+var isNaN = (v) => Number.isNaN(v);
+var nan = (v) => isNaN(v) ? 0 : v;
+var mod = (v, m) => (v % m + m) % m;
+var wrap = (v, vmax) => (v % vmax + vmax) % vmax;
+var getMinValueAtIndex = (i, v, vmin) => i === 0 ? vmin : v[i - 1];
+var getMaxValueAtIndex = (i, v, vmax) => i === v.length - 1 ? vmax : v[i + 1];
+var isValueAtMax = (v, vmax) => nan(v) >= vmax;
+var isValueAtMin = (v, vmin) => nan(v) <= vmin;
+var isValueWithinRange = (v, vmin, vmax) => {
+  const value = nan(v);
+  const minCheck = vmin == null || value >= vmin;
+  const maxCheck = vmax == null || value <= vmax;
+  return minCheck && maxCheck;
+};
+var roundValue = (v, vmin, step) => round((nan(v) - vmin) / step) * step + vmin;
+var clampValue = (v, vmin, vmax) => min(max(nan(v), vmin), vmax);
+var clampPercent = (v) => clampValue(v, 0, 1);
+var getValuePercent = (v, vmin, vmax) => (nan(v) - vmin) / (vmax - vmin);
+var getPercentValue = (p, vmin, vmax, step) => clampValue(roundValue(p * (vmax - vmin) + vmin, vmin, step), vmin, vmax);
+var roundToStepPrecision = (v, step) => {
+  let rv = v;
+  let ss = step.toString();
+  let pi = ss.indexOf(".");
+  let p = pi >= 0 ? ss.length - pi : 0;
+  if (p > 0) {
+    let pw = pow(10, p);
+    rv = round(rv * pw) / pw;
+  }
+  return rv;
+};
+var roundToDpr = (v, dpr) => typeof dpr === "number" ? floor(v * dpr + 0.5) / dpr : round(v);
+var snapValueToStep = (v, vmin, vmax, step) => {
+  const min2 = vmin != null ? Number(vmin) : 0;
+  const max2 = Number(vmax);
+  const remainder = (v - min2) % step;
+  let snapped = abs(remainder) * 2 >= step ? v + sign(remainder) * (step - abs(remainder)) : v - remainder;
+  snapped = roundToStepPrecision(snapped, step);
+  if (!isNaN(min2) && snapped < min2) {
+    snapped = min2;
+  } else if (!isNaN(max2) && snapped > max2) {
+    const stepsInRange = floor((max2 - min2) / step);
+    const largestValidStep = min2 + stepsInRange * step;
+    snapped = stepsInRange <= 0 || largestValidStep < min2 ? max2 : largestValidStep;
+  }
+  return roundToStepPrecision(snapped, step);
+};
+var setValueAtIndex = (vs, i, v) => {
+  if (vs[i] === v) return vs;
+  return [...vs.slice(0, i), v, ...vs.slice(i + 1)];
+};
+function getValueSetterAtIndex(index, ctx) {
+  const minValueAtIndex = getMinValueAtIndex(index, ctx.values, ctx.min);
+  const maxValueAtIndex = getMaxValueAtIndex(index, ctx.values, ctx.max);
+  let nextValues = ctx.values.slice();
+  return function setValue(value) {
+    let nextValue = snapValueToStep(value, minValueAtIndex, maxValueAtIndex, ctx.step);
+    nextValues = setValueAtIndex(nextValues, index, value);
+    nextValues[index] = nextValue;
+    return nextValues;
+  };
+}
+function getNextStepValue(index, ctx) {
+  const nextValue = ctx.values[index] + ctx.step;
+  return getValueSetterAtIndex(index, ctx)(nextValue);
+}
+function getPreviousStepValue(index, ctx) {
+  const nextValue = ctx.values[index] - ctx.step;
+  return getValueSetterAtIndex(index, ctx)(nextValue);
+}
+var getClosestValueIndex = (vs, t) => {
+  let i = vs.findIndex((v) => t - v < 0);
+  if (i === 0) return i;
+  if (i === -1) return vs.length - 1;
+  let vLeft = vs[i - 1];
+  let vRight = vs[i];
+  if (abs(vLeft - t) < abs(vRight - t)) return i - 1;
+  return i;
+};
+var getClosestValue = (vs, t) => vs[getClosestValueIndex(vs, t)];
+var getValueRanges = (vs, vmin, vmax, gap) => vs.map((v, i) => ({
+  min: i === 0 ? vmin : vs[i - 1] + gap,
+  max: i === vs.length - 1 ? vmax : vs[i + 1] - gap,
+  value: v
+}));
+var getValueTransformer = (va, vb) => {
+  const [a, b] = va;
+  const [c, d] = vb;
+  return (v) => a === b || c === d ? c : c + (d - c) / (b - a) * (v - a);
+};
+var toFixedNumber = (v, d = 0, b = 10) => {
+  const pow2 = Math.pow(b, d);
+  return round(v * pow2) / pow2;
+};
+var countDecimals = (value) => {
+  if (!Number.isFinite(value)) return 0;
+  let e = 1, p = 0;
+  while (Math.round(value * e) / e !== value) {
+    e *= 10;
+    p += 1;
+  }
+  return p;
+};
+var decimalOp = (a, op, b) => {
+  let result = op === "+" ? a + b : a - b;
+  if (a % 1 !== 0 || b % 1 !== 0) {
+    const multiplier = 10 ** Math.max(countDecimals(a), countDecimals(b));
+    a = Math.round(a * multiplier);
+    b = Math.round(b * multiplier);
+    result = op === "+" ? a + b : a - b;
+    result /= multiplier;
+  }
+  return result;
+};
+var incrementValue = (v, s) => decimalOp(nan(v), "+", s);
+var decrementValue = (v, s) => decimalOp(nan(v), "-", s);
+var toPx = (v) => typeof v === "number" ? `${v}px` : v;
+export {
+  clampPercent,
+  clampValue,
+  decrementValue,
+  getClosestValue,
+  getClosestValueIndex,
+  getMaxValueAtIndex,
+  getMinValueAtIndex,
+  getNextStepValue,
+  getPercentValue,
+  getPreviousStepValue,
+  getValuePercent,
+  getValueRanges,
+  getValueSetterAtIndex,
+  getValueTransformer,
+  incrementValue,
+  isNaN,
+  isValueAtMax,
+  isValueAtMin,
+  isValueWithinRange,
+  mod,
+  nan,
+  roundToDpr,
+  roundToStepPrecision,
+  roundValue,
+  setValueAtIndex,
+  snapValueToStep,
+  toFixedNumber,
+  toPx,
+  wrap
+};

package/dist/object.d.mts

@@ -0,0 +1,9 @@
+declare function compact<T extends Record<string, unknown> | undefined>(obj: T): T;
+declare const json: (v: any) => any;
+declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+type Dict = Record<string | symbol, any>;
+declare function splitProps<T extends Dict>(props: T, keys: (keyof T)[]): Dict[];
+declare const createSplitProps: <T extends Dict>(keys: (keyof T)[]) => <Props extends T>(props: Props) => [T, Omit<Props, keyof T>];
+declare function omit<T extends Record<string, any>>(obj: T, keys: string[]): Omit<T, string | number>;
+
+export { compact, createSplitProps, json, omit, pick, splitProps };

package/dist/object.d.ts

@@ -0,0 +1,9 @@
+declare function compact<T extends Record<string, unknown> | undefined>(obj: T): T;
+declare const json: (v: any) => any;
+declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+type Dict = Record<string | symbol, any>;
+declare function splitProps<T extends Dict>(props: T, keys: (keyof T)[]): Dict[];
+declare const createSplitProps: <T extends Dict>(keys: (keyof T)[]) => <Props extends T>(props: Props) => [T, Omit<Props, keyof T>];
+declare function omit<T extends Record<string, any>>(obj: T, keys: string[]): Omit<T, string | number>;
+
+export { compact, createSplitProps, json, omit, pick, splitProps };

package/dist/object.js

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/object.ts
+var object_exports = {};
+__export(object_exports, {
+  compact: () => compact,
+  createSplitProps: () => createSplitProps,
+  json: () => json,
+  omit: () => omit,
+  pick: () => pick,
+  splitProps: () => splitProps
+});
+module.exports = __toCommonJS(object_exports);
+var import_guard = require("./guard.cjs");
+function compact(obj) {
+  if (!(0, import_guard.isPlainObject)(obj) || obj === void 0) return obj;
+  const keys = Reflect.ownKeys(obj).filter((key) => typeof key === "string");
+  const filtered = {};
+  for (const key of keys) {
+    const value = obj[key];
+    if (value !== void 0) {
+      filtered[key] = compact(value);
+    }
+  }
+  return filtered;
+}
+var json = (v) => JSON.parse(JSON.stringify(v));
+function pick(obj, keys) {
+  const filtered = {};
+  for (const key of keys) {
+    const value = obj[key];
+    if (value !== void 0) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function splitProps(props, keys) {
+  const rest = {};
+  const result = {};
+  const keySet = new Set(keys);
+  const ownKeys = Reflect.ownKeys(props);
+  for (const key of ownKeys) {
+    if (keySet.has(key)) {
+      result[key] = props[key];
+    } else {
+      rest[key] = props[key];
+    }
+  }
+  return [result, rest];
+}
+var createSplitProps = (keys) => {
+  return function split(props) {
+    return splitProps(props, keys);
+  };
+};
+function omit(obj, keys) {
+  return createSplitProps(keys)(obj)[1];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compact,
+  createSplitProps,
+  json,
+  omit,
+  pick,
+  splitProps
+});

package/dist/object.mjs

@@ -0,0 +1,57 @@
+import "./chunk-MXGZDBDQ.mjs";
+
+// src/object.ts
+import { isPlainObject } from "./guard.mjs";
+function compact(obj) {
+  if (!isPlainObject(obj) || obj === void 0) return obj;
+  const keys = Reflect.ownKeys(obj).filter((key) => typeof key === "string");
+  const filtered = {};
+  for (const key of keys) {
+    const value = obj[key];
+    if (value !== void 0) {
+      filtered[key] = compact(value);
+    }
+  }
+  return filtered;
+}
+var json = (v) => JSON.parse(JSON.stringify(v));
+function pick(obj, keys) {
+  const filtered = {};
+  for (const key of keys) {
+    const value = obj[key];
+    if (value !== void 0) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function splitProps(props, keys) {
+  const rest = {};
+  const result = {};
+  const keySet = new Set(keys);
+  const ownKeys = Reflect.ownKeys(props);
+  for (const key of ownKeys) {
+    if (keySet.has(key)) {
+      result[key] = props[key];
+    } else {
+      rest[key] = props[key];
+    }
+  }
+  return [result, rest];
+}
+var createSplitProps = (keys) => {
+  return function split(props) {
+    return splitProps(props, keys);
+  };
+};
+function omit(obj, keys) {
+  return createSplitProps(keys)(obj)[1];
+}
+export {
+  compact,
+  createSplitProps,
+  json,
+  omit,
+  pick,
+  splitProps
+};

package/dist/store.d.mts

@@ -0,0 +1,12 @@
+type StoreListener = VoidFunction;
+type StoreCompareFn<T> = (a: T, b: T) => boolean;
+declare function createStore<T extends Record<string, any>>(initialState: T, compare?: StoreCompareFn<T>): Store<T>;
+interface Store<T extends Record<string, any>> {
+    subscribe: (listener: StoreListener) => () => void;
+    get: <K extends keyof T>(key: K) => T[K];
+    set: <K extends keyof T>(key: K, value: T[K]) => void;
+    update: (updates: Partial<T>) => void;
+    snapshot: () => T;
+}
+
+export { type Store, type StoreCompareFn, type StoreListener, createStore };

package/dist/store.d.ts

@@ -0,0 +1,12 @@
+type StoreListener = VoidFunction;
+type StoreCompareFn<T> = (a: T, b: T) => boolean;
+declare function createStore<T extends Record<string, any>>(initialState: T, compare?: StoreCompareFn<T>): Store<T>;
+interface Store<T extends Record<string, any>> {
+    subscribe: (listener: StoreListener) => () => void;
+    get: <K extends keyof T>(key: K) => T[K];
+    set: <K extends keyof T>(key: K, value: T[K]) => void;
+    update: (updates: Partial<T>) => void;
+    snapshot: () => T;
+}
+
+export { type Store, type StoreCompareFn, type StoreListener, createStore };

package/dist/store.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/store.ts
+var store_exports = {};
+__export(store_exports, {
+  createStore: () => createStore
+});
+module.exports = __toCommonJS(store_exports);
+function createStore(initialState, compare = Object.is) {
+  let state = { ...initialState };
+  const listeners = /* @__PURE__ */ new Set();
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const publish = () => {
+    listeners.forEach((listener) => listener());
+  };
+  const get = (key) => {
+    return state[key];
+  };
+  const set = (key, value) => {
+    if (!compare(state[key], value)) {
+      state[key] = value;
+      publish();
+    }
+  };
+  const update = (updates) => {
+    let hasChanges = false;
+    for (const key in updates) {
+      const value = updates[key];
+      if (value !== void 0 && !compare(state[key], value)) {
+        state[key] = value;
+        hasChanges = true;
+      }
+    }
+    if (hasChanges) {
+      publish();
+    }
+  };
+  const snapshot = () => ({ ...state });
+  return {
+    subscribe,
+    get,
+    set,
+    update,
+    snapshot
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStore
+});

package/dist/store.mjs

@@ -0,0 +1,47 @@
+import "./chunk-MXGZDBDQ.mjs";
+
+// src/store.ts
+function createStore(initialState, compare = Object.is) {
+  let state = { ...initialState };
+  const listeners = /* @__PURE__ */ new Set();
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const publish = () => {
+    listeners.forEach((listener) => listener());
+  };
+  const get = (key) => {
+    return state[key];
+  };
+  const set = (key, value) => {
+    if (!compare(state[key], value)) {
+      state[key] = value;
+      publish();
+    }
+  };
+  const update = (updates) => {
+    let hasChanges = false;
+    for (const key in updates) {
+      const value = updates[key];
+      if (value !== void 0 && !compare(state[key], value)) {
+        state[key] = value;
+        hasChanges = true;
+      }
+    }
+    if (hasChanges) {
+      publish();
+    }
+  };
+  const snapshot = () => ({ ...state });
+  return {
+    subscribe,
+    get,
+    set,
+    update,
+    snapshot
+  };
+}
+export {
+  createStore
+};

package/dist/timers.d.mts

@@ -0,0 +1,26 @@
+interface TimerBaseContext {
+    startMs: number;
+    deltaMs: number;
+}
+interface TimerContext extends TimerBaseContext {
+    now: number;
+}
+type TimerContextFn = (ctx: TimerContext) => boolean | void;
+declare class Timer {
+    #private;
+    private readonly onTick;
+    private frameId;
+    private pausedAtMs;
+    private context;
+    constructor(onTick: TimerContextFn);
+    private cancelFrame;
+    setStartMs: (startMs: number) => void;
+    get elapsedMs(): number;
+    start: () => void;
+    pause: () => void;
+    stop: () => void;
+}
+declare function setRafInterval(fn: (ctx: TimerBaseContext) => void, intervalMs: number): () => void;
+declare function setRafTimeout(fn: () => void, delayMs: number): () => void;
+
+export { Timer, type TimerBaseContext, type TimerContextFn, setRafInterval, setRafTimeout };