fix: prevent asset conflicts between React and Grid.js versions

Add coexistence checks to all enqueue methods to prevent loading
both React and Grid.js assets simultaneously.

Changes:
- ReactAdmin.php: Only enqueue React assets when ?react=1
- Init.php: Skip Grid.js when React active on admin pages
- Form.php, Coupon.php, Access.php: Restore classic assets when ?react=0
- Customer.php, Product.php, License.php: Add coexistence checks

Now the toggle between Classic and React versions works correctly.

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

node_modules/valtio/esm/index.d.ts

@@ -0,0 +1,2 @@
+export { useSnapshot } from './react';
+export { ref, proxy, getVersion, subscribe, snapshot, unstable_buildProxyFunction, } from './vanilla';

node_modules/valtio/esm/index.js

@@ -0,0 +1,59 @@
+import { useRef, useCallback, useEffect, useMemo, useDebugValue } from 'react';
+import { isChanged, createProxy, affectedToPathList } from 'proxy-compare';
+import useSyncExternalStoreExports from 'use-sync-external-store/shim/index.js';
+import { subscribe, snapshot } from 'valtio/vanilla';
+export { getVersion, proxy, ref, snapshot, subscribe, unstable_buildProxyFunction } from 'valtio/vanilla';
+
+const { useSyncExternalStore } = useSyncExternalStoreExports;
+const useAffectedDebugValue = (state, affected) => {
+  const pathList = useRef();
+  useEffect(() => {
+    pathList.current = affectedToPathList(state, affected);
+  });
+  useDebugValue(pathList.current);
+};
+function useSnapshot(proxyObject, options) {
+  const notifyInSync = options == null ? void 0 : options.sync;
+  const lastSnapshot = useRef();
+  const lastAffected = useRef();
+  let inRender = true;
+  const currSnapshot = useSyncExternalStore(
+    useCallback(
+      (callback) => {
+        const unsub = subscribe(proxyObject, callback, notifyInSync);
+        callback();
+        return unsub;
+      },
+      [proxyObject, notifyInSync]
+    ),
+    () => {
+      const nextSnapshot = snapshot(proxyObject);
+      try {
+        if (!inRender && lastSnapshot.current && lastAffected.current && !isChanged(
+          lastSnapshot.current,
+          nextSnapshot,
+          lastAffected.current,
+          /* @__PURE__ */ new WeakMap()
+        )) {
+          return lastSnapshot.current;
+        }
+      } catch (e) {
+      }
+      return nextSnapshot;
+    },
+    () => snapshot(proxyObject)
+  );
+  inRender = false;
+  const currAffected = /* @__PURE__ */ new WeakMap();
+  useEffect(() => {
+    lastSnapshot.current = currSnapshot;
+    lastAffected.current = currAffected;
+  });
+  if ((import.meta.env && import.meta.env.MODE) !== "production") {
+    useAffectedDebugValue(currSnapshot, currAffected);
+  }
+  const proxyCache = useMemo(() => /* @__PURE__ */ new WeakMap(), []);
+  return createProxy(currSnapshot, currAffected, proxyCache);
+}
+
+export { useSnapshot };

node_modules/valtio/esm/index.mjs

@@ -0,0 +1,59 @@
+import { useRef, useCallback, useEffect, useMemo, useDebugValue } from 'react';
+import { isChanged, createProxy, affectedToPathList } from 'proxy-compare';
+import useSyncExternalStoreExports from 'use-sync-external-store/shim/index.js';
+import { subscribe, snapshot } from 'valtio/vanilla';
+export { getVersion, proxy, ref, snapshot, subscribe, unstable_buildProxyFunction } from 'valtio/vanilla';
+
+const { useSyncExternalStore } = useSyncExternalStoreExports;
+const useAffectedDebugValue = (state, affected) => {
+  const pathList = useRef();
+  useEffect(() => {
+    pathList.current = affectedToPathList(state, affected);
+  });
+  useDebugValue(pathList.current);
+};
+function useSnapshot(proxyObject, options) {
+  const notifyInSync = options == null ? void 0 : options.sync;
+  const lastSnapshot = useRef();
+  const lastAffected = useRef();
+  let inRender = true;
+  const currSnapshot = useSyncExternalStore(
+    useCallback(
+      (callback) => {
+        const unsub = subscribe(proxyObject, callback, notifyInSync);
+        callback();
+        return unsub;
+      },
+      [proxyObject, notifyInSync]
+    ),
+    () => {
+      const nextSnapshot = snapshot(proxyObject);
+      try {
+        if (!inRender && lastSnapshot.current && lastAffected.current && !isChanged(
+          lastSnapshot.current,
+          nextSnapshot,
+          lastAffected.current,
+          /* @__PURE__ */ new WeakMap()
+        )) {
+          return lastSnapshot.current;
+        }
+      } catch (e) {
+      }
+      return nextSnapshot;
+    },
+    () => snapshot(proxyObject)
+  );
+  inRender = false;
+  const currAffected = /* @__PURE__ */ new WeakMap();
+  useEffect(() => {
+    lastSnapshot.current = currSnapshot;
+    lastAffected.current = currAffected;
+  });
+  if ((import.meta.env && import.meta.env.MODE) !== "production") {
+    useAffectedDebugValue(currSnapshot, currAffected);
+  }
+  const proxyCache = useMemo(() => /* @__PURE__ */ new WeakMap(), []);
+  return createProxy(currSnapshot, currAffected, proxyCache);
+}
+
+export { useSnapshot };

node_modules/valtio/esm/macro.d.ts

@@ -0,0 +1,3 @@
+export declare function useProxy<T extends object>(proxyObject: T): void;
+declare const _default: any;
+export default _default;

node_modules/valtio/esm/macro.js

@@ -0,0 +1,39 @@
+import { addNamed } from '@babel/helper-module-imports';
+import * as t from '@babel/types';
+import { createMacro, MacroError } from 'babel-plugin-macros';
+
+const macro = ({ references }) => {
+  var _a;
+  (_a = references.useProxy) == null ? void 0 : _a.forEach((path) => {
+    var _a2, _b, _c, _d, _e, _f;
+    const hook = addNamed(path, "useSnapshot", "valtio");
+    const proxy = (_b = (_a2 = path.parentPath) == null ? void 0 : _a2.get("arguments.0")) == null ? void 0 : _b.node;
+    if (!t.isIdentifier(proxy))
+      throw new MacroError("no proxy object");
+    const snap = t.identifier(`valtio_macro_snap_${proxy.name}`);
+    (_d = (_c = path.parentPath) == null ? void 0 : _c.parentPath) == null ? void 0 : _d.replaceWith(
+      t.variableDeclaration("const", [
+        t.variableDeclarator(snap, t.callExpression(hook, [proxy]))
+      ])
+    );
+    let inFunction = 0;
+    (_f = (_e = path.parentPath) == null ? void 0 : _e.getFunctionParent()) == null ? void 0 : _f.traverse({
+      Identifier(p) {
+        if (inFunction === 0 && p.node !== proxy && p.node.name === proxy.name) {
+          p.node.name = snap.name;
+        }
+      },
+      Function: {
+        enter() {
+          ++inFunction;
+        },
+        exit() {
+          --inFunction;
+        }
+      }
+    });
+  });
+};
+var macro$1 = createMacro(macro, { configName: "valtio" });
+
+export { macro$1 as default };

node_modules/valtio/esm/macro.mjs

@@ -0,0 +1,39 @@
+import { addNamed } from '@babel/helper-module-imports';
+import * as t from '@babel/types';
+import { createMacro, MacroError } from 'babel-plugin-macros';
+
+const macro = ({ references }) => {
+  var _a;
+  (_a = references.useProxy) == null ? void 0 : _a.forEach((path) => {
+    var _a2, _b, _c, _d, _e, _f;
+    const hook = addNamed(path, "useSnapshot", "valtio");
+    const proxy = (_b = (_a2 = path.parentPath) == null ? void 0 : _a2.get("arguments.0")) == null ? void 0 : _b.node;
+    if (!t.isIdentifier(proxy))
+      throw new MacroError("no proxy object");
+    const snap = t.identifier(`valtio_macro_snap_${proxy.name}`);
+    (_d = (_c = path.parentPath) == null ? void 0 : _c.parentPath) == null ? void 0 : _d.replaceWith(
+      t.variableDeclaration("const", [
+        t.variableDeclarator(snap, t.callExpression(hook, [proxy]))
+      ])
+    );
+    let inFunction = 0;
+    (_f = (_e = path.parentPath) == null ? void 0 : _e.getFunctionParent()) == null ? void 0 : _f.traverse({
+      Identifier(p) {
+        if (inFunction === 0 && p.node !== proxy && p.node.name === proxy.name) {
+          p.node.name = snap.name;
+        }
+      },
+      Function: {
+        enter() {
+          ++inFunction;
+        },
+        exit() {
+          --inFunction;
+        }
+      }
+    });
+  });
+};
+var macro$1 = createMacro(macro, { configName: "valtio" });
+
+export { macro$1 as default };

node_modules/valtio/esm/macro/vite.d.ts

@@ -0,0 +1,5 @@
+import * as plugin from 'aslemammad-vite-plugin-macro';
+export declare const valtioMacro: plugin.Macro;
+export declare function provideValtioMacro(): plugin.MacroProvider;
+declare const macroPlugin: plugin.MacroPlugin;
+export default macroPlugin;

node_modules/valtio/esm/macro/vite.js

@@ -0,0 +1,50 @@
+import * as babelModuleImports from '@babel/helper-module-imports';
+import * as t from '@babel/types';
+import * as plugin from 'aslemammad-vite-plugin-macro';
+import * as babelMacro from 'babel-plugin-macros';
+
+const { defineMacro, defineMacroProvider, createMacroPlugin } = "default" in plugin ? plugin.default : plugin;
+const valtioMacro = defineMacro(`useProxy`).withSignature(`<T extends object>(proxyObject: T): void`).withHandler((ctx) => {
+  var _a, _b, _c, _d;
+  const { path, args } = ctx;
+  const hook = babelModuleImports.addNamed(path, "useSnapshot", "valtio");
+  const proxy = (_a = args[0]) == null ? void 0 : _a.node;
+  if (!t.isIdentifier(proxy)) {
+    throw new babelMacro.MacroError("no proxy object");
+  }
+  const snap = t.identifier(`valtio_macro_snap_${proxy.name}`);
+  (_b = path.parentPath) == null ? void 0 : _b.replaceWith(
+    t.variableDeclaration("const", [
+      t.variableDeclarator(snap, t.callExpression(hook, [proxy]))
+    ])
+  );
+  let inFunction = 0;
+  (_d = (_c = path.parentPath) == null ? void 0 : _c.getFunctionParent()) == null ? void 0 : _d.traverse({
+    Identifier(p) {
+      if (inFunction === 0 && p.node !== proxy && p.node.name === proxy.name) {
+        p.node.name = snap.name;
+      }
+    },
+    Function: {
+      enter() {
+        ++inFunction;
+      },
+      exit() {
+        --inFunction;
+      }
+    }
+  });
+});
+function provideValtioMacro() {
+  return defineMacroProvider({
+    id: "valtio/macro",
+    exports: {
+      "valtio/macro": {
+        macros: [valtioMacro]
+      }
+    }
+  });
+}
+const macroPlugin = createMacroPlugin({}).use(provideValtioMacro());
+
+export { macroPlugin as default, provideValtioMacro, valtioMacro };

node_modules/valtio/esm/macro/vite.mjs

@@ -0,0 +1,50 @@
+import * as babelModuleImports from '@babel/helper-module-imports';
+import * as t from '@babel/types';
+import * as plugin from 'aslemammad-vite-plugin-macro';
+import * as babelMacro from 'babel-plugin-macros';
+
+const { defineMacro, defineMacroProvider, createMacroPlugin } = "default" in plugin ? plugin.default : plugin;
+const valtioMacro = defineMacro(`useProxy`).withSignature(`<T extends object>(proxyObject: T): void`).withHandler((ctx) => {
+  var _a, _b, _c, _d;
+  const { path, args } = ctx;
+  const hook = babelModuleImports.addNamed(path, "useSnapshot", "valtio");
+  const proxy = (_a = args[0]) == null ? void 0 : _a.node;
+  if (!t.isIdentifier(proxy)) {
+    throw new babelMacro.MacroError("no proxy object");
+  }
+  const snap = t.identifier(`valtio_macro_snap_${proxy.name}`);
+  (_b = path.parentPath) == null ? void 0 : _b.replaceWith(
+    t.variableDeclaration("const", [
+      t.variableDeclarator(snap, t.callExpression(hook, [proxy]))
+    ])
+  );
+  let inFunction = 0;
+  (_d = (_c = path.parentPath) == null ? void 0 : _c.getFunctionParent()) == null ? void 0 : _d.traverse({
+    Identifier(p) {
+      if (inFunction === 0 && p.node !== proxy && p.node.name === proxy.name) {
+        p.node.name = snap.name;
+      }
+    },
+    Function: {
+      enter() {
+        ++inFunction;
+      },
+      exit() {
+        --inFunction;
+      }
+    }
+  });
+});
+function provideValtioMacro() {
+  return defineMacroProvider({
+    id: "valtio/macro",
+    exports: {
+      "valtio/macro": {
+        macros: [valtioMacro]
+      }
+    }
+  });
+}
+const macroPlugin = createMacroPlugin({}).use(provideValtioMacro());
+
+export { macroPlugin as default, provideValtioMacro, valtioMacro };

node_modules/valtio/esm/react.d.ts

@@ -0,0 +1,78 @@
+import type { INTERNAL_Snapshot } from './vanilla';
+declare type Options = {
+    sync?: boolean;
+};
+/**
+ * useSnapshot
+ *
+ * Create a local snapshot that catches changes. This hook actually returns a wrapped snapshot in a proxy for
+ * render optimization instead of a plain object compared to `snapshot()` method.
+ * Rule of thumb: read from snapshots, mutate the source.
+ * The component will only re-render when the parts of the state you access have changed, it is render-optimized.
+ *
+ * @example A
+ * function Counter() {
+ *   const snap = useSnapshot(state)
+ *   return (
+ *     <div>
+ *       {snap.count}
+ *       <button onClick={() => ++state.count}>+1</button>
+ *     </div>
+ *   )
+ * }
+ *
+ * [Notes]
+ * Every object inside your proxy also becomes a proxy (if you don't use "ref"), so you can also use them to create
+ * the local snapshot as seen on example B.
+ *
+ * @example B
+ * function ProfileName() {
+ *   const snap = useSnapshot(state.profile)
+ *   return (
+ *     <div>
+ *       {snap.name}
+ *     </div>
+ *   )
+ * }
+ *
+ * Beware that you still can replace the child proxy with something else so it will break your snapshot. You can see
+ * above what happens with the original proxy when you replace the child proxy.
+ *
+ * > console.log(state)
+ * { profile: { name: "valtio" } }
+ * > childState = state.profile
+ * > console.log(childState)
+ * { name: "valtio" }
+ * > state.profile.name = "react"
+ * > console.log(childState)
+ * { name: "react" }
+ * > state.profile = { name: "new name" }
+ * > console.log(childState)
+ * { name: "react" }
+ * > console.log(state)
+ * { profile: { name: "new name" } }
+ *
+ * `useSnapshot()` depends on the original reference of the child proxy so if you replace it with a new one, the component
+ * that is subscribed to the old proxy won't receive new updates because it is still subscribed to the old one.
+ *
+ * In this case we recommend the example C or D. On both examples you don't need to worry with re-render,
+ * because it is render-optimized.
+ *
+ * @example C
+ * const snap = useSnapshot(state)
+ * return (
+ *   <div>
+ *     {snap.profile.name}
+ *   </div>
+ * )
+ *
+ * @example D
+ * const { profile } = useSnapshot(state)
+ * return (
+ *   <div>
+ *     {profile.name}
+ *   </div>
+ * )
+ */
+export declare function useSnapshot<T extends object>(proxyObject: T, options?: Options): INTERNAL_Snapshot<T>;
+export {};

node_modules/valtio/esm/utils.d.ts

@@ -0,0 +1,9 @@
+export { subscribeKey } from './utils/subscribeKey';
+export { watch } from './utils/watch';
+export { devtools } from './utils/devtools';
+export { derive, underive, unstable_deriveSubscriptions } from './utils/derive';
+export { addComputed_DEPRECATED as addComputed } from './utils/addComputed';
+export { proxyWithComputed } from './utils/proxyWithComputed';
+export { proxyWithHistory } from './utils/proxyWithHistory';
+export { proxySet } from './utils/proxySet';
+export { proxyMap } from './utils/proxyMap';

node_modules/valtio/esm/utils.js

@@ -0,0 +1,577 @@
+import { subscribe, snapshot, proxy, getVersion, ref } from 'valtio/vanilla';
+
+function subscribeKey(proxyObject, key, callback, notifyInSync) {
+  return subscribe(
+    proxyObject,
+    (ops) => {
+      if (ops.some((op) => op[1][0] === key)) {
+        callback(proxyObject[key]);
+      }
+    },
+    notifyInSync
+  );
+}
+
+let currentCleanups;
+function watch(callback, options) {
+  let alive = true;
+  const cleanups = /* @__PURE__ */ new Set();
+  const subscriptions = /* @__PURE__ */ new Map();
+  const cleanup = () => {
+    if (alive) {
+      alive = false;
+      cleanups.forEach((clean) => clean());
+      cleanups.clear();
+      subscriptions.forEach((unsubscribe) => unsubscribe());
+      subscriptions.clear();
+    }
+  };
+  const revalidate = () => {
+    if (!alive) {
+      return;
+    }
+    cleanups.forEach((clean) => clean());
+    cleanups.clear();
+    const proxiesToSubscribe = /* @__PURE__ */ new Set();
+    const parent = currentCleanups;
+    currentCleanups = cleanups;
+    try {
+      const cleanupReturn = callback((proxyObject) => {
+        proxiesToSubscribe.add(proxyObject);
+        return proxyObject;
+      });
+      if (cleanupReturn) {
+        cleanups.add(cleanupReturn);
+      }
+    } finally {
+      currentCleanups = parent;
+    }
+    subscriptions.forEach((unsubscribe, proxyObject) => {
+      if (proxiesToSubscribe.has(proxyObject)) {
+        proxiesToSubscribe.delete(proxyObject);
+      } else {
+        subscriptions.delete(proxyObject);
+        unsubscribe();
+      }
+    });
+    proxiesToSubscribe.forEach((proxyObject) => {
+      const unsubscribe = subscribe(proxyObject, revalidate, options == null ? void 0 : options.sync);
+      subscriptions.set(proxyObject, unsubscribe);
+    });
+  };
+  if (currentCleanups) {
+    currentCleanups.add(cleanup);
+  }
+  revalidate();
+  return cleanup;
+}
+
+const DEVTOOLS = Symbol();
+function devtools(proxyObject, options) {
+  if (typeof options === "string") {
+    console.warn(
+      "string name option is deprecated, use { name }. https://github.com/pmndrs/valtio/pull/400"
+    );
+    options = { name: options };
+  }
+  const { enabled, name = "" } = options || {};
+  let extension;
+  try {
+    extension = (enabled != null ? enabled : (import.meta.env && import.meta.env.MODE) !== "production") && window.__REDUX_DEVTOOLS_EXTENSION__;
+  } catch {
+  }
+  if (!extension) {
+    if ((import.meta.env && import.meta.env.MODE) !== "production" && enabled) {
+      console.warn("[Warning] Please install/enable Redux devtools extension");
+    }
+    return;
+  }
+  let isTimeTraveling = false;
+  const devtools2 = extension.connect({ name });
+  const unsub1 = subscribe(proxyObject, (ops) => {
+    const action = ops.filter(([_, path]) => path[0] !== DEVTOOLS).map(([op, path]) => `${op}:${path.map(String).join(".")}`).join(", ");
+    if (!action) {
+      return;
+    }
+    if (isTimeTraveling) {
+      isTimeTraveling = false;
+    } else {
+      const snapWithoutDevtools = Object.assign({}, snapshot(proxyObject));
+      delete snapWithoutDevtools[DEVTOOLS];
+      devtools2.send(
+        {
+          type: action,
+          updatedAt: new Date().toLocaleString()
+        },
+        snapWithoutDevtools
+      );
+    }
+  });
+  const unsub2 = devtools2.subscribe((message) => {
+    var _a, _b, _c, _d, _e, _f;
+    if (message.type === "ACTION" && message.payload) {
+      try {
+        Object.assign(proxyObject, JSON.parse(message.payload));
+      } catch (e) {
+        console.error(
+          "please dispatch a serializable value that JSON.parse() and proxy() support\n",
+          e
+        );
+      }
+    }
+    if (message.type === "DISPATCH" && message.state) {
+      if (((_a = message.payload) == null ? void 0 : _a.type) === "JUMP_TO_ACTION" || ((_b = message.payload) == null ? void 0 : _b.type) === "JUMP_TO_STATE") {
+        isTimeTraveling = true;
+        const state = JSON.parse(message.state);
+        Object.assign(proxyObject, state);
+      }
+      proxyObject[DEVTOOLS] = message;
+    } else if (message.type === "DISPATCH" && ((_c = message.payload) == null ? void 0 : _c.type) === "COMMIT") {
+      devtools2.init(snapshot(proxyObject));
+    } else if (message.type === "DISPATCH" && ((_d = message.payload) == null ? void 0 : _d.type) === "IMPORT_STATE") {
+      const actions = (_e = message.payload.nextLiftedState) == null ? void 0 : _e.actionsById;
+      const computedStates = ((_f = message.payload.nextLiftedState) == null ? void 0 : _f.computedStates) || [];
+      isTimeTraveling = true;
+      computedStates.forEach(({ state }, index) => {
+        const action = actions[index] || "No action found";
+        Object.assign(proxyObject, state);
+        if (index === 0) {
+          devtools2.init(snapshot(proxyObject));
+        } else {
+          devtools2.send(action, snapshot(proxyObject));
+        }
+      });
+    }
+  });
+  devtools2.init(snapshot(proxyObject));
+  return () => {
+    unsub1();
+    unsub2 == null ? void 0 : unsub2();
+  };
+}
+
+const sourceObjectMap = /* @__PURE__ */ new WeakMap();
+const derivedObjectMap = /* @__PURE__ */ new WeakMap();
+const markPending = (sourceObject, callback) => {
+  const sourceObjectEntry = sourceObjectMap.get(sourceObject);
+  if (sourceObjectEntry) {
+    sourceObjectEntry[0].forEach((subscription) => {
+      const { d: derivedObject } = subscription;
+      if (sourceObject !== derivedObject) {
+        markPending(derivedObject);
+      }
+    });
+    ++sourceObjectEntry[2];
+    if (callback) {
+      sourceObjectEntry[3].add(callback);
+    }
+  }
+};
+const checkPending = (sourceObject, callback) => {
+  const sourceObjectEntry = sourceObjectMap.get(sourceObject);
+  if (sourceObjectEntry == null ? void 0 : sourceObjectEntry[2]) {
+    sourceObjectEntry[3].add(callback);
+    return true;
+  }
+  return false;
+};
+const unmarkPending = (sourceObject) => {
+  const sourceObjectEntry = sourceObjectMap.get(sourceObject);
+  if (sourceObjectEntry) {
+    --sourceObjectEntry[2];
+    if (!sourceObjectEntry[2]) {
+      sourceObjectEntry[3].forEach((callback) => callback());
+      sourceObjectEntry[3].clear();
+    }
+    sourceObjectEntry[0].forEach((subscription) => {
+      const { d: derivedObject } = subscription;
+      if (sourceObject !== derivedObject) {
+        unmarkPending(derivedObject);
+      }
+    });
+  }
+};
+const addSubscription = (subscription) => {
+  const { s: sourceObject, d: derivedObject } = subscription;
+  let derivedObjectEntry = derivedObjectMap.get(derivedObject);
+  if (!derivedObjectEntry) {
+    derivedObjectEntry = [/* @__PURE__ */ new Set()];
+    derivedObjectMap.set(subscription.d, derivedObjectEntry);
+  }
+  derivedObjectEntry[0].add(subscription);
+  let sourceObjectEntry = sourceObjectMap.get(sourceObject);
+  if (!sourceObjectEntry) {
+    const subscriptions = /* @__PURE__ */ new Set();
+    const unsubscribe = subscribe(
+      sourceObject,
+      (ops) => {
+        subscriptions.forEach((subscription2) => {
+          const {
+            d: derivedObject2,
+            c: callback,
+            n: notifyInSync,
+            i: ignoreKeys
+          } = subscription2;
+          if (sourceObject === derivedObject2 && ops.every(
+            (op) => op[1].length === 1 && ignoreKeys.includes(op[1][0])
+          )) {
+            return;
+          }
+          if (subscription2.p) {
+            return;
+          }
+          markPending(sourceObject, callback);
+          if (notifyInSync) {
+            unmarkPending(sourceObject);
+          } else {
+            subscription2.p = Promise.resolve().then(() => {
+              delete subscription2.p;
+              unmarkPending(sourceObject);
+            });
+          }
+        });
+      },
+      true
+    );
+    sourceObjectEntry = [subscriptions, unsubscribe, 0, /* @__PURE__ */ new Set()];
+    sourceObjectMap.set(sourceObject, sourceObjectEntry);
+  }
+  sourceObjectEntry[0].add(subscription);
+};
+const removeSubscription = (subscription) => {
+  const { s: sourceObject, d: derivedObject } = subscription;
+  const derivedObjectEntry = derivedObjectMap.get(derivedObject);
+  derivedObjectEntry == null ? void 0 : derivedObjectEntry[0].delete(subscription);
+  if ((derivedObjectEntry == null ? void 0 : derivedObjectEntry[0].size) === 0) {
+    derivedObjectMap.delete(derivedObject);
+  }
+  const sourceObjectEntry = sourceObjectMap.get(sourceObject);
+  if (sourceObjectEntry) {
+    const [subscriptions, unsubscribe] = sourceObjectEntry;
+    subscriptions.delete(subscription);
+    if (!subscriptions.size) {
+      unsubscribe();
+      sourceObjectMap.delete(sourceObject);
+    }
+  }
+};
+const listSubscriptions = (derivedObject) => {
+  const derivedObjectEntry = derivedObjectMap.get(derivedObject);
+  if (derivedObjectEntry) {
+    return Array.from(derivedObjectEntry[0]);
+  }
+  return [];
+};
+const unstable_deriveSubscriptions = {
+  add: addSubscription,
+  remove: removeSubscription,
+  list: listSubscriptions
+};
+function derive(derivedFns, options) {
+  const proxyObject = (options == null ? void 0 : options.proxy) || proxy({});
+  const notifyInSync = !!(options == null ? void 0 : options.sync);
+  const derivedKeys = Object.keys(derivedFns);
+  derivedKeys.forEach((key) => {
+    if (Object.getOwnPropertyDescriptor(proxyObject, key)) {
+      throw new Error("object property already defined");
+    }
+    const fn = derivedFns[key];
+    let lastDependencies = null;
+    const evaluate = () => {
+      if (lastDependencies) {
+        if (Array.from(lastDependencies).map(([p]) => checkPending(p, evaluate)).some((isPending) => isPending)) {
+          return;
+        }
+        if (Array.from(lastDependencies).every(
+          ([p, entry]) => getVersion(p) === entry.v
+        )) {
+          return;
+        }
+      }
+      const dependencies = /* @__PURE__ */ new Map();
+      const get = (p) => {
+        dependencies.set(p, { v: getVersion(p) });
+        return p;
+      };
+      const value = fn(get);
+      const subscribeToDependencies = () => {
+        dependencies.forEach((entry, p) => {
+          var _a;
+          const lastSubscription = (_a = lastDependencies == null ? void 0 : lastDependencies.get(p)) == null ? void 0 : _a.s;
+          if (lastSubscription) {
+            entry.s = lastSubscription;
+          } else {
+            const subscription = {
+              s: p,
+              d: proxyObject,
+              k: key,
+              c: evaluate,
+              n: notifyInSync,
+              i: derivedKeys
+            };
+            addSubscription(subscription);
+            entry.s = subscription;
+          }
+        });
+        lastDependencies == null ? void 0 : lastDependencies.forEach((entry, p) => {
+          if (!dependencies.has(p) && entry.s) {
+            removeSubscription(entry.s);
+          }
+        });
+        lastDependencies = dependencies;
+      };
+      if (value instanceof Promise) {
+        value.finally(subscribeToDependencies);
+      } else {
+        subscribeToDependencies();
+      }
+      proxyObject[key] = value;
+    };
+    evaluate();
+  });
+  return proxyObject;
+}
+function underive(proxyObject, options) {
+  const keysToDelete = (options == null ? void 0 : options.delete) ? /* @__PURE__ */ new Set() : null;
+  listSubscriptions(proxyObject).forEach((subscription) => {
+    const { k: key } = subscription;
+    if (!(options == null ? void 0 : options.keys) || options.keys.includes(key)) {
+      removeSubscription(subscription);
+      if (keysToDelete) {
+        keysToDelete.add(key);
+      }
+    }
+  });
+  if (keysToDelete) {
+    keysToDelete.forEach((key) => {
+      delete proxyObject[key];
+    });
+  }
+}
+
+function addComputed_DEPRECATED(proxyObject, computedFns_FAKE, targetObject = proxyObject) {
+  console.warn(
+    "addComputed is deprecated. Please consider using `derive` or `proxyWithComputed` instead. Falling back to emulation with derive. https://github.com/pmndrs/valtio/pull/201"
+  );
+  const derivedFns = {};
+  Object.keys(computedFns_FAKE).forEach((key) => {
+    derivedFns[key] = (get) => computedFns_FAKE[key](get(proxyObject));
+  });
+  return derive(derivedFns, { proxy: targetObject });
+}
+
+function proxyWithComputed(initialObject, computedFns) {
+  Object.keys(computedFns).forEach((key) => {
+    if (Object.getOwnPropertyDescriptor(initialObject, key)) {
+      throw new Error("object property already defined");
+    }
+    const computedFn = computedFns[key];
+    const { get, set } = typeof computedFn === "function" ? { get: computedFn } : computedFn;
+    const desc = {};
+    desc.get = () => get(snapshot(proxyObject));
+    if (set) {
+      desc.set = (newValue) => set(proxyObject, newValue);
+    }
+    Object.defineProperty(initialObject, key, desc);
+  });
+  const proxyObject = proxy(initialObject);
+  return proxyObject;
+}
+
+const isObject = (x) => typeof x === "object" && x !== null;
+const deepClone = (obj) => {
+  if (!isObject(obj)) {
+    return obj;
+  }
+  const baseObject = Array.isArray(obj) ? [] : Object.create(Object.getPrototypeOf(obj));
+  Reflect.ownKeys(obj).forEach((key) => {
+    baseObject[key] = deepClone(obj[key]);
+  });
+  return baseObject;
+};
+function proxyWithHistory(initialValue, skipSubscribe = false) {
+  const proxyObject = proxy({
+    value: initialValue,
+    history: ref({
+      wip: void 0,
+      snapshots: [],
+      index: -1
+    }),
+    canUndo: () => proxyObject.history.index > 0,
+    undo: () => {
+      if (proxyObject.canUndo()) {
+        proxyObject.value = proxyObject.history.wip = deepClone(
+          proxyObject.history.snapshots[--proxyObject.history.index]
+        );
+      }
+    },
+    canRedo: () => proxyObject.history.index < proxyObject.history.snapshots.length - 1,
+    redo: () => {
+      if (proxyObject.canRedo()) {
+        proxyObject.value = proxyObject.history.wip = deepClone(
+          proxyObject.history.snapshots[++proxyObject.history.index]
+        );
+      }
+    },
+    saveHistory: () => {
+      proxyObject.history.snapshots.splice(proxyObject.history.index + 1);
+      proxyObject.history.snapshots.push(snapshot(proxyObject).value);
+      ++proxyObject.history.index;
+    },
+    subscribe: () => subscribe(proxyObject, (ops) => {
+      if (ops.every(
+        (op) => op[1][0] === "value" && (op[0] !== "set" || op[2] !== proxyObject.history.wip)
+      )) {
+        proxyObject.saveHistory();
+      }
+    })
+  });
+  proxyObject.saveHistory();
+  if (!skipSubscribe) {
+    proxyObject.subscribe();
+  }
+  return proxyObject;
+}
+
+function proxySet(initialValues) {
+  const set = proxy({
+    data: Array.from(new Set(initialValues)),
+    has(value) {
+      return this.data.indexOf(value) !== -1;
+    },
+    add(value) {
+      let hasProxy = false;
+      if (typeof value === "object" && value !== null) {
+        hasProxy = this.data.indexOf(proxy(value)) !== -1;
+      }
+      if (this.data.indexOf(value) === -1 && !hasProxy) {
+        this.data.push(value);
+      }
+      return this;
+    },
+    delete(value) {
+      const index = this.data.indexOf(value);
+      if (index === -1) {
+        return false;
+      }
+      this.data.splice(index, 1);
+      return true;
+    },
+    clear() {
+      this.data.splice(0);
+    },
+    get size() {
+      return this.data.length;
+    },
+    forEach(cb) {
+      this.data.forEach((value) => {
+        cb(value, value, this);
+      });
+    },
+    get [Symbol.toStringTag]() {
+      return "Set";
+    },
+    toJSON() {
+      return {};
+    },
+    [Symbol.iterator]() {
+      return this.data[Symbol.iterator]();
+    },
+    values() {
+      return this.data.values();
+    },
+    keys() {
+      return this.data.values();
+    },
+    entries() {
+      return new Set(this.data).entries();
+    }
+  });
+  Object.defineProperties(set, {
+    data: {
+      enumerable: false
+    },
+    size: {
+      enumerable: false
+    },
+    toJSON: {
+      enumerable: false
+    }
+  });
+  Object.seal(set);
+  return set;
+}
+
+function proxyMap(entries) {
+  const map = proxy({
+    data: Array.from(entries || []),
+    has(key) {
+      return this.data.some((p) => p[0] === key);
+    },
+    set(key, value) {
+      const record = this.data.find((p) => p[0] === key);
+      if (record) {
+        record[1] = value;
+      } else {
+        this.data.push([key, value]);
+      }
+      return this;
+    },
+    get(key) {
+      var _a;
+      return (_a = this.data.find((p) => p[0] === key)) == null ? void 0 : _a[1];
+    },
+    delete(key) {
+      const index = this.data.findIndex((p) => p[0] === key);
+      if (index === -1) {
+        return false;
+      }
+      this.data.splice(index, 1);
+      return true;
+    },
+    clear() {
+      this.data.splice(0);
+    },
+    get size() {
+      return this.data.length;
+    },
+    toJSON() {
+      return {};
+    },
+    forEach(cb) {
+      this.data.forEach((p) => {
+        cb(p[1], p[0], this);
+      });
+    },
+    keys() {
+      return this.data.map((p) => p[0]).values();
+    },
+    values() {
+      return this.data.map((p) => p[1]).values();
+    },
+    entries() {
+      return new Map(this.data).entries();
+    },
+    get [Symbol.toStringTag]() {
+      return "Map";
+    },
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  });
+  Object.defineProperties(map, {
+    data: {
+      enumerable: false
+    },
+    size: {
+      enumerable: false
+    },
+    toJSON: {
+      enumerable: false
+    }
+  });
+  Object.seal(map);
+  return map;
+}
+
+export { addComputed_DEPRECATED as addComputed, derive, devtools, proxyMap, proxySet, proxyWithComputed, proxyWithHistory, subscribeKey, underive, unstable_deriveSubscriptions, watch };

node_modules/valtio/esm/utils.mjs

@@ -0,0 +1,577 @@
+import { subscribe, snapshot, proxy, getVersion, ref } from 'valtio/vanilla';
+
+function subscribeKey(proxyObject, key, callback, notifyInSync) {
+  return subscribe(
+    proxyObject,
+    (ops) => {
+      if (ops.some((op) => op[1][0] === key)) {
+        callback(proxyObject[key]);
+      }
+    },
+    notifyInSync
+  );
+}
+
+let currentCleanups;
+function watch(callback, options) {
+  let alive = true;
+  const cleanups = /* @__PURE__ */ new Set();
+  const subscriptions = /* @__PURE__ */ new Map();
+  const cleanup = () => {
+    if (alive) {
+      alive = false;
+      cleanups.forEach((clean) => clean());
+      cleanups.clear();
+      subscriptions.forEach((unsubscribe) => unsubscribe());
+      subscriptions.clear();
+    }
+  };
+  const revalidate = () => {
+    if (!alive) {
+      return;
+    }
+    cleanups.forEach((clean) => clean());
+    cleanups.clear();
+    const proxiesToSubscribe = /* @__PURE__ */ new Set();
+    const parent = currentCleanups;
+    currentCleanups = cleanups;
+    try {
+      const cleanupReturn = callback((proxyObject) => {
+        proxiesToSubscribe.add(proxyObject);
+        return proxyObject;
+      });
+      if (cleanupReturn) {
+        cleanups.add(cleanupReturn);
+      }
+    } finally {
+      currentCleanups = parent;
+    }
+    subscriptions.forEach((unsubscribe, proxyObject) => {
+      if (proxiesToSubscribe.has(proxyObject)) {
+        proxiesToSubscribe.delete(proxyObject);
+      } else {
+        subscriptions.delete(proxyObject);
+        unsubscribe();
+      }
+    });
+    proxiesToSubscribe.forEach((proxyObject) => {
+      const unsubscribe = subscribe(proxyObject, revalidate, options == null ? void 0 : options.sync);
+      subscriptions.set(proxyObject, unsubscribe);
+    });
+  };
+  if (currentCleanups) {
+    currentCleanups.add(cleanup);
+  }
+  revalidate();
+  return cleanup;
+}
+
+const DEVTOOLS = Symbol();
+function devtools(proxyObject, options) {
+  if (typeof options === "string") {
+    console.warn(
+      "string name option is deprecated, use { name }. https://github.com/pmndrs/valtio/pull/400"
+    );
+    options = { name: options };
+  }
+  const { enabled, name = "" } = options || {};
+  let extension;
+  try {
+    extension = (enabled != null ? enabled : (import.meta.env && import.meta.env.MODE) !== "production") && window.__REDUX_DEVTOOLS_EXTENSION__;
+  } catch {
+  }
+  if (!extension) {
+    if ((import.meta.env && import.meta.env.MODE) !== "production" && enabled) {
+      console.warn("[Warning] Please install/enable Redux devtools extension");
+    }
+    return;
+  }
+  let isTimeTraveling = false;
+  const devtools2 = extension.connect({ name });
+  const unsub1 = subscribe(proxyObject, (ops) => {
+    const action = ops.filter(([_, path]) => path[0] !== DEVTOOLS).map(([op, path]) => `${op}:${path.map(String).join(".")}`).join(", ");
+    if (!action) {
+      return;
+    }
+    if (isTimeTraveling) {
+      isTimeTraveling = false;
+    } else {
+      const snapWithoutDevtools = Object.assign({}, snapshot(proxyObject));
+      delete snapWithoutDevtools[DEVTOOLS];
+      devtools2.send(
+        {
+          type: action,
+          updatedAt: new Date().toLocaleString()
+        },
+        snapWithoutDevtools
+      );
+    }
+  });
+  const unsub2 = devtools2.subscribe((message) => {
+    var _a, _b, _c, _d, _e, _f;
+    if (message.type === "ACTION" && message.payload) {
+      try {
+        Object.assign(proxyObject, JSON.parse(message.payload));
+      } catch (e) {
+        console.error(
+          "please dispatch a serializable value that JSON.parse() and proxy() support\n",
+          e
+        );
+      }
+    }
+    if (message.type === "DISPATCH" && message.state) {
+      if (((_a = message.payload) == null ? void 0 : _a.type) === "JUMP_TO_ACTION" || ((_b = message.payload) == null ? void 0 : _b.type) === "JUMP_TO_STATE") {
+        isTimeTraveling = true;
+        const state = JSON.parse(message.state);
+        Object.assign(proxyObject, state);
+      }
+      proxyObject[DEVTOOLS] = message;
+    } else if (message.type === "DISPATCH" && ((_c = message.payload) == null ? void 0 : _c.type) === "COMMIT") {
+      devtools2.init(snapshot(proxyObject));
+    } else if (message.type === "DISPATCH" && ((_d = message.payload) == null ? void 0 : _d.type) === "IMPORT_STATE") {
+      const actions = (_e = message.payload.nextLiftedState) == null ? void 0 : _e.actionsById;
+      const computedStates = ((_f = message.payload.nextLiftedState) == null ? void 0 : _f.computedStates) || [];
+      isTimeTraveling = true;
+      computedStates.forEach(({ state }, index) => {
+        const action = actions[index] || "No action found";
+        Object.assign(proxyObject, state);
+        if (index === 0) {
+          devtools2.init(snapshot(proxyObject));
+        } else {
+          devtools2.send(action, snapshot(proxyObject));
+        }
+      });
+    }
+  });
+  devtools2.init(snapshot(proxyObject));
+  return () => {
+    unsub1();
+    unsub2 == null ? void 0 : unsub2();
+  };
+}
+
+const sourceObjectMap = /* @__PURE__ */ new WeakMap();
+const derivedObjectMap = /* @__PURE__ */ new WeakMap();
+const markPending = (sourceObject, callback) => {
+  const sourceObjectEntry = sourceObjectMap.get(sourceObject);
+  if (sourceObjectEntry) {
+    sourceObjectEntry[0].forEach((subscription) => {
+      const { d: derivedObject } = subscription;
+      if (sourceObject !== derivedObject) {
+        markPending(derivedObject);
+      }
+    });
+    ++sourceObjectEntry[2];
+    if (callback) {
+      sourceObjectEntry[3].add(callback);
+    }
+  }
+};
+const checkPending = (sourceObject, callback) => {
+  const sourceObjectEntry = sourceObjectMap.get(sourceObject);
+  if (sourceObjectEntry == null ? void 0 : sourceObjectEntry[2]) {
+    sourceObjectEntry[3].add(callback);
+    return true;
+  }
+  return false;
+};
+const unmarkPending = (sourceObject) => {
+  const sourceObjectEntry = sourceObjectMap.get(sourceObject);
+  if (sourceObjectEntry) {
+    --sourceObjectEntry[2];
+    if (!sourceObjectEntry[2]) {
+      sourceObjectEntry[3].forEach((callback) => callback());
+      sourceObjectEntry[3].clear();
+    }
+    sourceObjectEntry[0].forEach((subscription) => {
+      const { d: derivedObject } = subscription;
+      if (sourceObject !== derivedObject) {
+        unmarkPending(derivedObject);
+      }
+    });
+  }
+};
+const addSubscription = (subscription) => {
+  const { s: sourceObject, d: derivedObject } = subscription;
+  let derivedObjectEntry = derivedObjectMap.get(derivedObject);
+  if (!derivedObjectEntry) {
+    derivedObjectEntry = [/* @__PURE__ */ new Set()];
+    derivedObjectMap.set(subscription.d, derivedObjectEntry);
+  }
+  derivedObjectEntry[0].add(subscription);
+  let sourceObjectEntry = sourceObjectMap.get(sourceObject);
+  if (!sourceObjectEntry) {
+    const subscriptions = /* @__PURE__ */ new Set();
+    const unsubscribe = subscribe(
+      sourceObject,
+      (ops) => {
+        subscriptions.forEach((subscription2) => {
+          const {
+            d: derivedObject2,
+            c: callback,
+            n: notifyInSync,
+            i: ignoreKeys
+          } = subscription2;
+          if (sourceObject === derivedObject2 && ops.every(
+            (op) => op[1].length === 1 && ignoreKeys.includes(op[1][0])
+          )) {
+            return;
+          }
+          if (subscription2.p) {
+            return;
+          }
+          markPending(sourceObject, callback);
+          if (notifyInSync) {
+            unmarkPending(sourceObject);
+          } else {
+            subscription2.p = Promise.resolve().then(() => {
+              delete subscription2.p;
+              unmarkPending(sourceObject);
+            });
+          }
+        });
+      },
+      true
+    );
+    sourceObjectEntry = [subscriptions, unsubscribe, 0, /* @__PURE__ */ new Set()];
+    sourceObjectMap.set(sourceObject, sourceObjectEntry);
+  }
+  sourceObjectEntry[0].add(subscription);
+};
+const removeSubscription = (subscription) => {
+  const { s: sourceObject, d: derivedObject } = subscription;
+  const derivedObjectEntry = derivedObjectMap.get(derivedObject);
+  derivedObjectEntry == null ? void 0 : derivedObjectEntry[0].delete(subscription);
+  if ((derivedObjectEntry == null ? void 0 : derivedObjectEntry[0].size) === 0) {
+    derivedObjectMap.delete(derivedObject);
+  }
+  const sourceObjectEntry = sourceObjectMap.get(sourceObject);
+  if (sourceObjectEntry) {
+    const [subscriptions, unsubscribe] = sourceObjectEntry;
+    subscriptions.delete(subscription);
+    if (!subscriptions.size) {
+      unsubscribe();
+      sourceObjectMap.delete(sourceObject);
+    }
+  }
+};
+const listSubscriptions = (derivedObject) => {
+  const derivedObjectEntry = derivedObjectMap.get(derivedObject);
+  if (derivedObjectEntry) {
+    return Array.from(derivedObjectEntry[0]);
+  }
+  return [];
+};
+const unstable_deriveSubscriptions = {
+  add: addSubscription,
+  remove: removeSubscription,
+  list: listSubscriptions
+};
+function derive(derivedFns, options) {
+  const proxyObject = (options == null ? void 0 : options.proxy) || proxy({});
+  const notifyInSync = !!(options == null ? void 0 : options.sync);
+  const derivedKeys = Object.keys(derivedFns);
+  derivedKeys.forEach((key) => {
+    if (Object.getOwnPropertyDescriptor(proxyObject, key)) {
+      throw new Error("object property already defined");
+    }
+    const fn = derivedFns[key];
+    let lastDependencies = null;
+    const evaluate = () => {
+      if (lastDependencies) {
+        if (Array.from(lastDependencies).map(([p]) => checkPending(p, evaluate)).some((isPending) => isPending)) {
+          return;
+        }
+        if (Array.from(lastDependencies).every(
+          ([p, entry]) => getVersion(p) === entry.v
+        )) {
+          return;
+        }
+      }
+      const dependencies = /* @__PURE__ */ new Map();
+      const get = (p) => {
+        dependencies.set(p, { v: getVersion(p) });
+        return p;
+      };
+      const value = fn(get);
+      const subscribeToDependencies = () => {
+        dependencies.forEach((entry, p) => {
+          var _a;
+          const lastSubscription = (_a = lastDependencies == null ? void 0 : lastDependencies.get(p)) == null ? void 0 : _a.s;
+          if (lastSubscription) {
+            entry.s = lastSubscription;
+          } else {
+            const subscription = {
+              s: p,
+              d: proxyObject,
+              k: key,
+              c: evaluate,
+              n: notifyInSync,
+              i: derivedKeys
+            };
+            addSubscription(subscription);
+            entry.s = subscription;
+          }
+        });
+        lastDependencies == null ? void 0 : lastDependencies.forEach((entry, p) => {
+          if (!dependencies.has(p) && entry.s) {
+            removeSubscription(entry.s);
+          }
+        });
+        lastDependencies = dependencies;
+      };
+      if (value instanceof Promise) {
+        value.finally(subscribeToDependencies);
+      } else {
+        subscribeToDependencies();
+      }
+      proxyObject[key] = value;
+    };
+    evaluate();
+  });
+  return proxyObject;
+}
+function underive(proxyObject, options) {
+  const keysToDelete = (options == null ? void 0 : options.delete) ? /* @__PURE__ */ new Set() : null;
+  listSubscriptions(proxyObject).forEach((subscription) => {
+    const { k: key } = subscription;
+    if (!(options == null ? void 0 : options.keys) || options.keys.includes(key)) {
+      removeSubscription(subscription);
+      if (keysToDelete) {
+        keysToDelete.add(key);
+      }
+    }
+  });
+  if (keysToDelete) {
+    keysToDelete.forEach((key) => {
+      delete proxyObject[key];
+    });
+  }
+}
+
+function addComputed_DEPRECATED(proxyObject, computedFns_FAKE, targetObject = proxyObject) {
+  console.warn(
+    "addComputed is deprecated. Please consider using `derive` or `proxyWithComputed` instead. Falling back to emulation with derive. https://github.com/pmndrs/valtio/pull/201"
+  );
+  const derivedFns = {};
+  Object.keys(computedFns_FAKE).forEach((key) => {
+    derivedFns[key] = (get) => computedFns_FAKE[key](get(proxyObject));
+  });
+  return derive(derivedFns, { proxy: targetObject });
+}
+
+function proxyWithComputed(initialObject, computedFns) {
+  Object.keys(computedFns).forEach((key) => {
+    if (Object.getOwnPropertyDescriptor(initialObject, key)) {
+      throw new Error("object property already defined");
+    }
+    const computedFn = computedFns[key];
+    const { get, set } = typeof computedFn === "function" ? { get: computedFn } : computedFn;
+    const desc = {};
+    desc.get = () => get(snapshot(proxyObject));
+    if (set) {
+      desc.set = (newValue) => set(proxyObject, newValue);
+    }
+    Object.defineProperty(initialObject, key, desc);
+  });
+  const proxyObject = proxy(initialObject);
+  return proxyObject;
+}
+
+const isObject = (x) => typeof x === "object" && x !== null;
+const deepClone = (obj) => {
+  if (!isObject(obj)) {
+    return obj;
+  }
+  const baseObject = Array.isArray(obj) ? [] : Object.create(Object.getPrototypeOf(obj));
+  Reflect.ownKeys(obj).forEach((key) => {
+    baseObject[key] = deepClone(obj[key]);
+  });
+  return baseObject;
+};
+function proxyWithHistory(initialValue, skipSubscribe = false) {
+  const proxyObject = proxy({
+    value: initialValue,
+    history: ref({
+      wip: void 0,
+      snapshots: [],
+      index: -1
+    }),
+    canUndo: () => proxyObject.history.index > 0,
+    undo: () => {
+      if (proxyObject.canUndo()) {
+        proxyObject.value = proxyObject.history.wip = deepClone(
+          proxyObject.history.snapshots[--proxyObject.history.index]
+        );
+      }
+    },
+    canRedo: () => proxyObject.history.index < proxyObject.history.snapshots.length - 1,
+    redo: () => {
+      if (proxyObject.canRedo()) {
+        proxyObject.value = proxyObject.history.wip = deepClone(
+          proxyObject.history.snapshots[++proxyObject.history.index]
+        );
+      }
+    },
+    saveHistory: () => {
+      proxyObject.history.snapshots.splice(proxyObject.history.index + 1);
+      proxyObject.history.snapshots.push(snapshot(proxyObject).value);
+      ++proxyObject.history.index;
+    },
+    subscribe: () => subscribe(proxyObject, (ops) => {
+      if (ops.every(
+        (op) => op[1][0] === "value" && (op[0] !== "set" || op[2] !== proxyObject.history.wip)
+      )) {
+        proxyObject.saveHistory();
+      }
+    })
+  });
+  proxyObject.saveHistory();
+  if (!skipSubscribe) {
+    proxyObject.subscribe();
+  }
+  return proxyObject;
+}
+
+function proxySet(initialValues) {
+  const set = proxy({
+    data: Array.from(new Set(initialValues)),
+    has(value) {
+      return this.data.indexOf(value) !== -1;
+    },
+    add(value) {
+      let hasProxy = false;
+      if (typeof value === "object" && value !== null) {
+        hasProxy = this.data.indexOf(proxy(value)) !== -1;
+      }
+      if (this.data.indexOf(value) === -1 && !hasProxy) {
+        this.data.push(value);
+      }
+      return this;
+    },
+    delete(value) {
+      const index = this.data.indexOf(value);
+      if (index === -1) {
+        return false;
+      }
+      this.data.splice(index, 1);
+      return true;
+    },
+    clear() {
+      this.data.splice(0);
+    },
+    get size() {
+      return this.data.length;
+    },
+    forEach(cb) {
+      this.data.forEach((value) => {
+        cb(value, value, this);
+      });
+    },
+    get [Symbol.toStringTag]() {
+      return "Set";
+    },
+    toJSON() {
+      return {};
+    },
+    [Symbol.iterator]() {
+      return this.data[Symbol.iterator]();
+    },
+    values() {
+      return this.data.values();
+    },
+    keys() {
+      return this.data.values();
+    },
+    entries() {
+      return new Set(this.data).entries();
+    }
+  });
+  Object.defineProperties(set, {
+    data: {
+      enumerable: false
+    },
+    size: {
+      enumerable: false
+    },
+    toJSON: {
+      enumerable: false
+    }
+  });
+  Object.seal(set);
+  return set;
+}
+
+function proxyMap(entries) {
+  const map = proxy({
+    data: Array.from(entries || []),
+    has(key) {
+      return this.data.some((p) => p[0] === key);
+    },
+    set(key, value) {
+      const record = this.data.find((p) => p[0] === key);
+      if (record) {
+        record[1] = value;
+      } else {
+        this.data.push([key, value]);
+      }
+      return this;
+    },
+    get(key) {
+      var _a;
+      return (_a = this.data.find((p) => p[0] === key)) == null ? void 0 : _a[1];
+    },
+    delete(key) {
+      const index = this.data.findIndex((p) => p[0] === key);
+      if (index === -1) {
+        return false;
+      }
+      this.data.splice(index, 1);
+      return true;
+    },
+    clear() {
+      this.data.splice(0);
+    },
+    get size() {
+      return this.data.length;
+    },
+    toJSON() {
+      return {};
+    },
+    forEach(cb) {
+      this.data.forEach((p) => {
+        cb(p[1], p[0], this);
+      });
+    },
+    keys() {
+      return this.data.map((p) => p[0]).values();
+    },
+    values() {
+      return this.data.map((p) => p[1]).values();
+    },
+    entries() {
+      return new Map(this.data).entries();
+    },
+    get [Symbol.toStringTag]() {
+      return "Map";
+    },
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  });
+  Object.defineProperties(map, {
+    data: {
+      enumerable: false
+    },
+    size: {
+      enumerable: false
+    },
+    toJSON: {
+      enumerable: false
+    }
+  });
+  Object.seal(map);
+  return map;
+}
+
+export { addComputed_DEPRECATED as addComputed, derive, devtools, proxyMap, proxySet, proxyWithComputed, proxyWithHistory, subscribeKey, underive, unstable_deriveSubscriptions, watch };

node_modules/valtio/esm/utils/addComputed.d.ts

@@ -0,0 +1,8 @@
+/**
+ * addComputed (DEPRECATED)
+ *
+ * @deprecated Please consider using `derive` or `proxyWithComputed` instead.
+ */
+export declare function addComputed_DEPRECATED<T extends object, U extends object>(proxyObject: T, computedFns_FAKE: {
+    [K in keyof U]: (snap_FAKE: T) => U[K];
+}, targetObject?: any): any;

node_modules/valtio/esm/utils/derive.d.ts

@@ -0,0 +1,72 @@
+declare type DeriveGet = <T extends object>(proxyObject: T) => T;
+declare type Subscription = {
+    s: object;
+    d: object;
+    k: string;
+    c: () => void;
+    n: boolean;
+    i: string[];
+    p?: Promise<void>;
+};
+export declare const unstable_deriveSubscriptions: {
+    add: (subscription: Subscription) => void;
+    remove: (subscription: Subscription) => void;
+    list: (derivedObject: object) => Subscription[];
+};
+/**
+ * derive
+ *
+ * This creates derived properties and attaches them
+ * to a new proxy object or an existing proxy object.
+ *
+ * @example
+ * import { proxy } from 'valtio'
+ * import { derive } from 'valtio/utils'
+ *
+ * const state = proxy({
+ *   count: 1,
+ * })
+ *
+ * const derivedState = derive({
+ *   doubled: (get) => get(state).count * 2,
+ * })
+ *
+ * derive({
+ *   tripled: (get) => get(state).count * 3,
+ * }, {
+ *   proxy: state,
+ * })
+ */
+export declare function derive<T extends object, U extends object>(derivedFns: {
+    [K in keyof U]: (get: DeriveGet) => U[K];
+}, options?: {
+    proxy?: T;
+    sync?: boolean;
+}): T & U;
+/**
+ * underive
+ *
+ * This stops derived properties to evaluate.
+ * It will stop all (or specified by `keys` option) subscriptions.
+ * If you specify `delete` option, it will delete the properties
+ * and you can attach new derived properties.
+ *
+ * @example
+ * import { proxy } from 'valtio'
+ * import { derive, underive } from 'valtio/utils'
+ *
+ * const state = proxy({
+ *   count: 1,
+ * })
+ *
+ * const derivedState = derive({
+ *   doubled: (get) => get(state).count * 2,
+ * })
+ *
+ * underive(derivedState)
+ */
+export declare function underive<T extends object, U extends object>(proxyObject: T & U, options?: {
+    delete?: boolean;
+    keys?: (keyof U)[];
+}): void;
+export {};

node_modules/valtio/esm/utils/devtools.d.ts

@@ -0,0 +1,10 @@
+declare type Options = {
+    enabled?: boolean;
+    name?: string;
+};
+export declare function devtools<T extends object>(proxyObject: T, options?: Options): (() => void) | undefined;
+/**
+ * @deprecated Please use { name } option
+ */
+export declare function devtools<T extends object>(proxyObject: T, name?: string): (() => void) | undefined;
+export {};

node_modules/valtio/esm/utils/proxyMap.d.ts

@@ -0,0 +1,29 @@
+/**
+ * proxyMap
+ *
+ * This is to create a proxy which mimic the native Map behavior.
+ * The API is the same as Map API
+ *
+ * @example
+ * import { proxyMap } from 'valtio/utils'
+ * const state = proxyMap([["key", "value"]])
+ *
+ * //can be used inside a proxy as well
+ * const state = proxy({
+ *   count: 1,
+ *   map: proxyMap()
+ * })
+ *
+ * // When using an object as a key, you can wrap it with `ref` so it's not proxied
+ * // this is useful if you want to preserve the key equality
+ * import { ref } from 'valtio'
+ *
+ * const key = ref({})
+ * state.set(key, "value")
+ * state.get(key) //value
+ *
+ * const key = {}
+ * state.set(key, "value")
+ * state.get(key) //undefined
+ */
+export declare function proxyMap<K, V>(entries?: Iterable<readonly [K, V]> | null): Map<K, V>;

node_modules/valtio/esm/utils/proxySet.d.ts

@@ -0,0 +1,16 @@
+/**
+ * proxySet
+ *
+ * This is to create a proxy which mimic the native Set behavior.
+ * The API is the same as Set API
+ *
+ * @example
+ * import { proxySet } from 'valtio/utils'
+ * const state = proxySet([1,2,3])
+ * //can be used inside a proxy as well
+ * const state = proxy({
+ *   count: 1,
+ *   set: proxySet()
+ * })
+ */
+export declare function proxySet<T>(initialValues?: Iterable<T> | null): Set<T>;

node_modules/valtio/esm/utils/proxyWithComputed.d.ts

@@ -0,0 +1,31 @@
+import type { INTERNAL_Snapshot } from '../vanilla';
+/**
+ * proxyWithComputed
+ *
+ * This is to create a proxy with initial object and additional object,
+ * which specifies getters for computed values with dependency tracking.
+ * It also accepts optional setters for computed values.
+ *
+ * [Notes]
+ * This comes with a cost and overlaps with useSnapshot.
+ * Do not try to optimize too early. It can worsen the performance.
+ * Measurement and comparison will be very important.
+ *
+ * @example
+ * import { proxyWithComputed } from 'valtio/utils'
+ * const state = proxyWithComputed({
+ *   count: 1,
+ * }, {
+ *   doubled: snap => snap.count * 2, // getter only
+ *   tripled: {
+ *     get: snap => snap.count * 3,
+ *     set: (state, newValue) => { state.count = newValue / 3 }
+ *   }, // with optional setter
+ * })
+ */
+export declare function proxyWithComputed<T extends object, U extends object>(initialObject: T, computedFns: {
+    [K in keyof U]: ((snap: INTERNAL_Snapshot<T>) => U[K]) | {
+        get: (snap: INTERNAL_Snapshot<T>) => U[K];
+        set?: (state: T, newValue: U[K]) => void;
+    };
+}): T & U;

node_modules/valtio/esm/utils/proxyWithHistory.d.ts

@@ -0,0 +1,40 @@
+import type { INTERNAL_Snapshot } from '../vanilla';
+/**
+ * proxyWithHistory
+ *
+ * This creates a new proxy with history support.
+ * It includes following properties:
+ * - value: any value (does not have to be an object)
+ * - history: an array holding the history of snapshots
+ * - historyIndex: the history index to the current snapshot
+ * - canUndo: a function to return true if undo is available
+ * - undo: a function to go back history
+ * - canRedo: a function to return true if redo is available
+ * - redo: a function to go forward history
+ * - saveHistory: a function to save history
+ *
+ * [Notes]
+ * Suspense/promise is not supported.
+ *
+ * @example
+ * import { proxyWithHistory } from 'valtio/utils'
+ * const state = proxyWithHistory({
+ *   count: 1,
+ * })
+ */
+export declare function proxyWithHistory<V>(initialValue: V, skipSubscribe?: boolean): {
+    value: V;
+    history: {
+        wip: INTERNAL_Snapshot<V> | undefined;
+        snapshots: INTERNAL_Snapshot<V>[];
+        index: number;
+    } & {
+        $$valtioRef: true;
+    };
+    canUndo: () => boolean;
+    undo: () => void;
+    canRedo: () => boolean;
+    redo: () => void;
+    saveHistory: () => void;
+    subscribe: () => () => void;
+};

node_modules/valtio/esm/utils/subscribeKey.d.ts

@@ -0,0 +1,12 @@
+/**
+ * subscribeKey
+ *
+ * The subscribeKey utility enables subscription to a primitive subproperty of a given state proxy.
+ * Subscriptions created with subscribeKey will only fire when the specified property changes.
+ * notifyInSync: same as the parameter to subscribe(); true disables batching of subscriptions.
+ *
+ * @example
+ * import { subscribeKey } from 'valtio/utils'
+ * subscribeKey(state, 'count', (v) => console.log('state.count has changed to', v))
+ */
+export declare function subscribeKey<T extends object, K extends keyof T>(proxyObject: T, key: K, callback: (value: T[K]) => void, notifyInSync?: boolean): () => void;

node_modules/valtio/esm/utils/watch.d.ts

@@ -0,0 +1,31 @@
+declare type Cleanup = () => void;
+declare type WatchGet = <T extends object>(proxyObject: T) => T;
+declare type WatchCallback = (get: WatchGet) => Cleanup | void | undefined;
+declare type WatchOptions = {
+    sync?: boolean;
+};
+/**
+ * watch
+ *
+ * Creates a reactive effect that automatically tracks proxy objects and
+ * reevaluates everytime one of the tracked proxy objects updates. It returns
+ * a cleanup function to stop the reactive effect from reevaluating.
+ *
+ * Callback is invoked immediately to detect the tracked objects.
+ *
+ * Callback passed to `watch` receives a `get` function that "tracks" the
+ * passed proxy object.
+ *
+ * Watch callbacks may return an optional cleanup function, which is evaluated
+ * whenever the callback reevaluates or when the cleanup function returned by
+ * `watch` is evaluated.
+ *
+ * `watch` calls inside `watch` are also automatically tracked and cleaned up
+ * whenever the parent `watch` reevaluates.
+ *
+ * @param callback
+ * @returns A cleanup function that stops the callback from reevaluating and
+ * also performs cleanups registered into `watch`.
+ */
+export declare function watch(callback: WatchCallback, options?: WatchOptions): Cleanup;
+export {};

node_modules/valtio/esm/vanilla.d.ts

@@ -0,0 +1,20 @@
+declare type AsRef = {
+    $$valtioRef: true;
+};
+declare type Path = (string | symbol)[];
+declare type Op = [op: 'set', path: Path, value: unknown, prevValue: unknown] | [op: 'delete', path: Path, prevValue: unknown] | [op: 'resolve', path: Path, value: unknown] | [op: 'reject', path: Path, error: unknown];
+declare type AnyFunction = (...args: any[]) => any;
+/**
+ * This is not a public API.
+ * It can be changed without any notice.
+ */
+export declare type INTERNAL_Snapshot<T> = T extends AnyFunction ? T : T extends AsRef ? T : T extends Promise<infer V> ? INTERNAL_Snapshot<V> : {
+    readonly [K in keyof T]: INTERNAL_Snapshot<T[K]>;
+};
+export declare function proxy<T extends object>(initialObject?: T): T;
+export declare function getVersion(proxyObject: unknown): number | undefined;
+export declare function subscribe<T extends object>(proxyObject: T, callback: (ops: Op[]) => void, notifyInSync?: boolean): () => void;
+export declare function snapshot<T extends object>(proxyObject: T): INTERNAL_Snapshot<T>;
+export declare function ref<T extends object>(obj: T): T & AsRef;
+export declare const unstable_buildProxyFunction: (objectIs?: (value1: any, value2: any) => boolean, newProxy?: <T extends object>(target: T, handler: ProxyHandler<T>) => T, canProxy?: (x: unknown) => boolean, PROMISE_RESULT?: symbol, PROMISE_ERROR?: symbol, snapshotCache?: WeakMap<object, [version: number, snapshot: unknown]>, createSnapshot?: <T_1 extends object>(version: number, target: T_1, receiver: any) => T_1, proxyCache?: WeakMap<object, object>, versionHolder?: [number], proxyFunction?: <T_2 extends object>(initialObject: T_2) => T_2) => readonly [<T_2 extends object>(initialObject: T_2) => T_2, WeakSet<object>, symbol, symbol, symbol, (value1: any, value2: any) => boolean, <T extends object>(target: T, handler: ProxyHandler<T>) => T, (x: unknown) => boolean, symbol, symbol, WeakMap<object, [version: number, snapshot: unknown]>, <T_1 extends object>(version: number, target: T_1, receiver: any) => T_1, WeakMap<object, object>, [number]];
+export {};

node_modules/valtio/esm/vanilla.js

@@ -0,0 +1,215 @@
+import { markToTrack, getUntracked } from 'proxy-compare';
+
+const isObject = (x) => typeof x === "object" && x !== null;
+const refSet = /* @__PURE__ */ new WeakSet();
+const VERSION = (import.meta.env && import.meta.env.MODE) !== "production" ? Symbol("VERSION") : Symbol();
+const LISTENERS = (import.meta.env && import.meta.env.MODE) !== "production" ? Symbol("LISTENERS") : Symbol();
+const SNAPSHOT = (import.meta.env && import.meta.env.MODE) !== "production" ? Symbol("SNAPSHOT") : Symbol();
+const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), canProxy = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer), PROMISE_RESULT = (import.meta.env && import.meta.env.MODE) !== "production" ? Symbol("PROMISE_RESULT") : Symbol(), PROMISE_ERROR = (import.meta.env && import.meta.env.MODE) !== "production" ? Symbol("PROMISE_ERROR") : Symbol(), snapshotCache = /* @__PURE__ */ new WeakMap(), createSnapshot = (version, target, receiver) => {
+  const cache = snapshotCache.get(receiver);
+  if ((cache == null ? void 0 : cache[0]) === version) {
+    return cache[1];
+  }
+  const snapshot2 = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
+  markToTrack(snapshot2, true);
+  snapshotCache.set(receiver, [version, snapshot2]);
+  Reflect.ownKeys(target).forEach((key) => {
+    const value = Reflect.get(target, key, receiver);
+    if (refSet.has(value)) {
+      markToTrack(value, false);
+      snapshot2[key] = value;
+    } else if (value instanceof Promise) {
+      if (PROMISE_RESULT in value) {
+        snapshot2[key] = value[PROMISE_RESULT];
+      } else {
+        const errorOrPromise = value[PROMISE_ERROR] || value;
+        Object.defineProperty(snapshot2, key, {
+          get() {
+            if (PROMISE_RESULT in value) {
+              return value[PROMISE_RESULT];
+            }
+            throw errorOrPromise;
+          }
+        });
+      }
+    } else if (value == null ? void 0 : value[LISTENERS]) {
+      snapshot2[key] = value[SNAPSHOT];
+    } else {
+      snapshot2[key] = value;
+    }
+  });
+  return Object.freeze(snapshot2);
+}, proxyCache = /* @__PURE__ */ new WeakMap(), versionHolder = [1], proxyFunction2 = (initialObject) => {
+  if (!isObject(initialObject)) {
+    throw new Error("object required");
+  }
+  const found = proxyCache.get(initialObject);
+  if (found) {
+    return found;
+  }
+  let version = versionHolder[0];
+  const listeners = /* @__PURE__ */ new Set();
+  const notifyUpdate = (op, nextVersion = ++versionHolder[0]) => {
+    if (version !== nextVersion) {
+      version = nextVersion;
+      listeners.forEach((listener) => listener(op, nextVersion));
+    }
+  };
+  const propListeners = /* @__PURE__ */ new Map();
+  const getPropListener = (prop) => {
+    let propListener = propListeners.get(prop);
+    if (!propListener) {
+      propListener = (op, nextVersion) => {
+        const newOp = [...op];
+        newOp[1] = [prop, ...newOp[1]];
+        notifyUpdate(newOp, nextVersion);
+      };
+      propListeners.set(prop, propListener);
+    }
+    return propListener;
+  };
+  const popPropListener = (prop) => {
+    const propListener = propListeners.get(prop);
+    propListeners.delete(prop);
+    return propListener;
+  };
+  const baseObject = Array.isArray(initialObject) ? [] : Object.create(Object.getPrototypeOf(initialObject));
+  const handler = {
+    get(target, prop, receiver) {
+      if (prop === VERSION) {
+        return version;
+      }
+      if (prop === LISTENERS) {
+        return listeners;
+      }
+      if (prop === SNAPSHOT) {
+        return createSnapshot(version, target, receiver);
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    deleteProperty(target, prop) {
+      const prevValue = Reflect.get(target, prop);
+      const childListeners = prevValue == null ? void 0 : prevValue[LISTENERS];
+      if (childListeners) {
+        childListeners.delete(popPropListener(prop));
+      }
+      const deleted = Reflect.deleteProperty(target, prop);
+      if (deleted) {
+        notifyUpdate(["delete", [prop], prevValue]);
+      }
+      return deleted;
+    },
+    set(target, prop, value, receiver) {
+      var _a;
+      const hasPrevValue = Reflect.has(target, prop);
+      const prevValue = Reflect.get(target, prop, receiver);
+      if (hasPrevValue && objectIs(prevValue, value)) {
+        return true;
+      }
+      const childListeners = prevValue == null ? void 0 : prevValue[LISTENERS];
+      if (childListeners) {
+        childListeners.delete(popPropListener(prop));
+      }
+      if (isObject(value)) {
+        value = getUntracked(value) || value;
+      }
+      let nextValue;
+      if ((_a = Object.getOwnPropertyDescriptor(target, prop)) == null ? void 0 : _a.set) {
+        nextValue = value;
+      } else if (value instanceof Promise) {
+        nextValue = value.then((v) => {
+          nextValue[PROMISE_RESULT] = v;
+          notifyUpdate(["resolve", [prop], v]);
+          return v;
+        }).catch((e) => {
+          nextValue[PROMISE_ERROR] = e;
+          notifyUpdate(["reject", [prop], e]);
+        });
+      } else if (value == null ? void 0 : value[LISTENERS]) {
+        nextValue = value;
+        nextValue[LISTENERS].add(getPropListener(prop));
+      } else if (canProxy(value)) {
+        nextValue = proxy(value);
+        nextValue[LISTENERS].add(getPropListener(prop));
+      } else {
+        nextValue = value;
+      }
+      Reflect.set(target, prop, nextValue, receiver);
+      notifyUpdate(["set", [prop], value, prevValue]);
+      return true;
+    }
+  };
+  const proxyObject = newProxy(baseObject, handler);
+  proxyCache.set(initialObject, proxyObject);
+  Reflect.ownKeys(initialObject).forEach((key) => {
+    const desc = Object.getOwnPropertyDescriptor(
+      initialObject,
+      key
+    );
+    if (desc.get || desc.set) {
+      Object.defineProperty(baseObject, key, desc);
+    } else {
+      proxyObject[key] = initialObject[key];
+    }
+  });
+  return proxyObject;
+}) => [
+  proxyFunction2,
+  refSet,
+  VERSION,
+  LISTENERS,
+  SNAPSHOT,
+  objectIs,
+  newProxy,
+  canProxy,
+  PROMISE_RESULT,
+  PROMISE_ERROR,
+  snapshotCache,
+  createSnapshot,
+  proxyCache,
+  versionHolder
+];
+const [proxyFunction] = buildProxyFunction();
+function proxy(initialObject = {}) {
+  return proxyFunction(initialObject);
+}
+function getVersion(proxyObject) {
+  return isObject(proxyObject) ? proxyObject[VERSION] : void 0;
+}
+function subscribe(proxyObject, callback, notifyInSync) {
+  if ((import.meta.env && import.meta.env.MODE) !== "production" && !(proxyObject == null ? void 0 : proxyObject[LISTENERS])) {
+    console.warn("Please use proxy object");
+  }
+  let promise;
+  const ops = [];
+  const listener = (op) => {
+    ops.push(op);
+    if (notifyInSync) {
+      callback(ops.splice(0));
+      return;
+    }
+    if (!promise) {
+      promise = Promise.resolve().then(() => {
+        promise = void 0;
+        callback(ops.splice(0));
+      });
+    }
+  };
+  proxyObject[LISTENERS].add(listener);
+  return () => {
+    proxyObject[LISTENERS].delete(listener);
+  };
+}
+function snapshot(proxyObject) {
+  if ((import.meta.env && import.meta.env.MODE) !== "production" && !(proxyObject == null ? void 0 : proxyObject[SNAPSHOT])) {
+    console.warn("Please use proxy object");
+  }
+  return proxyObject[SNAPSHOT];
+}
+function ref(obj) {
+  refSet.add(obj);
+  return obj;
+}
+const unstable_buildProxyFunction = buildProxyFunction;
+
+export { getVersion, proxy, ref, snapshot, subscribe, unstable_buildProxyFunction };

node_modules/valtio/esm/vanilla.mjs

@@ -0,0 +1,215 @@
+import { markToTrack, getUntracked } from 'proxy-compare';
+
+const isObject = (x) => typeof x === "object" && x !== null;
+const refSet = /* @__PURE__ */ new WeakSet();
+const VERSION = (import.meta.env && import.meta.env.MODE) !== "production" ? Symbol("VERSION") : Symbol();
+const LISTENERS = (import.meta.env && import.meta.env.MODE) !== "production" ? Symbol("LISTENERS") : Symbol();
+const SNAPSHOT = (import.meta.env && import.meta.env.MODE) !== "production" ? Symbol("SNAPSHOT") : Symbol();
+const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), canProxy = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer), PROMISE_RESULT = (import.meta.env && import.meta.env.MODE) !== "production" ? Symbol("PROMISE_RESULT") : Symbol(), PROMISE_ERROR = (import.meta.env && import.meta.env.MODE) !== "production" ? Symbol("PROMISE_ERROR") : Symbol(), snapshotCache = /* @__PURE__ */ new WeakMap(), createSnapshot = (version, target, receiver) => {
+  const cache = snapshotCache.get(receiver);
+  if ((cache == null ? void 0 : cache[0]) === version) {
+    return cache[1];
+  }
+  const snapshot2 = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
+  markToTrack(snapshot2, true);
+  snapshotCache.set(receiver, [version, snapshot2]);
+  Reflect.ownKeys(target).forEach((key) => {
+    const value = Reflect.get(target, key, receiver);
+    if (refSet.has(value)) {
+      markToTrack(value, false);
+      snapshot2[key] = value;
+    } else if (value instanceof Promise) {
+      if (PROMISE_RESULT in value) {
+        snapshot2[key] = value[PROMISE_RESULT];
+      } else {
+        const errorOrPromise = value[PROMISE_ERROR] || value;
+        Object.defineProperty(snapshot2, key, {
+          get() {
+            if (PROMISE_RESULT in value) {
+              return value[PROMISE_RESULT];
+            }
+            throw errorOrPromise;
+          }
+        });
+      }
+    } else if (value == null ? void 0 : value[LISTENERS]) {
+      snapshot2[key] = value[SNAPSHOT];
+    } else {
+      snapshot2[key] = value;
+    }
+  });
+  return Object.freeze(snapshot2);
+}, proxyCache = /* @__PURE__ */ new WeakMap(), versionHolder = [1], proxyFunction2 = (initialObject) => {
+  if (!isObject(initialObject)) {
+    throw new Error("object required");
+  }
+  const found = proxyCache.get(initialObject);
+  if (found) {
+    return found;
+  }
+  let version = versionHolder[0];
+  const listeners = /* @__PURE__ */ new Set();
+  const notifyUpdate = (op, nextVersion = ++versionHolder[0]) => {
+    if (version !== nextVersion) {
+      version = nextVersion;
+      listeners.forEach((listener) => listener(op, nextVersion));
+    }
+  };
+  const propListeners = /* @__PURE__ */ new Map();
+  const getPropListener = (prop) => {
+    let propListener = propListeners.get(prop);
+    if (!propListener) {
+      propListener = (op, nextVersion) => {
+        const newOp = [...op];
+        newOp[1] = [prop, ...newOp[1]];
+        notifyUpdate(newOp, nextVersion);
+      };
+      propListeners.set(prop, propListener);
+    }
+    return propListener;
+  };
+  const popPropListener = (prop) => {
+    const propListener = propListeners.get(prop);
+    propListeners.delete(prop);
+    return propListener;
+  };
+  const baseObject = Array.isArray(initialObject) ? [] : Object.create(Object.getPrototypeOf(initialObject));
+  const handler = {
+    get(target, prop, receiver) {
+      if (prop === VERSION) {
+        return version;
+      }
+      if (prop === LISTENERS) {
+        return listeners;
+      }
+      if (prop === SNAPSHOT) {
+        return createSnapshot(version, target, receiver);
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    deleteProperty(target, prop) {
+      const prevValue = Reflect.get(target, prop);
+      const childListeners = prevValue == null ? void 0 : prevValue[LISTENERS];
+      if (childListeners) {
+        childListeners.delete(popPropListener(prop));
+      }
+      const deleted = Reflect.deleteProperty(target, prop);
+      if (deleted) {
+        notifyUpdate(["delete", [prop], prevValue]);
+      }
+      return deleted;
+    },
+    set(target, prop, value, receiver) {
+      var _a;
+      const hasPrevValue = Reflect.has(target, prop);
+      const prevValue = Reflect.get(target, prop, receiver);
+      if (hasPrevValue && objectIs(prevValue, value)) {
+        return true;
+      }
+      const childListeners = prevValue == null ? void 0 : prevValue[LISTENERS];
+      if (childListeners) {
+        childListeners.delete(popPropListener(prop));
+      }
+      if (isObject(value)) {
+        value = getUntracked(value) || value;
+      }
+      let nextValue;
+      if ((_a = Object.getOwnPropertyDescriptor(target, prop)) == null ? void 0 : _a.set) {
+        nextValue = value;
+      } else if (value instanceof Promise) {
+        nextValue = value.then((v) => {
+          nextValue[PROMISE_RESULT] = v;
+          notifyUpdate(["resolve", [prop], v]);
+          return v;
+        }).catch((e) => {
+          nextValue[PROMISE_ERROR] = e;
+          notifyUpdate(["reject", [prop], e]);
+        });
+      } else if (value == null ? void 0 : value[LISTENERS]) {
+        nextValue = value;
+        nextValue[LISTENERS].add(getPropListener(prop));
+      } else if (canProxy(value)) {
+        nextValue = proxy(value);
+        nextValue[LISTENERS].add(getPropListener(prop));
+      } else {
+        nextValue = value;
+      }
+      Reflect.set(target, prop, nextValue, receiver);
+      notifyUpdate(["set", [prop], value, prevValue]);
+      return true;
+    }
+  };
+  const proxyObject = newProxy(baseObject, handler);
+  proxyCache.set(initialObject, proxyObject);
+  Reflect.ownKeys(initialObject).forEach((key) => {
+    const desc = Object.getOwnPropertyDescriptor(
+      initialObject,
+      key
+    );
+    if (desc.get || desc.set) {
+      Object.defineProperty(baseObject, key, desc);
+    } else {
+      proxyObject[key] = initialObject[key];
+    }
+  });
+  return proxyObject;
+}) => [
+  proxyFunction2,
+  refSet,
+  VERSION,
+  LISTENERS,
+  SNAPSHOT,
+  objectIs,
+  newProxy,
+  canProxy,
+  PROMISE_RESULT,
+  PROMISE_ERROR,
+  snapshotCache,
+  createSnapshot,
+  proxyCache,
+  versionHolder
+];
+const [proxyFunction] = buildProxyFunction();
+function proxy(initialObject = {}) {
+  return proxyFunction(initialObject);
+}
+function getVersion(proxyObject) {
+  return isObject(proxyObject) ? proxyObject[VERSION] : void 0;
+}
+function subscribe(proxyObject, callback, notifyInSync) {
+  if ((import.meta.env && import.meta.env.MODE) !== "production" && !(proxyObject == null ? void 0 : proxyObject[LISTENERS])) {
+    console.warn("Please use proxy object");
+  }
+  let promise;
+  const ops = [];
+  const listener = (op) => {
+    ops.push(op);
+    if (notifyInSync) {
+      callback(ops.splice(0));
+      return;
+    }
+    if (!promise) {
+      promise = Promise.resolve().then(() => {
+        promise = void 0;
+        callback(ops.splice(0));
+      });
+    }
+  };
+  proxyObject[LISTENERS].add(listener);
+  return () => {
+    proxyObject[LISTENERS].delete(listener);
+  };
+}
+function snapshot(proxyObject) {
+  if ((import.meta.env && import.meta.env.MODE) !== "production" && !(proxyObject == null ? void 0 : proxyObject[SNAPSHOT])) {
+    console.warn("Please use proxy object");
+  }
+  return proxyObject[SNAPSHOT];
+}
+function ref(obj) {
+  refSet.add(obj);
+  return obj;
+}
+const unstable_buildProxyFunction = buildProxyFunction;
+
+export { getVersion, proxy, ref, snapshot, subscribe, unstable_buildProxyFunction };