@vuu-ui/vuu-utils 3.1.0-beta.3 → 3.1.0-beta.4

package/src/vendor/@dnd-kit/react/sortable.d.ts

@@ -0,0 +1,26 @@
+import { Data } from '@dnd-kit/abstract';
+import { SortableInput, Sortable } from '@dnd-kit/dom/sortable';
+export { isSortable } from '@dnd-kit/dom/sortable';
+import { RefObject, MutableRefObject } from 'react';
+
+type Ref<T> = RefObject<T | null | undefined> | MutableRefObject<T>;
+type RefOrValue<T> = T | Ref<T> | null | undefined;
+
+interface UseSortableInput<T extends Data = Data> extends Omit<SortableInput<T>, 'handle' | 'element' | 'target'> {
+    handle?: RefOrValue<Element>;
+    element?: RefOrValue<Element>;
+    target?: RefOrValue<Element>;
+}
+declare function useSortable<T extends Data = Data>(input: UseSortableInput<T>): {
+    sortable: Sortable<T>;
+    readonly isDragging: boolean;
+    readonly isDropping: boolean;
+    readonly isDragSource: boolean;
+    readonly isDropTarget: boolean;
+    handleRef: (element: Element | null) => void;
+    ref: (element: Element | null) => void;
+    sourceRef: (element: Element | null) => void;
+    targetRef: (element: Element | null) => void;
+};
+
+export { type UseSortableInput, useSortable };

package/src/vendor/@dnd-kit/react/sortable.js

@@ -0,0 +1,175 @@
+import { useCallback } from 'react';
+import { batch, deepEqual } from '../state/dist/index.js';
+import { defaultSortableTransition, Sortable } from '../dom/sortable.js';
+export { isSortable } from '../dom/sortable.js';
+import { useInstance } from './index.js';
+import { useDeepSignal, useOnValueChange, useIsomorphicLayoutEffect, useImmediateEffect, useOnElementChange } from './hooks.js';
+import { currentValue } from './utilities.js';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function useSortable(input) {
+  const {
+    accept,
+    collisionDetector,
+    collisionPriority,
+    id,
+    data,
+    element,
+    handle,
+    index,
+    group,
+    disabled,
+    feedback,
+    modifiers,
+    sensors,
+    target,
+    type
+  } = input;
+  const transition = __spreadValues(__spreadValues({}, defaultSortableTransition), input.transition);
+  const sortable = useInstance((manager) => {
+    return new Sortable(
+      __spreadProps(__spreadValues({}, input), {
+        transition,
+        register: false,
+        handle: currentValue(handle),
+        element: currentValue(element),
+        target: currentValue(target),
+        feedback
+      }),
+      manager
+    );
+  });
+  const trackedSortable = useDeepSignal(sortable, shouldUpdateSynchronously);
+  useOnValueChange(id, () => sortable.id = id);
+  useIsomorphicLayoutEffect(() => {
+    batch(() => {
+      sortable.group = group;
+      sortable.index = index;
+    });
+  }, [sortable, group, index]);
+  useOnValueChange(type, () => sortable.type = type);
+  useOnValueChange(
+    accept,
+    () => sortable.accept = accept,
+    void 0,
+    deepEqual
+  );
+  useOnValueChange(data, () => data && (sortable.data = data));
+  useOnValueChange(
+    index,
+    () => {
+      var _a;
+      if (((_a = sortable.manager) == null ? void 0 : _a.dragOperation.status.idle) && (transition == null ? void 0 : transition.idle)) {
+        sortable.refreshShape();
+      }
+    },
+    useImmediateEffect
+  );
+  useOnElementChange(handle, (handle2) => sortable.handle = handle2);
+  useOnElementChange(element, (element2) => sortable.element = element2);
+  useOnElementChange(target, (target2) => sortable.target = target2);
+  useOnValueChange(disabled, () => sortable.disabled = disabled === true);
+  useOnValueChange(sensors, () => sortable.sensors = sensors);
+  useOnValueChange(
+    collisionDetector,
+    () => sortable.collisionDetector = collisionDetector
+  );
+  useOnValueChange(
+    collisionPriority,
+    () => sortable.collisionPriority = collisionPriority
+  );
+  useOnValueChange(feedback, () => sortable.feedback = feedback != null ? feedback : "default");
+  useOnValueChange(
+    transition,
+    () => sortable.transition = transition,
+    void 0,
+    deepEqual
+  );
+  useOnValueChange(
+    modifiers,
+    () => sortable.modifiers = modifiers,
+    void 0,
+    deepEqual
+  );
+  useOnValueChange(
+    input.alignment,
+    () => sortable.alignment = input.alignment
+  );
+  return {
+    sortable: trackedSortable,
+    get isDragging() {
+      return trackedSortable.isDragging;
+    },
+    get isDropping() {
+      return trackedSortable.isDropping;
+    },
+    get isDragSource() {
+      return trackedSortable.isDragSource;
+    },
+    get isDropTarget() {
+      return trackedSortable.isDropTarget;
+    },
+    handleRef: useCallback(
+      (element2) => {
+        sortable.handle = element2 != null ? element2 : void 0;
+      },
+      [sortable]
+    ),
+    ref: useCallback(
+      (element2) => {
+        var _a, _b;
+        if (!element2 && ((_a = sortable.element) == null ? void 0 : _a.isConnected) && !((_b = sortable.manager) == null ? void 0 : _b.dragOperation.status.idle)) {
+          return;
+        }
+        sortable.element = element2 != null ? element2 : void 0;
+      },
+      [sortable]
+    ),
+    sourceRef: useCallback(
+      (element2) => {
+        var _a, _b;
+        if (!element2 && ((_a = sortable.source) == null ? void 0 : _a.isConnected) && !((_b = sortable.manager) == null ? void 0 : _b.dragOperation.status.idle)) {
+          return;
+        }
+        sortable.source = element2 != null ? element2 : void 0;
+      },
+      [sortable]
+    ),
+    targetRef: useCallback(
+      (element2) => {
+        var _a, _b;
+        if (!element2 && ((_a = sortable.target) == null ? void 0 : _a.isConnected) && !((_b = sortable.manager) == null ? void 0 : _b.dragOperation.status.idle)) {
+          return;
+        }
+        sortable.target = element2 != null ? element2 : void 0;
+      },
+      [sortable]
+    )
+  };
+}
+function shouldUpdateSynchronously(key, oldValue, newValue) {
+  if (key === "isDragSource" && !newValue && oldValue) return true;
+  return false;
+}
+
+export { useSortable };
+//# sourceMappingURL=sortable.js.map
+//# sourceMappingURL=sortable.js.map

package/src/vendor/@dnd-kit/react/utilities.d.ts

@@ -0,0 +1,7 @@
+import { RefObject, MutableRefObject } from 'react';
+
+type Ref<T> = RefObject<T | null | undefined> | MutableRefObject<T>;
+type RefOrValue<T> = T | Ref<T> | null | undefined;
+declare function currentValue<T>(value: RefOrValue<T>): NonNullable<T> | undefined;
+
+export { type RefOrValue, currentValue };

package/src/vendor/@dnd-kit/react/utilities.js

@@ -0,0 +1,18 @@
+// src/utilities/currentValue.ts
+function isRef(value) {
+  return value != null && typeof value === "object" && "current" in value;
+}
+function currentValue(value) {
+  var _a;
+  if (value == null) {
+    return void 0;
+  }
+  if (isRef(value)) {
+    return (_a = value.current) != null ? _a : void 0;
+  }
+  return value;
+}
+
+export { currentValue };
+//# sourceMappingURL=utilities.js.map
+//# sourceMappingURL=utilities.js.map

package/src/vendor/@dnd-kit/state/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { ReadonlySignal, effect } from '@preact/signals-core';
+export { ReadonlySignal, Signal, batch, effect, signal, untracked } from '@preact/signals-core';
+
+declare function computed<T>(compute: () => T, comparator?: (a: T, b: T) => boolean): ReadonlySignal<T>;
+
+declare function deepEqual<T>(a: T, b: T): boolean;
+
+declare function reactive<This, Value>({ get }: ClassAccessorDecoratorTarget<This, Value>, _: ClassAccessorDecoratorContext<This, Value>): ClassAccessorDecoratorResult<This, Value>;
+declare function derived<This, Return>(target: (this: This) => Return, _: ClassGetterDecoratorContext<This, Return>): (this: This) => Return;
+/**
+ * Make a field enumerable (or non‑enumerable) on every instance.
+ *
+ *   @enumerable(true)  – enumerable
+ *   @enumerable(false) – non‑enumerable
+ */
+declare function enumerable(enumerable?: boolean): (_value: unknown, context: ClassFieldDecoratorContext<any, any> | ClassGetterDecoratorContext<any, any> | ClassSetterDecoratorContext<any, any> | ClassAccessorDecoratorContext<any, any> | ClassMethodDecoratorContext<any, any>) => void;
+
+type CleanupFunction = () => void;
+type Effect = Parameters<typeof effect>[0];
+
+declare function effects(...entries: Effect[]): CleanupFunction;
+
+type WithHistory<T> = {
+    current: T;
+    initial: T;
+    previous: T | undefined;
+};
+declare class ValueHistory<T> implements WithHistory<T> {
+    #private;
+    protected readonly defaultValue: T;
+    protected readonly equals: (a: T, b: T) => boolean;
+    constructor(defaultValue: T, equals?: (a: T, b: T) => boolean);
+    /** Current value */
+    get current(): T;
+    /** Initial value */
+    get initial(): T;
+    /** Previous value */
+    get previous(): T | undefined;
+    /** Set the current value */
+    set current(value: T);
+    /** Reset the state to the initial value */
+    reset(value?: T): void;
+}
+
+declare function snapshot<T extends object>(value: T): T;
+
+declare class WeakStore<WeakKey extends object, Key extends string | number | symbol, Value extends Record<Key, any>> {
+    #private;
+    get(key: WeakKey | undefined, id: Key): Value | undefined;
+    set(key: WeakKey | undefined, id: Key, value: Value): Map<Key, Value> | undefined;
+    clear(key: WeakKey | undefined): void;
+}
+
+export { type CleanupFunction, type Effect, ValueHistory, WeakStore, type WithHistory, computed, deepEqual, derived, effects, enumerable, reactive, snapshot };

package/src/vendor/@dnd-kit/state/dist/index.js

@@ -0,0 +1,328 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var __decoratorStart = (base) => {
+  var _a2;
+  return [, , , __create((_a2 = base == null ? void 0 : base[__knownSymbol("metadata")]) != null ? _a2 : null)];
+};
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Signal: () => import_signals_core6.Signal,
+  ValueHistory: () => ValueHistory,
+  WeakStore: () => WeakStore,
+  batch: () => import_signals_core6.batch,
+  computed: () => computed,
+  deepEqual: () => deepEqual,
+  derived: () => derived,
+  effect: () => import_signals_core6.effect,
+  effects: () => effects,
+  enumerable: () => enumerable,
+  reactive: () => reactive,
+  signal: () => import_signals_core6.signal,
+  snapshot: () => snapshot,
+  untracked: () => import_signals_core6.untracked
+});
+module.exports = __toCommonJS(src_exports);
+var import_signals_core6 = require("../../../@preact/signals-core/dist/signals-core.js");
+
+// src/computed.ts
+var import_signals_core = require("../../../@preact/signals-core/dist/signals-core.js");
+function computed(compute, comparator) {
+  if (comparator) {
+    let previousValue;
+    return (0, import_signals_core.computed)(() => {
+      const value = compute();
+      if (value && previousValue && comparator(previousValue, value)) {
+        return previousValue;
+      }
+      previousValue = value;
+      return value;
+    });
+  }
+  return (0, import_signals_core.computed)(compute);
+}
+
+// src/comparators.ts
+function deepEqual(a, b) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (a === null || b === null) return false;
+  if (typeof a === "function" && typeof b === "function") {
+    return a === b;
+  }
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) {
+      return false;
+    }
+    for (const value of a) {
+      if (!b.has(value)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) {
+      return false;
+    }
+    const hasDifferentValues = a.some(
+      (value, index) => !deepEqual(value, b[index])
+    );
+    return !hasDifferentValues;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    const hasDifferentValues = aKeys.some(
+      (key) => !deepEqual(a[key], b[key])
+    );
+    return !hasDifferentValues;
+  }
+  return false;
+}
+
+// src/decorators.ts
+var import_signals_core2 = require("../../../@preact/signals-core/dist/signals-core.js");
+function reactive({ get }, _) {
+  return {
+    init(value) {
+      return (0, import_signals_core2.signal)(value);
+    },
+    get() {
+      const current = get.call(this);
+      return current.value;
+    },
+    set(newValue) {
+      const current = get.call(this);
+      if (current.peek() === newValue) {
+        return;
+      }
+      current.value = newValue;
+    }
+  };
+}
+function derived(target, _) {
+  const map = /* @__PURE__ */ new WeakMap();
+  return function() {
+    let result = map.get(this);
+    if (!result) {
+      result = computed(target.bind(this));
+      map.set(this, result);
+    }
+    return result.value;
+  };
+}
+function enumerable(enumerable2 = true) {
+  return function(_value, context) {
+    context.addInitializer(function() {
+      const host = context.kind === "field" ? this : context.static ? this : Object.getPrototypeOf(this);
+      const descriptor = Object.getOwnPropertyDescriptor(host, context.name);
+      if (descriptor) {
+        Object.defineProperty(host, context.name, __spreadProps(__spreadValues({}, descriptor), { enumerable: enumerable2 }));
+      }
+    });
+  };
+}
+
+// src/effects.ts
+var import_signals_core3 = require("../../../@preact/signals-core/dist/signals-core.js");
+function effects(...entries) {
+  const effects2 = entries.map(import_signals_core3.effect);
+  return () => effects2.forEach((cleanup) => cleanup());
+}
+
+// src/history.ts
+var import_signals_core4 = require("../../../@preact/signals-core/dist/signals-core.js");
+var _previous_dec, _initial_dec, _current_dec, _current_dec2, _previous_dec2, _initial_dec2, _init, _initial, _a, initial_get, initial_set, _ValueHistory_instances, _previous, _b, previous_get, previous_set, _current, _c, current_get, current_set;
+_initial_dec2 = [reactive], _previous_dec2 = [reactive], _current_dec2 = [reactive], _current_dec = [enumerable()], _initial_dec = [enumerable()], _previous_dec = [enumerable()];
+var ValueHistory = class {
+  constructor(defaultValue, equals = Object.is) {
+    this.defaultValue = defaultValue;
+    this.equals = equals;
+    __runInitializers(_init, 5, this);
+    __privateAdd(this, _ValueHistory_instances);
+    // @ts-ignore
+    __privateAdd(this, _initial, __runInitializers(_init, 8, this)), __runInitializers(_init, 11, this);
+    // @ts-ignore
+    __privateAdd(this, _previous, __runInitializers(_init, 12, this)), __runInitializers(_init, 15, this);
+    // @ts-ignore
+    __privateAdd(this, _current, __runInitializers(_init, 16, this)), __runInitializers(_init, 19, this);
+    this.reset = this.reset.bind(this);
+    this.reset();
+  }
+  get current() {
+    return __privateGet(this, _ValueHistory_instances, current_get);
+  }
+  get initial() {
+    return __privateGet(this, _ValueHistory_instances, initial_get);
+  }
+  get previous() {
+    return __privateGet(this, _ValueHistory_instances, previous_get);
+  }
+  /** Set the current value */
+  set current(value) {
+    const current = (0, import_signals_core4.untracked)(() => __privateGet(this, _ValueHistory_instances, current_get));
+    if (value && current && this.equals(current, value)) {
+      return;
+    }
+    (0, import_signals_core4.batch)(() => {
+      if (!__privateGet(this, _ValueHistory_instances, initial_get)) {
+        __privateSet(this, _ValueHistory_instances, value, initial_set);
+      }
+      __privateSet(this, _ValueHistory_instances, current, previous_set);
+      __privateSet(this, _ValueHistory_instances, value, current_set);
+    });
+  }
+  /** Reset the state to the initial value */
+  reset(value = this.defaultValue) {
+    (0, import_signals_core4.batch)(() => {
+      __privateSet(this, _ValueHistory_instances, void 0, previous_set);
+      __privateSet(this, _ValueHistory_instances, value, initial_set);
+      __privateSet(this, _ValueHistory_instances, value, current_set);
+    });
+  }
+};
+_init = __decoratorStart(null);
+_initial = new WeakMap();
+_ValueHistory_instances = new WeakSet();
+_previous = new WeakMap();
+_current = new WeakMap();
+_a = __decorateElement(_init, 20, "#initial", _initial_dec2, _ValueHistory_instances, _initial), initial_get = _a.get, initial_set = _a.set;
+_b = __decorateElement(_init, 20, "#previous", _previous_dec2, _ValueHistory_instances, _previous), previous_get = _b.get, previous_set = _b.set;
+_c = __decorateElement(_init, 20, "#current", _current_dec2, _ValueHistory_instances, _current), current_get = _c.get, current_set = _c.set;
+__decorateElement(_init, 2, "current", _current_dec, ValueHistory);
+__decorateElement(_init, 2, "initial", _initial_dec, ValueHistory);
+__decorateElement(_init, 2, "previous", _previous_dec, ValueHistory);
+__decoratorMetadata(_init, ValueHistory);
+
+// src/snapshot.ts
+var import_signals_core5 = require("../../../@preact/signals-core/dist/signals-core.js");
+function snapshot(value) {
+  return (0, import_signals_core5.untracked)(() => {
+    const output = {};
+    for (const key in value) {
+      output[key] = value[key];
+    }
+    return output;
+  });
+}
+
+// src/store.ts
+var _store;
+var WeakStore = class {
+  constructor() {
+    __privateAdd(this, _store, /* @__PURE__ */ new WeakMap());
+  }
+  get(key, id) {
+    var _a2;
+    return key ? (_a2 = __privateGet(this, _store).get(key)) == null ? void 0 : _a2.get(id) : void 0;
+  }
+  set(key, id, value) {
+    var _a2;
+    if (!key) return;
+    if (!__privateGet(this, _store).has(key)) __privateGet(this, _store).set(key, /* @__PURE__ */ new Map());
+    return (_a2 = __privateGet(this, _store).get(key)) == null ? void 0 : _a2.set(id, value);
+  }
+  clear(key) {
+    var _a2;
+    return key ? (_a2 = __privateGet(this, _store).get(key)) == null ? void 0 : _a2.clear() : void 0;
+  }
+};
+_store = new WeakMap();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Signal,
+  ValueHistory,
+  WeakStore,
+  batch,
+  computed,
+  deepEqual,
+  derived,
+  effect,
+  effects,
+  enumerable,
+  reactive,
+  signal,
+  snapshot,
+  untracked
+});

package/src/vendor/@dnd-kit/state/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@dnd-kit/state",
+  "version": "0.1.21",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "license": "MIT",
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --external react",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts --external react",
+    "test": "bun test",
+    "lint": "TIMING=1 eslint src/**/*.ts* --fix",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  },
+  "dependencies": {
+    "@preact/signals-core": "^1.10.0",
+    "tslib": "^2.6.2"
+  },
+  "devDependencies": {
+    "@dnd-kit/eslint-config": "*",
+    "bun-types": "^1.2.15",
+    "eslint": "^8.38.0",
+    "tsup": "8.3.0",
+    "typescript": "^5.5.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/vendor/@preact/signals-core/dist/signals-core.js

@@ -0,0 +1 @@
+var i=Symbol.for("preact-signals");function t(){if(!(h>1)){var i,t=!1;while(void 0!==n){var r=n;n=void 0;s++;while(void 0!==r){var o=r.o;r.o=void 0;r.f&=-3;if(!(8&r.f)&&u(r))try{r.c()}catch(r){if(!t){i=r;t=!0}}r=o}}s=0;h--;if(t)throw i}else h--}var r=void 0;function o(i){var t=r;r=void 0;try{return i()}finally{r=t}}var n=void 0,h=0,s=0,f=0;function v(i){if(void 0!==r){var t=i.n;if(void 0===t||t.t!==r){t={i:0,S:i,p:r.s,n:void 0,t:r,e:void 0,x:void 0,r:t};if(void 0!==r.s)r.s.n=t;r.s=t;i.n=t;if(32&r.f)i.S(t);return t}else if(-1===t.i){t.i=0;if(void 0!==t.n){t.n.p=t.p;if(void 0!==t.p)t.p.n=t.n;t.p=r.s;t.n=void 0;r.s.n=t;r.s=t}return t}}}function e(i,t){this.v=i;this.i=0;this.n=void 0;this.t=void 0;this.W=null==t?void 0:t.watched;this.Z=null==t?void 0:t.unwatched}e.prototype.brand=i;e.prototype.h=function(){return!0};e.prototype.S=function(i){var t=this,r=this.t;if(r!==i&&void 0===i.e){i.x=r;this.t=i;if(void 0!==r)r.e=i;else o(function(){var i;null==(i=t.W)||i.call(t)})}};e.prototype.U=function(i){var t=this;if(void 0!==this.t){var r=i.e,n=i.x;if(void 0!==r){r.x=n;i.e=void 0}if(void 0!==n){n.e=r;i.x=void 0}if(i===this.t){this.t=n;if(void 0===n)o(function(){var i;null==(i=t.Z)||i.call(t)})}}};e.prototype.subscribe=function(i){var t=this;return x(function(){var o=t.value,n=r;r=void 0;try{i(o)}finally{r=n}})};e.prototype.valueOf=function(){return this.value};e.prototype.toString=function(){return this.value+""};e.prototype.toJSON=function(){return this.value};e.prototype.peek=function(){var i=r;r=void 0;try{return this.value}finally{r=i}};Object.defineProperty(e.prototype,"value",{get:function(){var i=v(this);if(void 0!==i)i.i=this.i;return this.v},set:function(i){if(i!==this.v){if(s>100)throw new Error("Cycle detected");this.v=i;this.i++;f++;h++;try{for(var r=this.t;void 0!==r;r=r.x)r.t.N()}finally{t()}}}});function u(i){for(var t=i.s;void 0!==t;t=t.n)if(t.S.i!==t.i||!t.S.h()||t.S.i!==t.i)return!0;return!1}function d(i){for(var t=i.s;void 0!==t;t=t.n){var r=t.S.n;if(void 0!==r)t.r=r;t.S.n=t;t.i=-1;if(void 0===t.n){i.s=t;break}}}function c(i){var t=i.s,r=void 0;while(void 0!==t){var o=t.p;if(-1===t.i){t.S.U(t);if(void 0!==o)o.n=t.n;if(void 0!==t.n)t.n.p=o}else r=t;t.S.n=t.r;if(void 0!==t.r)t.r=void 0;t=o}i.s=r}function a(i,t){e.call(this,void 0);this.x=i;this.s=void 0;this.g=f-1;this.f=4;this.W=null==t?void 0:t.watched;this.Z=null==t?void 0:t.unwatched}a.prototype=new e;a.prototype.h=function(){this.f&=-3;if(1&this.f)return!1;if(32==(36&this.f))return!0;this.f&=-5;if(this.g===f)return!0;this.g=f;this.f|=1;if(this.i>0&&!u(this)){this.f&=-2;return!0}var i=r;try{d(this);r=this;var t=this.x();if(16&this.f||this.v!==t||0===this.i){this.v=t;this.f&=-17;this.i++}}catch(i){this.v=i;this.f|=16;this.i++}r=i;c(this);this.f&=-2;return!0};a.prototype.S=function(i){if(void 0===this.t){this.f|=36;for(var t=this.s;void 0!==t;t=t.n)t.S.S(t)}e.prototype.S.call(this,i)};a.prototype.U=function(i){if(void 0!==this.t){e.prototype.U.call(this,i);if(void 0===this.t){this.f&=-33;for(var t=this.s;void 0!==t;t=t.n)t.S.U(t)}}};a.prototype.N=function(){if(!(2&this.f)){this.f|=6;for(var i=this.t;void 0!==i;i=i.x)i.t.N()}};Object.defineProperty(a.prototype,"value",{get:function(){if(1&this.f)throw new Error("Cycle detected");var i=v(this);this.h();if(void 0!==i)i.i=this.i;if(16&this.f)throw this.v;return this.v}});function l(i){var o=i.u;i.u=void 0;if("function"==typeof o){h++;var n=r;r=void 0;try{o()}catch(t){i.f&=-2;i.f|=8;y(i);throw t}finally{r=n;t()}}}function y(i){for(var t=i.s;void 0!==t;t=t.n)t.S.U(t);i.x=void 0;i.s=void 0;l(i)}function w(i){if(r!==this)throw new Error("Out-of-order effect");c(this);r=i;this.f&=-2;if(8&this.f)y(this);t()}function p(i){this.x=i;this.u=void 0;this.s=void 0;this.o=void 0;this.f=32}p.prototype.c=function(){var i=this.S();try{if(8&this.f)return;if(void 0===this.x)return;var t=this.x();if("function"==typeof t)this.u=t}finally{i()}};p.prototype.S=function(){if(1&this.f)throw new Error("Cycle detected");this.f|=1;this.f&=-9;l(this);d(this);h++;var i=r;r=this;return w.bind(this,i)};p.prototype.N=function(){if(!(2&this.f)){this.f|=2;this.o=n;n=this}};p.prototype.d=function(){this.f|=8;if(!(1&this.f))y(this)};p.prototype.dispose=function(){this.d()};function x(i){var t=new p(i);try{t.c()}catch(i){t.d();throw i}var r=t.d.bind(t);r[Symbol.dispose]=r;return r}exports.Signal=e;exports.batch=function(i){if(h>0)return i();h++;try{return i()}finally{t()}};exports.computed=function(i,t){return new a(i,t)};exports.effect=x;exports.signal=function(i,t){return new e(i,t)};exports.untracked=o;//# sourceMappingURL=signals-core.js.map