@arcote.tech/arc-host 0.1.8 → 0.1.10

package/dist/index.js

@@ -554,8 +554,8 @@ var require_sign_stream = __commonJS((exports, module) => {
   var Stream = __require("node:stream");
   var toString = require_tostring();
   var util = __require("node:util");
-  function base64url(string2, encoding) {
-    return Buffer2.from(string2, encoding).toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  function base64url(string, encoding) {
+    return Buffer2.from(string, encoding).toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
   }
   function jwsSecuredInput(header, payload, encoding) {
     encoding = encoding || "utf8";
@@ -623,11 +623,11 @@ var require_verify_stream = __commonJS((exports, module) => {
   var toString = require_tostring();
   var util = __require("node:util");
   var JWS_REGEX = /^[a-zA-Z0-9\-_]+?\.[a-zA-Z0-9\-_]+?\.([a-zA-Z0-9\-_]+)?$/;
-  function isObject2(thing) {
+  function isObject(thing) {
     return Object.prototype.toString.call(thing) === "[object Object]";
   }
   function safeJsonParse(thing) {
-    if (isObject2(thing))
+    if (isObject(thing))
       return thing;
     try {
       return JSON.parse(thing);
@@ -650,8 +650,8 @@ var require_verify_stream = __commonJS((exports, module) => {
     var payload = jwsSig.split(".")[1];
     return Buffer2.from(payload, "base64").toString(encoding);
   }
-  function isValidJws(string2) {
-    return JWS_REGEX.test(string2) && !!headerFromJWS(string2);
+  function isValidJws(string) {
+    return JWS_REGEX.test(string) && !!headerFromJWS(string);
   }
   function jwsVerify(jwsSig, algorithm, secretOrKey) {
     if (!algorithm) {
@@ -1155,14 +1155,14 @@ var require_semver = __commonJS((exports, module) => {
       if (!m[4]) {
         this.prerelease = [];
       } else {
-        this.prerelease = m[4].split(".").map((id2) => {
-          if (/^[0-9]+$/.test(id2)) {
-            const num = +id2;
+        this.prerelease = m[4].split(".").map((id) => {
+          if (/^[0-9]+$/.test(id)) {
+            const num = +id;
             if (num >= 0 && num < MAX_SAFE_INTEGER) {
               return num;
             }
           }
-          return id2;
+          return id;
         });
       }
       this.build = m[5] ? m[5].split(".") : [];
@@ -1883,7 +1883,7 @@ var require_range = __commonJS((exports, module) => {
     debug("stars", comp);
     return comp;
   };
-  var isX = (id2) => !id2 || id2.toLowerCase() === "x" || id2 === "*";
+  var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
   var replaceTildes = (comp, options) => {
     return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
   };
@@ -2049,20 +2049,20 @@ var require_range = __commonJS((exports, module) => {
     }
     return `${from} ${to}`.trim();
   };
-  var testSet = (set2, version, options) => {
-    for (let i = 0;i < set2.length; i++) {
-      if (!set2[i].test(version)) {
+  var testSet = (set, version, options) => {
+    for (let i = 0;i < set.length; i++) {
+      if (!set[i].test(version)) {
         return false;
       }
     }
     if (version.prerelease.length && !options.includePrerelease) {
-      for (let i = 0;i < set2.length; i++) {
-        debug(set2[i].semver);
-        if (set2[i].semver === Comparator.ANY) {
+      for (let i = 0;i < set.length; i++) {
+        debug(set[i].semver);
+        if (set[i].semver === Comparator.ANY) {
           continue;
         }
-        if (set2[i].semver.prerelease.length > 0) {
-          const allowed = set2[i].semver;
+        if (set[i].semver.prerelease.length > 0) {
+          const allowed = set[i].semver;
           if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
             return true;
           }
@@ -2421,7 +2421,7 @@ var require_simplify = __commonJS((exports, module) => {
   var satisfies = require_satisfies();
   var compare = require_compare();
   module.exports = (versions, range, options) => {
-    const set2 = [];
+    const set = [];
     let first = null;
     let prev = null;
     const v = versions.sort((a, b) => compare(a, b, options));
@@ -2434,17 +2434,17 @@ var require_simplify = __commonJS((exports, module) => {
         }
       } else {
         if (prev) {
-          set2.push([first, prev]);
+          set.push([first, prev]);
         }
         prev = null;
         first = null;
       }
     }
     if (first) {
-      set2.push([first, null]);
+      set.push([first, null]);
     }
     const ranges = [];
-    for (const [min, max] of set2) {
+    for (const [min, max] of set) {
       if (min === max) {
         ranges.push(min);
       } else if (!max && min === v[0]) {
@@ -3121,13 +3121,13 @@ var require_lodash = __commonJS((exports, module) => {
     return isObjectLike(value) && isArrayLike(value);
   }
   function isFunction(value) {
-    var tag = isObject2(value) ? objectToString.call(value) : "";
+    var tag = isObject(value) ? objectToString.call(value) : "";
     return tag == funcTag || tag == genTag;
   }
   function isLength(value) {
     return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
   }
-  function isObject2(value) {
+  function isObject(value) {
     var type = typeof value;
     return !!value && (type == "object" || type == "function");
   }
@@ -3162,9 +3162,9 @@ var require_lodash = __commonJS((exports, module) => {
     if (isSymbol(value)) {
       return NAN;
     }
-    if (isObject2(value)) {
+    if (isObject(value)) {
       var other = typeof value.valueOf == "function" ? value.valueOf() : value;
-      value = isObject2(other) ? other + "" : other;
+      value = isObject(other) ? other + "" : other;
     }
     if (typeof value != "string") {
       return value === 0 ? value : +value;
@@ -3212,7 +3212,7 @@ var require_lodash3 = __commonJS((exports, module) => {
   function isInteger(value) {
     return typeof value == "number" && value == toInteger(value);
   }
-  function isObject2(value) {
+  function isObject(value) {
     var type = typeof value;
     return !!value && (type == "object" || type == "function");
   }
@@ -3244,9 +3244,9 @@ var require_lodash3 = __commonJS((exports, module) => {
     if (isSymbol(value)) {
       return NAN;
     }
-    if (isObject2(value)) {
+    if (isObject(value)) {
       var other = typeof value.valueOf == "function" ? value.valueOf() : value;
-      value = isObject2(other) ? other + "" : other;
+      value = isObject(other) ? other + "" : other;
     }
     if (typeof value != "string") {
       return value === 0 ? value : +value;
@@ -3361,7 +3361,7 @@ var require_lodash7 = __commonJS((exports, module) => {
   function once(func) {
     return before(2, func);
   }
-  function isObject2(value) {
+  function isObject(value) {
     var type = typeof value;
     return !!value && (type == "object" || type == "function");
   }
@@ -3393,9 +3393,9 @@ var require_lodash7 = __commonJS((exports, module) => {
     if (isSymbol(value)) {
       return NAN;
     }
-    if (isObject2(value)) {
+    if (isObject(value)) {
       var other = typeof value.valueOf == "function" ? value.valueOf() : value;
-      value = isObject2(other) ? other + "" : other;
+      value = isObject(other) ? other + "" : other;
     }
     if (typeof value != "string") {
       return value === 0 ? value : +value;
@@ -3641,3154 +3641,13 @@ var require_jsonwebtoken = __commonJS((exports, module) => {
   };
 });
 
-// ../../node_modules/mutative/dist/mutative.esm.mjs
-var Operation = {
-  Remove: "remove",
-  Replace: "replace",
-  Add: "add"
-};
-var PROXY_DRAFT = Symbol.for("__MUTATIVE_PROXY_DRAFT__");
-var RAW_RETURN_SYMBOL = Symbol("__MUTATIVE_RAW_RETURN_SYMBOL__");
-var iteratorSymbol = Symbol.iterator;
-var dataTypes = {
-  mutable: "mutable",
-  immutable: "immutable"
-};
-var internal = {};
-function latest(proxyDraft) {
-  var _a;
-  return (_a = proxyDraft.copy) !== null && _a !== undefined ? _a : proxyDraft.original;
-}
-function isDraft(target) {
-  return !!getProxyDraft(target);
-}
-function getProxyDraft(value) {
-  if (typeof value !== "object")
-    return null;
-  return value === null || value === undefined ? undefined : value[PROXY_DRAFT];
-}
-function getValue(value) {
-  var _a;
-  const proxyDraft = getProxyDraft(value);
-  return proxyDraft ? (_a = proxyDraft.copy) !== null && _a !== undefined ? _a : proxyDraft.original : value;
-}
-function isDraftable(value, options) {
-  if (!value || typeof value !== "object")
-    return false;
-  let markResult;
-  return Object.getPrototypeOf(value) === Object.prototype || Array.isArray(value) || value instanceof Map || value instanceof Set || !!(options === null || options === undefined ? undefined : options.mark) && ((markResult = options.mark(value, dataTypes)) === dataTypes.immutable || typeof markResult === "function");
-}
-function getPath(target, path = []) {
-  if (Object.hasOwnProperty.call(target, "key")) {
-    const proxyDraft = getProxyDraft(get(target.parent.copy, target.key));
-    if (proxyDraft !== null && (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== target.original) {
-      return null;
-    }
-    path.push(target.parent.type === 3 ? Array.from(target.parent.setMap.keys()).indexOf(target.key) : target.key);
-  }
-  if (target.parent) {
-    return getPath(target.parent, path);
-  }
-  return path.reverse();
-}
-function getType(target) {
-  if (Array.isArray(target))
-    return 1;
-  if (target instanceof Map)
-    return 2;
-  if (target instanceof Set)
-    return 3;
-  return 0;
-}
-function get(target, key) {
-  return getType(target) === 2 ? target.get(key) : target[key];
-}
-function set(target, key, value) {
-  const type = getType(target);
-  if (type === 2) {
-    target.set(key, value);
-  } else {
-    target[key] = value;
-  }
-}
-function peek(target, key) {
-  const state = getProxyDraft(target);
-  const source = state ? latest(state) : target;
-  return source[key];
-}
-function isEqual(x, y) {
-  if (x === y) {
-    return x !== 0 || 1 / x === 1 / y;
-  } else {
-    return x !== x && y !== y;
-  }
-}
-function revokeProxy(proxyDraft) {
-  if (!proxyDraft)
-    return;
-  while (proxyDraft.finalities.revoke.length > 0) {
-    const revoke = proxyDraft.finalities.revoke.pop();
-    revoke();
-  }
-}
-function escapePath(path, pathAsArray) {
-  return pathAsArray ? path : [""].concat(path).map((_item) => {
-    const item = `${_item}`;
-    if (item.indexOf("/") === -1 && item.indexOf("~") === -1)
-      return item;
-    return item.replace(/~/g, "~0").replace(/\//g, "~1");
-  }).join("/");
-}
-function unescapePath(path) {
-  if (Array.isArray(path))
-    return path;
-  return path.split("/").map((_item) => _item.replace(/~1/g, "/").replace(/~0/g, "~")).slice(1);
-}
-function strictCopy(target) {
-  const copy = Object.create(Object.getPrototypeOf(target));
-  Reflect.ownKeys(target).forEach((key) => {
-    let desc = Reflect.getOwnPropertyDescriptor(target, key);
-    if (desc.enumerable && desc.configurable && desc.writable) {
-      copy[key] = target[key];
-      return;
-    }
-    if (!desc.writable) {
-      desc.writable = true;
-      desc.configurable = true;
-    }
-    if (desc.get || desc.set)
-      desc = {
-        configurable: true,
-        writable: true,
-        enumerable: desc.enumerable,
-        value: target[key]
-      };
-    Reflect.defineProperty(copy, key, desc);
-  });
-  return copy;
-}
-var propIsEnum = Object.prototype.propertyIsEnumerable;
-function shallowCopy(original, options) {
-  let markResult;
-  if (Array.isArray(original)) {
-    return Array.prototype.concat.call(original);
-  } else if (original instanceof Set) {
-    return new Set(original.values());
-  } else if (original instanceof Map) {
-    return new Map(original);
-  } else if ((options === null || options === undefined ? undefined : options.mark) && (markResult = options.mark(original, dataTypes), markResult !== undefined) && markResult !== dataTypes.mutable) {
-    if (markResult === dataTypes.immutable) {
-      return strictCopy(original);
-    } else if (typeof markResult === "function") {
-      if (options.enablePatches || options.enableAutoFreeze) {
-        throw new Error(`You can't use mark and patches or auto freeze together.`);
-      }
-      return markResult();
-    }
-    throw new Error(`Unsupported mark result: ${markResult}`);
-  } else if (typeof original === "object" && Object.getPrototypeOf(original) === Object.prototype) {
-    const copy = {};
-    Object.keys(original).forEach((key) => {
-      copy[key] = original[key];
-    });
-    Object.getOwnPropertySymbols(original).forEach((key) => {
-      if (propIsEnum.call(original, key)) {
-        copy[key] = original[key];
-      }
-    });
-    return copy;
-  } else {
-    throw new Error(`Please check mark() to ensure that it is a stable marker draftable function.`);
-  }
-}
-function ensureShallowCopy(target) {
-  if (target.copy)
-    return;
-  target.copy = shallowCopy(target.original, target.options);
-}
-function deepClone(target) {
-  if (!isDraftable(target))
-    return getValue(target);
-  if (Array.isArray(target))
-    return target.map(deepClone);
-  if (target instanceof Map)
-    return new Map(Array.from(target.entries()).map(([k, v]) => [k, deepClone(v)]));
-  if (target instanceof Set)
-    return new Set(Array.from(target).map(deepClone));
-  const copy = Object.create(Object.getPrototypeOf(target));
-  for (const key in target)
-    copy[key] = deepClone(target[key]);
-  return copy;
-}
-function cloneIfNeeded(target) {
-  return isDraft(target) ? deepClone(target) : target;
-}
-function markChanged(proxyDraft) {
-  var _a;
-  proxyDraft.assignedMap = (_a = proxyDraft.assignedMap) !== null && _a !== undefined ? _a : new Map;
-  if (!proxyDraft.operated) {
-    proxyDraft.operated = true;
-    if (proxyDraft.parent) {
-      markChanged(proxyDraft.parent);
-    }
-  }
-}
-function throwFrozenError() {
-  throw new Error("Cannot modify frozen object");
-}
-function deepFreeze(target, subKey, updatedValues, stack, keys) {
-  {
-    updatedValues = updatedValues !== null && updatedValues !== undefined ? updatedValues : new WeakMap;
-    stack = stack !== null && stack !== undefined ? stack : [];
-    keys = keys !== null && keys !== undefined ? keys : [];
-    const value = updatedValues.has(target) ? updatedValues.get(target) : target;
-    if (stack.length > 0) {
-      const index = stack.indexOf(value);
-      if (value && typeof value === "object" && index !== -1) {
-        if (stack[0] === value) {
-          throw new Error(`Forbids circular reference`);
-        }
-        throw new Error(`Forbids circular reference: ~/${keys.slice(0, index).map((key, index2) => {
-          if (typeof key === "symbol")
-            return `[${key.toString()}]`;
-          const parent = stack[index2];
-          if (typeof key === "object" && (parent instanceof Map || parent instanceof Set))
-            return Array.from(parent.keys()).indexOf(key);
-          return key;
-        }).join("/")}`);
-      }
-      stack.push(value);
-      keys.push(subKey);
-    } else {
-      stack.push(value);
-    }
-  }
-  if (Object.isFrozen(target) || isDraft(target)) {
-    {
-      stack.pop();
-      keys.pop();
-    }
-    return;
-  }
-  const type = getType(target);
-  switch (type) {
-    case 2:
-      for (const [key, value] of target) {
-        deepFreeze(key, key, updatedValues, stack, keys);
-        deepFreeze(value, key, updatedValues, stack, keys);
-      }
-      target.set = target.clear = target.delete = throwFrozenError;
-      break;
-    case 3:
-      for (const value of target) {
-        deepFreeze(value, value, updatedValues, stack, keys);
-      }
-      target.add = target.clear = target.delete = throwFrozenError;
-      break;
-    case 1:
-      Object.freeze(target);
-      let index = 0;
-      for (const value of target) {
-        deepFreeze(value, index, updatedValues, stack, keys);
-        index += 1;
-      }
-      break;
-    default:
-      Object.freeze(target);
-      Object.keys(target).forEach((name) => {
-        const value = target[name];
-        deepFreeze(value, name, updatedValues, stack, keys);
-      });
-  }
-  {
-    stack.pop();
-    keys.pop();
-  }
-}
-function has(target, key) {
-  return target instanceof Map ? target.has(key) : Object.prototype.hasOwnProperty.call(target, key);
-}
-function getDescriptor(target, key) {
-  if (key in target) {
-    let prototype = Reflect.getPrototypeOf(target);
-    while (prototype) {
-      const descriptor = Reflect.getOwnPropertyDescriptor(prototype, key);
-      if (descriptor)
-        return descriptor;
-      prototype = Reflect.getPrototypeOf(prototype);
-    }
-  }
-  return;
-}
-function forEach(target, iter) {
-  const type = getType(target);
-  if (type === 0) {
-    Reflect.ownKeys(target).forEach((key) => {
-      iter(key, target[key], target);
-    });
-  } else if (type === 1) {
-    let index = 0;
-    for (const entry of target) {
-      iter(index, entry, target);
-      index += 1;
-    }
-  } else {
-    target.forEach((entry, index) => iter(index, entry, target));
-  }
-}
-function handleValue(target, handledSet, options) {
-  if (isDraft(target) || !isDraftable(target, options) || handledSet.has(target) || Object.isFrozen(target))
-    return;
-  const isSet = target instanceof Set;
-  const setMap = isSet ? new Map : undefined;
-  handledSet.add(target);
-  forEach(target, (key, value) => {
-    var _a;
-    if (isDraft(value)) {
-      const proxyDraft = getProxyDraft(value);
-      ensureShallowCopy(proxyDraft);
-      const updatedValue = ((_a = proxyDraft.assignedMap) === null || _a === undefined ? undefined : _a.size) || proxyDraft.operated ? proxyDraft.copy : proxyDraft.original;
-      set(isSet ? setMap : target, key, updatedValue);
-    } else {
-      handleValue(value, handledSet, options);
-    }
-  });
-  if (setMap) {
-    const set2 = target;
-    const values = Array.from(set2);
-    set2.clear();
-    values.forEach((value) => {
-      set2.add(setMap.has(value) ? setMap.get(value) : value);
-    });
-  }
-}
-function finalizeAssigned(proxyDraft, key) {
-  const copy = proxyDraft.type === 3 ? proxyDraft.setMap : proxyDraft.copy;
-  if (proxyDraft.finalities.revoke.length > 1 && proxyDraft.assignedMap.get(key) && copy) {
-    handleValue(get(copy, key), proxyDraft.finalities.handledSet, proxyDraft.options);
-  }
-}
-function finalizeSetValue(target) {
-  if (target.type === 3 && target.copy) {
-    target.copy.clear();
-    target.setMap.forEach((value) => {
-      target.copy.add(getValue(value));
-    });
-  }
-}
-function finalizePatches(target, generatePatches, patches, inversePatches) {
-  const shouldFinalize = target.operated && target.assignedMap && target.assignedMap.size > 0 && !target.finalized;
-  if (shouldFinalize) {
-    if (patches && inversePatches) {
-      const basePath = getPath(target);
-      if (basePath) {
-        generatePatches(target, basePath, patches, inversePatches);
-      }
-    }
-    target.finalized = true;
-  }
-}
-function markFinalization(target, key, value, generatePatches) {
-  const proxyDraft = getProxyDraft(value);
-  if (proxyDraft) {
-    if (!proxyDraft.callbacks) {
-      proxyDraft.callbacks = [];
-    }
-    proxyDraft.callbacks.push((patches, inversePatches) => {
-      var _a;
-      const copy = target.type === 3 ? target.setMap : target.copy;
-      if (isEqual(get(copy, key), value)) {
-        let updatedValue = proxyDraft.original;
-        if (proxyDraft.copy) {
-          updatedValue = proxyDraft.copy;
-        }
-        finalizeSetValue(target);
-        finalizePatches(target, generatePatches, patches, inversePatches);
-        if (target.options.enableAutoFreeze) {
-          target.options.updatedValues = (_a = target.options.updatedValues) !== null && _a !== undefined ? _a : new WeakMap;
-          target.options.updatedValues.set(updatedValue, proxyDraft.original);
-        }
-        set(copy, key, updatedValue);
-      }
-    });
-    if (target.options.enableAutoFreeze) {
-      if (proxyDraft.finalities !== target.finalities) {
-        target.options.enableAutoFreeze = false;
-      }
-    }
-  }
-  if (isDraftable(value, target.options)) {
-    target.finalities.draft.push(() => {
-      const copy = target.type === 3 ? target.setMap : target.copy;
-      if (isEqual(get(copy, key), value)) {
-        finalizeAssigned(target, key);
-      }
-    });
-  }
-}
-function generateArrayPatches(proxyState, basePath, patches, inversePatches, pathAsArray) {
-  let { original, assignedMap, options } = proxyState;
-  let copy = proxyState.copy;
-  if (copy.length < original.length) {
-    [original, copy] = [copy, original];
-    [patches, inversePatches] = [inversePatches, patches];
-  }
-  for (let index = 0;index < original.length; index += 1) {
-    if (assignedMap.get(index.toString()) && copy[index] !== original[index]) {
-      const _path = basePath.concat([index]);
-      const path = escapePath(_path, pathAsArray);
-      patches.push({
-        op: Operation.Replace,
-        path,
-        value: cloneIfNeeded(copy[index])
-      });
-      inversePatches.push({
-        op: Operation.Replace,
-        path,
-        value: cloneIfNeeded(original[index])
-      });
-    }
-  }
-  for (let index = original.length;index < copy.length; index += 1) {
-    const _path = basePath.concat([index]);
-    const path = escapePath(_path, pathAsArray);
-    patches.push({
-      op: Operation.Add,
-      path,
-      value: cloneIfNeeded(copy[index])
-    });
-  }
-  if (original.length < copy.length) {
-    const { arrayLengthAssignment = true } = options.enablePatches;
-    if (arrayLengthAssignment) {
-      const _path = basePath.concat(["length"]);
-      const path = escapePath(_path, pathAsArray);
-      inversePatches.push({
-        op: Operation.Replace,
-        path,
-        value: original.length
-      });
-    } else {
-      for (let index = copy.length;original.length < index; index -= 1) {
-        const _path = basePath.concat([index - 1]);
-        const path = escapePath(_path, pathAsArray);
-        inversePatches.push({
-          op: Operation.Remove,
-          path
-        });
-      }
-    }
-  }
-}
-function generatePatchesFromAssigned({ original, copy, assignedMap }, basePath, patches, inversePatches, pathAsArray) {
-  assignedMap.forEach((assignedValue, key) => {
-    const originalValue = get(original, key);
-    const value = cloneIfNeeded(get(copy, key));
-    const op = !assignedValue ? Operation.Remove : has(original, key) ? Operation.Replace : Operation.Add;
-    if (isEqual(originalValue, value) && op === Operation.Replace)
-      return;
-    const _path = basePath.concat(key);
-    const path = escapePath(_path, pathAsArray);
-    patches.push(op === Operation.Remove ? { op, path } : { op, path, value });
-    inversePatches.push(op === Operation.Add ? { op: Operation.Remove, path } : op === Operation.Remove ? { op: Operation.Add, path, value: originalValue } : { op: Operation.Replace, path, value: originalValue });
-  });
-}
-function generateSetPatches({ original, copy }, basePath, patches, inversePatches, pathAsArray) {
-  let index = 0;
-  original.forEach((value) => {
-    if (!copy.has(value)) {
-      const _path = basePath.concat([index]);
-      const path = escapePath(_path, pathAsArray);
-      patches.push({
-        op: Operation.Remove,
-        path,
-        value
-      });
-      inversePatches.unshift({
-        op: Operation.Add,
-        path,
-        value
-      });
-    }
-    index += 1;
-  });
-  index = 0;
-  copy.forEach((value) => {
-    if (!original.has(value)) {
-      const _path = basePath.concat([index]);
-      const path = escapePath(_path, pathAsArray);
-      patches.push({
-        op: Operation.Add,
-        path,
-        value
-      });
-      inversePatches.unshift({
-        op: Operation.Remove,
-        path,
-        value
-      });
-    }
-    index += 1;
-  });
-}
-function generatePatches(proxyState, basePath, patches, inversePatches) {
-  const { pathAsArray = true } = proxyState.options.enablePatches;
-  switch (proxyState.type) {
-    case 0:
-    case 2:
-      return generatePatchesFromAssigned(proxyState, basePath, patches, inversePatches, pathAsArray);
-    case 1:
-      return generateArrayPatches(proxyState, basePath, patches, inversePatches, pathAsArray);
-    case 3:
-      return generateSetPatches(proxyState, basePath, patches, inversePatches, pathAsArray);
-  }
-}
-var readable = false;
-var checkReadable = (value, options, ignoreCheckDraftable = false) => {
-  if (typeof value === "object" && value !== null && (!isDraftable(value, options) || ignoreCheckDraftable) && !readable) {
-    throw new Error(`Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.`);
-  }
-};
-var mapHandler = {
-  get size() {
-    const current = latest(getProxyDraft(this));
-    return current.size;
-  },
-  has(key) {
-    return latest(getProxyDraft(this)).has(key);
-  },
-  set(key, value) {
-    const target = getProxyDraft(this);
-    const source = latest(target);
-    if (!source.has(key) || !isEqual(source.get(key), value)) {
-      ensureShallowCopy(target);
-      markChanged(target);
-      target.assignedMap.set(key, true);
-      target.copy.set(key, value);
-      markFinalization(target, key, value, generatePatches);
-    }
-    return this;
-  },
-  delete(key) {
-    if (!this.has(key)) {
-      return false;
-    }
-    const target = getProxyDraft(this);
-    ensureShallowCopy(target);
-    markChanged(target);
-    if (target.original.has(key)) {
-      target.assignedMap.set(key, false);
-    } else {
-      target.assignedMap.delete(key);
-    }
-    target.copy.delete(key);
-    return true;
-  },
-  clear() {
-    const target = getProxyDraft(this);
-    if (!this.size)
-      return;
-    ensureShallowCopy(target);
-    markChanged(target);
-    target.assignedMap = new Map;
-    for (const [key] of target.original) {
-      target.assignedMap.set(key, false);
-    }
-    target.copy.clear();
-  },
-  forEach(callback, thisArg) {
-    const target = getProxyDraft(this);
-    latest(target).forEach((_value, _key) => {
-      callback.call(thisArg, this.get(_key), _key, this);
-    });
-  },
-  get(key) {
-    var _a, _b;
-    const target = getProxyDraft(this);
-    const value = latest(target).get(key);
-    const mutable = ((_b = (_a = target.options).mark) === null || _b === undefined ? undefined : _b.call(_a, value, dataTypes)) === dataTypes.mutable;
-    if (target.options.strict) {
-      checkReadable(value, target.options, mutable);
-    }
-    if (mutable) {
-      return value;
-    }
-    if (target.finalized || !isDraftable(value, target.options)) {
-      return value;
-    }
-    if (value !== target.original.get(key)) {
-      return value;
-    }
-    const draft = internal.createDraft({
-      original: value,
-      parentDraft: target,
-      key,
-      finalities: target.finalities,
-      options: target.options
-    });
-    ensureShallowCopy(target);
-    target.copy.set(key, draft);
-    return draft;
-  },
-  keys() {
-    return latest(getProxyDraft(this)).keys();
-  },
-  values() {
-    const iterator = this.keys();
-    return {
-      [iteratorSymbol]: () => this.values(),
-      next: () => {
-        const result = iterator.next();
-        if (result.done)
-          return result;
-        const value = this.get(result.value);
-        return {
-          done: false,
-          value
-        };
-      }
-    };
-  },
-  entries() {
-    const iterator = this.keys();
-    return {
-      [iteratorSymbol]: () => this.entries(),
-      next: () => {
-        const result = iterator.next();
-        if (result.done)
-          return result;
-        const value = this.get(result.value);
-        return {
-          done: false,
-          value: [result.value, value]
-        };
-      }
-    };
-  },
-  [iteratorSymbol]() {
-    return this.entries();
-  }
-};
-var mapHandlerKeys = Reflect.ownKeys(mapHandler);
-var getNextIterator = (target, iterator, { isValuesIterator }) => () => {
-  var _a, _b;
-  const result = iterator.next();
-  if (result.done)
-    return result;
-  const key = result.value;
-  let value = target.setMap.get(key);
-  const currentDraft = getProxyDraft(value);
-  const mutable = ((_b = (_a = target.options).mark) === null || _b === undefined ? undefined : _b.call(_a, value, dataTypes)) === dataTypes.mutable;
-  if (target.options.strict) {
-    checkReadable(key, target.options, mutable);
-  }
-  if (!mutable && !currentDraft && isDraftable(key, target.options) && !target.finalized && target.original.has(key)) {
-    const proxy = internal.createDraft({
-      original: key,
-      parentDraft: target,
-      key,
-      finalities: target.finalities,
-      options: target.options
-    });
-    target.setMap.set(key, proxy);
-    value = proxy;
-  } else if (currentDraft) {
-    value = currentDraft.proxy;
-  }
-  return {
-    done: false,
-    value: isValuesIterator ? value : [value, value]
-  };
-};
-var setHandler = {
-  get size() {
-    const target = getProxyDraft(this);
-    return target.setMap.size;
-  },
-  has(value) {
-    const target = getProxyDraft(this);
-    if (target.setMap.has(value))
-      return true;
-    ensureShallowCopy(target);
-    const valueProxyDraft = getProxyDraft(value);
-    if (valueProxyDraft && target.setMap.has(valueProxyDraft.original))
-      return true;
-    return false;
-  },
-  add(value) {
-    const target = getProxyDraft(this);
-    if (!this.has(value)) {
-      ensureShallowCopy(target);
-      markChanged(target);
-      target.assignedMap.set(value, true);
-      target.setMap.set(value, value);
-      markFinalization(target, value, value, generatePatches);
-    }
-    return this;
-  },
-  delete(value) {
-    if (!this.has(value)) {
-      return false;
-    }
-    const target = getProxyDraft(this);
-    ensureShallowCopy(target);
-    markChanged(target);
-    const valueProxyDraft = getProxyDraft(value);
-    if (valueProxyDraft && target.setMap.has(valueProxyDraft.original)) {
-      target.assignedMap.set(valueProxyDraft.original, false);
-      return target.setMap.delete(valueProxyDraft.original);
-    }
-    if (!valueProxyDraft && target.setMap.has(value)) {
-      target.assignedMap.set(value, false);
-    } else {
-      target.assignedMap.delete(value);
-    }
-    return target.setMap.delete(value);
-  },
-  clear() {
-    if (!this.size)
-      return;
-    const target = getProxyDraft(this);
-    ensureShallowCopy(target);
-    markChanged(target);
-    for (const value of target.original) {
-      target.assignedMap.set(value, false);
-    }
-    target.setMap.clear();
-  },
-  values() {
-    const target = getProxyDraft(this);
-    ensureShallowCopy(target);
-    const iterator = target.setMap.keys();
-    return {
-      [Symbol.iterator]: () => this.values(),
-      next: getNextIterator(target, iterator, { isValuesIterator: true })
-    };
-  },
-  entries() {
-    const target = getProxyDraft(this);
-    ensureShallowCopy(target);
-    const iterator = target.setMap.keys();
-    return {
-      [Symbol.iterator]: () => this.entries(),
-      next: getNextIterator(target, iterator, {
-        isValuesIterator: false
-      })
-    };
-  },
-  keys() {
-    return this.values();
-  },
-  [iteratorSymbol]() {
-    return this.values();
-  },
-  forEach(callback, thisArg) {
-    const iterator = this.values();
-    let result = iterator.next();
-    while (!result.done) {
-      callback.call(thisArg, result.value, result.value, this);
-      result = iterator.next();
-    }
-  }
-};
-var setHandlerKeys = Reflect.ownKeys(setHandler);
-var draftsCache = new WeakSet;
-var proxyHandler = {
-  get(target, key, receiver) {
-    var _a, _b;
-    const copy = (_a = target.copy) === null || _a === undefined ? undefined : _a[key];
-    if (copy && draftsCache.has(copy)) {
-      return copy;
-    }
-    if (key === PROXY_DRAFT)
-      return target;
-    let markResult;
-    if (target.options.mark) {
-      const value2 = key === "size" && (target.original instanceof Map || target.original instanceof Set) ? Reflect.get(target.original, key) : Reflect.get(target.original, key, receiver);
-      markResult = target.options.mark(value2, dataTypes);
-      if (markResult === dataTypes.mutable) {
-        if (target.options.strict) {
-          checkReadable(value2, target.options, true);
-        }
-        return value2;
-      }
-    }
-    const source = latest(target);
-    if (source instanceof Map && mapHandlerKeys.includes(key)) {
-      if (key === "size") {
-        return Object.getOwnPropertyDescriptor(mapHandler, "size").get.call(target.proxy);
-      }
-      const handle = mapHandler[key];
-      if (handle) {
-        return handle.bind(target.proxy);
-      }
-    }
-    if (source instanceof Set && setHandlerKeys.includes(key)) {
-      if (key === "size") {
-        return Object.getOwnPropertyDescriptor(setHandler, "size").get.call(target.proxy);
-      }
-      const handle = setHandler[key];
-      if (handle) {
-        return handle.bind(target.proxy);
-      }
-    }
-    if (!has(source, key)) {
-      const desc = getDescriptor(source, key);
-      return desc ? `value` in desc ? desc.value : (_b = desc.get) === null || _b === undefined ? undefined : _b.call(target.proxy) : undefined;
-    }
-    const value = source[key];
-    if (target.options.strict) {
-      checkReadable(value, target.options);
-    }
-    if (target.finalized || !isDraftable(value, target.options)) {
-      return value;
-    }
-    if (value === peek(target.original, key)) {
-      ensureShallowCopy(target);
-      target.copy[key] = createDraft({
-        original: target.original[key],
-        parentDraft: target,
-        key: target.type === 1 ? Number(key) : key,
-        finalities: target.finalities,
-        options: target.options
-      });
-      if (typeof markResult === "function") {
-        const subProxyDraft = getProxyDraft(target.copy[key]);
-        ensureShallowCopy(subProxyDraft);
-        markChanged(subProxyDraft);
-        return subProxyDraft.copy;
-      }
-      return target.copy[key];
-    }
-    return value;
-  },
-  set(target, key, value) {
-    var _a;
-    if (target.type === 3 || target.type === 2) {
-      throw new Error(`Map/Set draft does not support any property assignment.`);
-    }
-    let _key;
-    if (target.type === 1 && key !== "length" && !(Number.isInteger(_key = Number(key)) && _key >= 0 && (key === 0 || _key === 0 || String(_key) === String(key)))) {
-      throw new Error(`Only supports setting array indices and the 'length' property.`);
-    }
-    const desc = getDescriptor(latest(target), key);
-    if (desc === null || desc === undefined ? undefined : desc.set) {
-      desc.set.call(target.proxy, value);
-      return true;
-    }
-    const current = peek(latest(target), key);
-    const currentProxyDraft = getProxyDraft(current);
-    if (currentProxyDraft && isEqual(currentProxyDraft.original, value)) {
-      target.copy[key] = value;
-      target.assignedMap = (_a = target.assignedMap) !== null && _a !== undefined ? _a : new Map;
-      target.assignedMap.set(key, false);
-      return true;
-    }
-    if (isEqual(value, current) && (value !== undefined || has(target.original, key)))
-      return true;
-    ensureShallowCopy(target);
-    markChanged(target);
-    if (has(target.original, key) && isEqual(value, target.original[key])) {
-      target.assignedMap.delete(key);
-    } else {
-      target.assignedMap.set(key, true);
-    }
-    target.copy[key] = value;
-    markFinalization(target, key, value, generatePatches);
-    return true;
-  },
-  has(target, key) {
-    return key in latest(target);
-  },
-  ownKeys(target) {
-    return Reflect.ownKeys(latest(target));
-  },
-  getOwnPropertyDescriptor(target, key) {
-    const source = latest(target);
-    const descriptor = Reflect.getOwnPropertyDescriptor(source, key);
-    if (!descriptor)
-      return descriptor;
-    return {
-      writable: true,
-      configurable: target.type !== 1 || key !== "length",
-      enumerable: descriptor.enumerable,
-      value: source[key]
-    };
-  },
-  getPrototypeOf(target) {
-    return Reflect.getPrototypeOf(target.original);
-  },
-  setPrototypeOf() {
-    throw new Error(`Cannot call 'setPrototypeOf()' on drafts`);
-  },
-  defineProperty() {
-    throw new Error(`Cannot call 'defineProperty()' on drafts`);
-  },
-  deleteProperty(target, key) {
-    var _a;
-    if (target.type === 1) {
-      return proxyHandler.set.call(this, target, key, undefined, target.proxy);
-    }
-    if (peek(target.original, key) !== undefined || key in target.original) {
-      ensureShallowCopy(target);
-      markChanged(target);
-      target.assignedMap.set(key, false);
-    } else {
-      target.assignedMap = (_a = target.assignedMap) !== null && _a !== undefined ? _a : new Map;
-      target.assignedMap.delete(key);
-    }
-    if (target.copy)
-      delete target.copy[key];
-    return true;
-  }
-};
-function createDraft(createDraftOptions) {
-  const { original, parentDraft, key, finalities, options } = createDraftOptions;
-  const type = getType(original);
-  const proxyDraft = {
-    type,
-    finalized: false,
-    parent: parentDraft,
-    original,
-    copy: null,
-    proxy: null,
-    finalities,
-    options,
-    setMap: type === 3 ? new Map(original.entries()) : undefined
-  };
-  if (key || "key" in createDraftOptions) {
-    proxyDraft.key = key;
-  }
-  const { proxy, revoke } = Proxy.revocable(type === 1 ? Object.assign([], proxyDraft) : proxyDraft, proxyHandler);
-  finalities.revoke.push(revoke);
-  draftsCache.add(proxy);
-  proxyDraft.proxy = proxy;
-  if (parentDraft) {
-    const target = parentDraft;
-    target.finalities.draft.push((patches, inversePatches) => {
-      var _a, _b;
-      const oldProxyDraft = getProxyDraft(proxy);
-      let copy = target.type === 3 ? target.setMap : target.copy;
-      const draft = get(copy, key);
-      const proxyDraft2 = getProxyDraft(draft);
-      if (proxyDraft2) {
-        let updatedValue = proxyDraft2.original;
-        if (proxyDraft2.operated) {
-          updatedValue = getValue(draft);
-        }
-        finalizeSetValue(proxyDraft2);
-        finalizePatches(proxyDraft2, generatePatches, patches, inversePatches);
-        if (target.options.enableAutoFreeze) {
-          target.options.updatedValues = (_a = target.options.updatedValues) !== null && _a !== undefined ? _a : new WeakMap;
-          target.options.updatedValues.set(updatedValue, proxyDraft2.original);
-        }
-        set(copy, key, updatedValue);
-      }
-      (_b = oldProxyDraft.callbacks) === null || _b === undefined || _b.forEach((callback) => {
-        callback(patches, inversePatches);
-      });
-    });
-  } else {
-    const target = getProxyDraft(proxy);
-    target.finalities.draft.push((patches, inversePatches) => {
-      finalizeSetValue(target);
-      finalizePatches(target, generatePatches, patches, inversePatches);
-    });
-  }
-  return proxy;
-}
-internal.createDraft = createDraft;
-function finalizeDraft(result, returnedValue, patches, inversePatches, enableAutoFreeze) {
-  var _a;
-  const proxyDraft = getProxyDraft(result);
-  const original = (_a = proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== null && _a !== undefined ? _a : result;
-  const hasReturnedValue = !!returnedValue.length;
-  if (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.operated) {
-    while (proxyDraft.finalities.draft.length > 0) {
-      const finalize = proxyDraft.finalities.draft.pop();
-      finalize(patches, inversePatches);
-    }
-  }
-  const state = hasReturnedValue ? returnedValue[0] : proxyDraft ? proxyDraft.operated ? proxyDraft.copy : proxyDraft.original : result;
-  if (proxyDraft)
-    revokeProxy(proxyDraft);
-  if (enableAutoFreeze) {
-    deepFreeze(state, state, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options.updatedValues);
-  }
-  return [
-    state,
-    patches && hasReturnedValue ? [{ op: Operation.Replace, path: [], value: returnedValue[0] }] : patches,
-    inversePatches && hasReturnedValue ? [{ op: Operation.Replace, path: [], value: original }] : inversePatches
-  ];
-}
-function draftify(baseState, options) {
-  var _a;
-  const finalities = {
-    draft: [],
-    revoke: [],
-    handledSet: new WeakSet
-  };
-  let patches;
-  let inversePatches;
-  if (options.enablePatches) {
-    patches = [];
-    inversePatches = [];
-  }
-  const isMutable = ((_a = options.mark) === null || _a === undefined ? undefined : _a.call(options, baseState, dataTypes)) === dataTypes.mutable || !isDraftable(baseState, options);
-  const draft = isMutable ? baseState : createDraft({
-    original: baseState,
-    parentDraft: null,
-    finalities,
-    options
-  });
-  return [
-    draft,
-    (returnedValue = []) => {
-      const [finalizedState, finalizedPatches, finalizedInversePatches] = finalizeDraft(draft, returnedValue, patches, inversePatches, options.enableAutoFreeze);
-      return options.enablePatches ? [finalizedState, finalizedPatches, finalizedInversePatches] : finalizedState;
-    }
-  ];
-}
-function handleReturnValue(options) {
-  const { rootDraft, value, useRawReturn = false, isRoot = true } = options;
-  forEach(value, (key, item, source) => {
-    const proxyDraft = getProxyDraft(item);
-    if (proxyDraft && rootDraft && proxyDraft.finalities === rootDraft.finalities) {
-      options.isContainDraft = true;
-      const currentValue = proxyDraft.original;
-      if (source instanceof Set) {
-        const arr = Array.from(source);
-        source.clear();
-        arr.forEach((_item) => source.add(key === _item ? currentValue : _item));
-      } else {
-        set(source, key, currentValue);
-      }
-    } else if (typeof item === "object" && item !== null) {
-      options.value = item;
-      options.isRoot = false;
-      handleReturnValue(options);
-    }
-  });
-  if (isRoot) {
-    if (!options.isContainDraft)
-      console.warn(`The return value does not contain any draft, please use 'rawReturn()' to wrap the return value to improve performance.`);
-    if (useRawReturn) {
-      console.warn(`The return value contains drafts, please don't use 'rawReturn()' to wrap the return value.`);
-    }
-  }
-}
-function getCurrent(target) {
-  const proxyDraft = getProxyDraft(target);
-  if (!isDraftable(target, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options))
-    return target;
-  const type = getType(target);
-  if (proxyDraft && !proxyDraft.operated)
-    return proxyDraft.original;
-  let currentValue;
-  function ensureShallowCopy2() {
-    currentValue = type === 2 ? new Map(target) : type === 3 ? Array.from(proxyDraft.setMap.values()) : shallowCopy(target, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options);
-  }
-  if (proxyDraft) {
-    proxyDraft.finalized = true;
-    try {
-      ensureShallowCopy2();
-    } finally {
-      proxyDraft.finalized = false;
-    }
-  } else {
-    currentValue = target;
-  }
-  forEach(currentValue, (key, value) => {
-    if (proxyDraft && isEqual(get(proxyDraft.original, key), value))
-      return;
-    const newValue = getCurrent(value);
-    if (newValue !== value) {
-      if (currentValue === target)
-        ensureShallowCopy2();
-      set(currentValue, key, newValue);
-    }
-  });
-  return type === 3 ? new Set(currentValue) : currentValue;
-}
-function current(target) {
-  if (!isDraft(target)) {
-    throw new Error(`current() is only used for Draft, parameter: ${target}`);
-  }
-  return getCurrent(target);
-}
-var makeCreator = (arg) => {
-  if (arg !== undefined && Object.prototype.toString.call(arg) !== "[object Object]") {
-    throw new Error(`Invalid options: ${String(arg)}, 'options' should be an object.`);
-  }
-  return function create(arg0, arg1, arg2) {
-    var _a, _b, _c;
-    if (typeof arg0 === "function" && typeof arg1 !== "function") {
-      return function(base2, ...args) {
-        return create(base2, (draft2) => arg0.call(this, draft2, ...args), arg1);
-      };
-    }
-    const base = arg0;
-    const mutate = arg1;
-    let options = arg2;
-    if (typeof arg1 !== "function") {
-      options = arg1;
-    }
-    if (options !== undefined && Object.prototype.toString.call(options) !== "[object Object]") {
-      throw new Error(`Invalid options: ${options}, 'options' should be an object.`);
-    }
-    options = Object.assign(Object.assign({}, arg), options);
-    const state = isDraft(base) ? current(base) : base;
-    const mark = Array.isArray(options.mark) ? (value, types) => {
-      for (const mark2 of options.mark) {
-        if (typeof mark2 !== "function") {
-          throw new Error(`Invalid mark: ${mark2}, 'mark' should be a function.`);
-        }
-        const result2 = mark2(value, types);
-        if (result2) {
-          return result2;
-        }
-      }
-      return;
-    } : options.mark;
-    const enablePatches = (_a = options.enablePatches) !== null && _a !== undefined ? _a : false;
-    const strict = (_b = options.strict) !== null && _b !== undefined ? _b : false;
-    const enableAutoFreeze = (_c = options.enableAutoFreeze) !== null && _c !== undefined ? _c : false;
-    const _options = {
-      enableAutoFreeze,
-      mark,
-      strict,
-      enablePatches
-    };
-    if (!isDraftable(state, _options) && typeof state === "object" && state !== null) {
-      throw new Error(`Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.`);
-    }
-    const [draft, finalize] = draftify(state, _options);
-    if (typeof arg1 !== "function") {
-      if (!isDraftable(state, _options)) {
-        throw new Error(`Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.`);
-      }
-      return [draft, finalize];
-    }
-    let result;
-    try {
-      result = mutate(draft);
-    } catch (error) {
-      revokeProxy(getProxyDraft(draft));
-      throw error;
-    }
-    const returnValue = (value) => {
-      const proxyDraft = getProxyDraft(draft);
-      if (!isDraft(value)) {
-        if (value !== undefined && !isEqual(value, draft) && (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.operated)) {
-          throw new Error(`Either the value is returned as a new non-draft value, or only the draft is modified without returning any value.`);
-        }
-        const rawReturnValue = value === null || value === undefined ? undefined : value[RAW_RETURN_SYMBOL];
-        if (rawReturnValue) {
-          const _value = rawReturnValue[0];
-          if (_options.strict && typeof value === "object" && value !== null) {
-            handleReturnValue({
-              rootDraft: proxyDraft,
-              value,
-              useRawReturn: true
-            });
-          }
-          return finalize([_value]);
-        }
-        if (value !== undefined) {
-          if (typeof value === "object" && value !== null) {
-            handleReturnValue({ rootDraft: proxyDraft, value });
-          }
-          return finalize([value]);
-        }
-      }
-      if (value === draft || value === undefined) {
-        return finalize([]);
-      }
-      const returnedProxyDraft = getProxyDraft(value);
-      if (_options === returnedProxyDraft.options) {
-        if (returnedProxyDraft.operated) {
-          throw new Error(`Cannot return a modified child draft.`);
-        }
-        return finalize([current(value)]);
-      }
-      return finalize([value]);
-    };
-    if (result instanceof Promise) {
-      return result.then(returnValue, (error) => {
-        revokeProxy(getProxyDraft(draft));
-        throw error;
-      });
-    }
-    return returnValue(result);
-  };
-};
-var create = makeCreator();
-function apply(state, patches, applyOptions) {
-  let i;
-  for (i = patches.length - 1;i >= 0; i -= 1) {
-    const { value, op, path } = patches[i];
-    if (!path.length && op === Operation.Replace || path === "" && op === Operation.Add) {
-      state = value;
-      break;
-    }
-  }
-  if (i > -1) {
-    patches = patches.slice(i + 1);
-  }
-  const mutate = (draft) => {
-    patches.forEach((patch) => {
-      const { path: _path, op } = patch;
-      const path = unescapePath(_path);
-      let base = draft;
-      for (let index = 0;index < path.length - 1; index += 1) {
-        const parentType = getType(base);
-        let key2 = path[index];
-        if (typeof key2 !== "string" && typeof key2 !== "number") {
-          key2 = String(key2);
-        }
-        if ((parentType === 0 || parentType === 1) && (key2 === "__proto__" || key2 === "constructor") || typeof base === "function" && key2 === "prototype") {
-          throw new Error(`Patching reserved attributes like __proto__ and constructor is not allowed.`);
-        }
-        base = get(getType(base) === 3 ? Array.from(base) : base, key2);
-        if (typeof base !== "object") {
-          throw new Error(`Cannot apply patch at '${path.join("/")}'.`);
-        }
-      }
-      const type = getType(base);
-      const value = deepClone(patch.value);
-      const key = path[path.length - 1];
-      switch (op) {
-        case Operation.Replace:
-          switch (type) {
-            case 2:
-              return base.set(key, value);
-            case 3:
-              throw new Error(`Cannot apply replace patch to set.`);
-            default:
-              return base[key] = value;
-          }
-        case Operation.Add:
-          switch (type) {
-            case 1:
-              return key === "-" ? base.push(value) : base.splice(key, 0, value);
-            case 2:
-              return base.set(key, value);
-            case 3:
-              return base.add(value);
-            default:
-              return base[key] = value;
-          }
-        case Operation.Remove:
-          switch (type) {
-            case 1:
-              return base.splice(key, 1);
-            case 2:
-              return base.delete(key);
-            case 3:
-              return base.delete(patch.value);
-            default:
-              return delete base[key];
-          }
-        default:
-          throw new Error(`Unsupported patch operation: ${op}.`);
-      }
-    });
-  };
-  if (isDraft(state)) {
-    if (applyOptions !== undefined) {
-      throw new Error(`Cannot apply patches with options to a draft.`);
-    }
-    mutate(state);
-    return state;
-  }
-  return create(state, mutate, Object.assign(Object.assign({}, applyOptions), { enablePatches: false }));
-}
-var constructorString = Object.prototype.constructor.toString();
-
-// ../core/dist/index.js
-class ArcContextElement {
-  $event;
-  name;
-  queryBuilder;
-  commandContext;
-  commandClient;
-  observer;
-}
-
-class ArcContextElementWithStore extends ArcContextElement {
-}
-
-class ArcOptional {
-  parent;
-  constructor(parent) {
-    this.parent = parent;
-  }
-  parse(value) {
-    if (!value)
-      return null;
-    return this.parent.parse(value);
-  }
-  serialize(value) {
-    if (value)
-      return this.parent.serialize(value);
-    return null;
-  }
-  deserialize(value) {
-    if (!value)
-      return null;
-    return this.parent.deserialize(value);
-  }
-  validate(value) {
-    if (!value)
-      return false;
-    return this.parent.validate(value);
-  }
-  toJsonSchema() {
-    const parentSchema = this.parent.toJsonSchema?.() ?? {};
-    return {
-      anyOf: [parentSchema, { type: "null" }]
-    };
-  }
-}
-
-class ArcBranded {
-  parent;
-  brand;
-  constructor(parent, brand) {
-    this.parent = parent;
-    this.brand = brand;
-  }
-  serialize(value) {
-    return this.parent.serialize(value);
-  }
-  deserialize(value) {
-    return this.parent.deserialize(value);
-  }
-  parse(value) {
-    return this.parent.parse(value);
-  }
-  optional() {
-    return new ArcOptional(this);
-  }
-  validate(value) {
-    return this.parent.validate(value);
-  }
-  toJsonSchema() {
-    return this.parent.toJsonSchema?.() ?? {};
-  }
-}
-
-class ArcDefault {
-  parent;
-  defaultValueOrCallback;
-  constructor(parent, defaultValueOrCallback) {
-    this.parent = parent;
-    this.defaultValueOrCallback = defaultValueOrCallback;
-  }
-  validate(value) {
-    throw new Error("Method not implemented.");
-  }
-  parse(value) {
-    if (value)
-      return this.parent.parse(value);
-    if (typeof this.defaultValueOrCallback === "function") {
-      return this.defaultValueOrCallback();
-    } else
-      return this.defaultValueOrCallback;
-  }
-  serialize(value) {
-    return this.parent.serialize(value);
-  }
-  deserialize(value) {
-    if (value)
-      return this.parent.deserialize(value);
-    if (typeof this.defaultValueOrCallback === "function") {
-      return this.defaultValueOrCallback();
-    } else
-      return this.defaultValueOrCallback;
-  }
-  toJsonSchema() {
-    const schema = this.parent.toJsonSchema?.() ?? {};
-    const defaultValue = typeof this.defaultValueOrCallback === "function" ? this.defaultValueOrCallback() : this.defaultValueOrCallback;
-    return {
-      ...schema,
-      default: defaultValue
-    };
-  }
-}
-
-class ArcAbstract {
-  validations;
-  constructor(validations = []) {
-    this.validations = validations;
-  }
-  default(defaultValueOrCallback) {
-    return new ArcDefault(this, defaultValueOrCallback);
-  }
-  optional() {
-    return new ArcOptional(this);
-  }
-  branded(name) {
-    return new ArcBranded(this, name);
-  }
-  clone() {
-    const Constructor = this.constructor;
-    const newInstance = Object.assign(new Constructor, this);
-    return newInstance;
-  }
-  validate(value) {
-    const errors = this.validations.reduce((acc, { name, validator }) => {
-      try {
-        acc[name] = validator(value);
-      } catch (error) {
-        acc[name] = error;
-      }
-      return acc;
-    }, {});
-    if (Object.values(errors).some((result) => !!result)) {
-      return errors;
-    }
-    return false;
-  }
-  pipeValidation(name, validator) {
-    const newInstance = this.clone();
-    newInstance.validations = [...this.validations, { name, validator }];
-    return newInstance;
-  }
-  toJsonSchema() {
-    return {};
-  }
-  getValidations() {
-    return this.validations;
-  }
-}
-
-class ArcPrimitive extends ArcAbstract {
-  serialize(value) {
-    return value;
-  }
-  parse(value) {
-    return value;
-  }
-  deserialize(value) {
-    return value;
-  }
-}
-function primitiveTypeComparatorStrategyFactory(type) {
-  return (value) => typeof value === type;
-}
-function typeValidatorBuilder(typeName, comparatorStrategy) {
-  const comparator = comparatorStrategy || primitiveTypeComparatorStrategyFactory(typeName);
-  return {
-    name: "type",
-    validator: (value) => {
-      const valueType = typeof value;
-      if (!comparator(value))
-        return { current: valueType, expected: typeName };
-      return false;
-    }
-  };
-}
-var stringValidator = typeValidatorBuilder("string");
-
-class ArcString extends ArcPrimitive {
-  constructor() {
-    super([stringValidator]);
-  }
-  minLength(min) {
-    return this.validation("minLength", (value) => {
-      if (value.length < min)
-        return {
-          currentLength: value.length,
-          minLength: min
-        };
-    });
-  }
-  maxLength(max) {
-    return this.validation("maxLength", (value) => {
-      if (value.length > max)
-        return {
-          currentLength: value.length,
-          maxLength: max
-        };
-    });
-  }
-  length(number) {
-    return this.validation("length", (value) => {
-      if (value.length !== number) {
-        return {
-          currentLength: value.length,
-          length: number
-        };
-      }
-    });
-  }
-  includes(str) {
-    return this.validation("includes", (value) => {
-      if (!value.includes(str)) {
-        return {
-          currentValue: value,
-          includes: str
-        };
-      }
-    });
-  }
-  startsWith(str) {
-    return this.validation("startsWith", (value) => {
-      if (!value.startsWith(str)) {
-        return {
-          currentValue: value,
-          startsWith: str
-        };
-      }
-    });
-  }
-  endsWith(str) {
-    return this.validation("endsWith", (value) => {
-      if (!value.endsWith(str)) {
-        return {
-          currentValue: value,
-          endsWith: str
-        };
-      }
-    });
-  }
-  regex(regex) {
-    return this.validation("regex", (value) => {
-      if (!regex.test(value)) {
-        return {
-          currentValue: value,
-          regex
-        };
-      }
-    });
-  }
-  email() {
-    const regex = /^(?:(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~.-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~.-]+)*)|(?:"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f])*"))@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$|(?:\[(?:\d{1,3}\.){3}\d{1,3}\])$/;
-    return this.validation("email", (value) => {
-      if (!regex.test(value)) {
-        return {
-          currentEmail: value
-        };
-      }
-    });
-  }
-  toJsonSchema() {
-    return { type: "string" };
-  }
-  url() {
-    const regex = /^(https?):\/\/(?![-0-9])(?!www\.[0-9])(?:[a-zA-Z0-9-]+(?::[a-zA-Z0-9-]+)?@)?(?:localhost|\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b|[a-zA-Z0-9-]+\.)?[a-zA-Z0-9-]+\.(?:[a-zA-Z]{2,}|[a-zA-Z]{2}\.[a-zA-Z]{2})(?::\d{1,5})?(?!\/\/)(?:\/[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(?!\/{2})(?:;[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(\?(?!=)[a-zA-Z0-9&=;]*)?(\#[a-zA-Z0-9-]*)?$|^(https?):\/\/(localhost|\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b)(?::\d{1,5})?(?!\/\/)(?:\/[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(?!\/{2})(?:;[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(\?(?!=)[a-zA-Z0-9&=;]*)?(\#[a-zA-Z0-9-]*)?$/;
-    return this.validation("url", (value) => {
-      if (!regex.test(value)) {
-        return {
-          currentUrl: value
-        };
-      }
-    });
-  }
-  ip() {
-    const IPv4regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
-    const IPv6regex = /^(?:([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|:(:[0-9a-fA-F]{1,4}){1,7}|([0-9a-fA-F]{1,4}:){1,6}:([0-9a-fA-F]{1,4}:){1,6}[0-9a-fA-F]{1,4})$/;
-    return this.validation("ip", (value) => {
-      if (!(IPv4regex.test(value) || IPv6regex.test(value))) {
-        return {
-          currentIP: value
-        };
-      }
-    });
-  }
-  validation(name, validator) {
-    const instance = this.pipeValidation(name, validator);
-    return instance;
-  }
-}
-function string() {
-  return new ArcString;
-}
-
-class ArcCustomId extends ArcBranded {
-  createFn;
-  constructor(name, createFn) {
-    super(string(), name);
-    this.createFn = createFn;
-  }
-  get(...args) {
-    return this.createFn(...args);
-  }
-}
-
-class ArcId extends ArcBranded {
-  generateFn;
-  constructor(name, generateFn) {
-    super(string(), name);
-    this.generateFn = generateFn;
-  }
-  generate() {
-    if (this.generateFn) {
-      return this.generateFn();
-    }
-    var timestamp = (new Date().getTime() / 1000 | 0).toString(16);
-    return timestamp + "xxxxxxxxxxxxxxxx".replace(/[x]/g, function() {
-      return (Math.random() * 16 | 0).toString(16);
-    }).toLowerCase();
-  }
-}
-function id(name, generateFn) {
-  return new ArcId(name, generateFn);
-}
-var objectValidator = typeValidatorBuilder("object");
-
-class ArcObject extends ArcAbstract {
-  rawShape;
-  constructor(rawShape) {
-    super([
-      objectValidator,
-      {
-        name: "schema",
-        validator: (value) => {
-          const errors = Object.entries(this.rawShape).reduce((acc, [key, element]) => {
-            if (!element.validate) {
-              return acc;
-            }
-            acc[key] = element.validate(value[key]);
-            return acc;
-          }, {});
-          if (Object.values(errors).some((result) => !!result)) {
-            return errors;
-          }
-          return false;
-        }
-      }
-    ]);
-    this.rawShape = rawShape;
-  }
-  parse(value) {
-    return Object.entries(this.rawShape).reduce((acc, [key, element]) => {
-      acc[key] = element.parse(value[key]);
-      return acc;
-    }, {});
-  }
-  serialize(value) {
-    return Object.entries(value).reduce((acc, [key, value2]) => {
-      if (!this.rawShape[key]) {
-        acc[key] = value2;
-      } else {
-        acc[key] = this.rawShape[key].serialize(value2);
-      }
-      return acc;
-    }, {});
-  }
-  deserialize(value) {
-    return Object.fromEntries(Object.entries(this.rawShape).map(([key, element]) => [
-      key,
-      element.deserialize(value[key])
-    ]));
-  }
-  deserializePath(path, value) {
-    if (path.length === 0) {
-      return this.deserialize(value);
-    }
-    const [key, ...restPath] = path;
-    const element = this.rawShape[key];
-    if (!element) {
-      console.warn(`No element found for key: ${key}`);
-      return value;
-    }
-    if (element instanceof ArcObject || element instanceof ArcArray) {
-      return element.deserializePath(restPath, value);
-    }
-    return element.deserialize(value);
-  }
-  parsePartial(value) {
-    return Object.entries(value).reduce((acc, [key, value2]) => {
-      acc[key] = this.rawShape[key].parse(value2);
-      return acc;
-    }, {});
-  }
-  deserializePartial(value) {
-    return Object.entries(value).reduce((acc, [key, value2]) => {
-      acc[key] = this.rawShape[key].deserialize(value2);
-      return acc;
-    }, {});
-  }
-  serializePartial(value) {
-    return Object.entries(value).reduce((acc, [key, value2]) => {
-      acc[key] = this.rawShape[key].serialize(value2);
-      return acc;
-    }, {});
-  }
-  validatePartial(value) {
-    const errors = Object.entries(value).reduce((acc, [key, val]) => {
-      if (!this.rawShape[key]) {
-        return acc;
-      }
-      const result = this.rawShape[key].validate(val);
-      if (result) {
-        acc[key] = result;
-      }
-      return acc;
-    }, {});
-    if (Object.keys(errors).length > 0) {
-      return { schema: errors };
-    }
-    return false;
-  }
-  pick(...keys) {
-    return new ArcObject(Object.fromEntries(keys.map((key) => [key, this.rawShape[key]])));
-  }
-  omit(...keys) {
-    return new ArcObject(Object.fromEntries(Object.entries(this.rawShape).filter(([key]) => !keys.includes(key))));
-  }
-  entries() {
-    return Object.entries(this.rawShape);
-  }
-  toJsonSchema() {
-    const properties = {};
-    const required = [];
-    for (const [key, element] of Object.entries(this.rawShape)) {
-      properties[key] = element.toJsonSchema?.() ?? {};
-      if (!(element instanceof ArcOptional)) {
-        required.push(key);
-      }
-    }
-    const schema = {
-      type: "object",
-      properties
-    };
-    if (required.length)
-      schema.required = required;
-    return schema;
-  }
-}
-var arrayValidator = typeValidatorBuilder("array", Array.isArray);
-
-class ArcArray extends ArcAbstract {
-  parent;
-  constructor(parent) {
-    super([
-      arrayValidator,
-      {
-        name: "schema",
-        validator: (values) => {
-          const errors = values.reduce((acc, value, index) => {
-            const error = parent.validate(value);
-            if (error)
-              acc[index] = error;
-            return acc;
-          }, {});
-          if (Object.values(errors).some((result) => !!result)) {
-            return errors;
-          }
-          return false;
-        }
-      }
-    ]);
-    this.parent = parent;
-  }
-  minLength(min) {
-    return this.validation("minLength", (value) => {
-      if (value.length < min)
-        return {
-          currentLength: value.length,
-          minLength: min
-        };
-    });
-  }
-  maxLength(max) {
-    return this.validation("maxLength", (value) => {
-      if (value.length > max)
-        return {
-          currentLength: value.length,
-          maxLength: max
-        };
-    });
-  }
-  length(number) {
-    return this.validation("length", (value) => {
-      if (value.length !== number) {
-        return {
-          currentLength: value.length,
-          length: number
-        };
-      }
-    });
-  }
-  nonEmpty() {
-    return this.validation("nonEmpty", (value) => {
-      if (value.length === 0)
-        return { msg: "array is empty" };
-    });
-  }
-  parse(value) {
-    return value.map((v) => this.parent.parse(v));
-  }
-  serialize(value) {
-    return value.map((v) => this.parent.serialize(v));
-  }
-  deserialize(value) {
-    if (!Array.isArray(value))
-      return [];
-    return value.map((v) => this.parent.deserialize(v));
-  }
-  deserializePath(path, value) {
-    if (path.length === 0) {
-      return this.deserialize(value);
-    }
-    if (this.parent instanceof ArcObject || this.parent instanceof ArcArray) {
-      return this.parent.deserializePath(path, value);
-    }
-    return this.parent.deserialize(value);
-  }
-  validation(name, validator) {
-    const instance = this.pipeValidation(name, validator);
-    return instance;
-  }
-  toJsonSchema() {
-    return {
-      type: "array",
-      items: this.parent.toJsonSchema?.() ?? {}
-    };
-  }
-}
-class ArcBoolean extends ArcPrimitive {
-  hasToBeTrue() {
-    return this.validation("hasToBeTrue", (value) => {
-      if (!value)
-        return {
-          current: value
-        };
-    });
-  }
-  validation(name, validator) {
-    const instance = this.pipeValidation(name, validator);
-    return instance;
-  }
-  toJsonSchema() {
-    return { type: "boolean" };
-  }
-}
-var dateValidator = typeValidatorBuilder("Date", (value) => value instanceof Date);
-
-class ArcDate extends ArcAbstract {
-  constructor() {
-    super([dateValidator]);
-  }
-  parse(value) {
-    return new Date(value);
-  }
-  serialize(value) {
-    if (value instanceof Date) {
-      return value.getTime();
-    }
-    return value;
-  }
-  deserialize(value) {
-    return new Date(value);
-  }
-  after(after) {
-    return this.validation("after", (value) => {
-      if (value <= after)
-        return { current: value, after };
-    });
-  }
-  before(before) {
-    return this.validation("before", (value) => {
-      if (value >= before)
-        return { current: value, before };
-    });
-  }
-  validation(name, validator) {
-    const instance = this.pipeValidation(name, validator);
-    return instance;
-  }
-  toJsonSchema() {
-    return {
-      type: "string",
-      format: "date-time"
-    };
-  }
-}
-var numberValidator = typeValidatorBuilder("number");
-
-class ArcNumber extends ArcPrimitive {
-  constructor() {
-    super([numberValidator]);
-  }
-  min(min) {
-    return this.validation("min", (value) => {
-      if (value < min)
-        return { current: value, min };
-    });
-  }
-  max(max) {
-    return this.validation("max", (value) => {
-      if (value > max)
-        return { current: value, max };
-    });
-  }
-  validation(name, validator) {
-    const instance = this.pipeValidation(name, validator);
-    return instance;
-  }
-  toJsonSchema() {
-    return { type: "number" };
-  }
-}
-function getSQLiteType(element2) {
-  if (element2 instanceof ArcDate) {
-    return "TEXT";
-  }
-  if (element2 instanceof ArcArray || element2 instanceof ArcObject) {
-    return "TEXT";
-  }
-  if (element2 instanceof ArcBoolean) {
-    return "INTEGER";
-  }
-  if (element2 instanceof ArcNumber) {
-    return "NUMBER";
-  }
-  return "TEXT";
-}
-function arcObjectToStoreSchema(tableName, schema) {
-  const columns = schema.entries().map(([name, element2]) => ({
-    name,
-    type: getSQLiteType(element2),
-    isOptional: element2 instanceof ArcOptional
-  }));
-  columns.unshift({
-    name: "_id",
-    type: "TEXT",
-    isOptional: false
-  }, {
-    name: "deleted",
-    type: "INTEGER",
-    isOptional: false,
-    default: 0
-  }, {
-    name: "lastUpdate",
-    type: "TEXT",
-    isOptional: false
-  });
-  return {
-    tables: [
-      {
-        name: tableName,
-        columns,
-        primaryKey: "_id"
-      }
-    ]
-  };
-}
-
-class ArcQuery {
-  lastResult;
-  listeners = new Set;
-  subscribe(listener) {
-    this.listeners.add(listener);
-  }
-  unsubscribe(listener) {
-    this.listeners.delete(listener);
-  }
-  nextResult(result) {
-    this.lastResult = result;
-    this.listeners.forEach((listener) => listener(result));
-  }
-}
-
-class ArcSerializableQuery extends ArcQuery {
-  params;
-  static key;
-  constructor(params) {
-    super();
-    this.params = params;
-  }
-  serialize() {
-    return {
-      key: this.constructor.key,
-      params: this.params
-    };
-  }
-}
-
-class ArcCollectionQuery extends ArcSerializableQuery {
-  collection;
-  bindedChangeHandler = this.changeHandler.bind(this);
-  store;
-  constructor(collection, params) {
-    super(params);
-    this.collection = collection;
-  }
-  async run(dataStorage) {
-    const store = dataStorage.getStore(this.collection.name);
-    this.store = store;
-    const result = await this.fetch(store);
-    this.lastResult = result;
-    return result;
-  }
-  changeHandler(changes) {
-    let resultChanged = false;
-    for (const change of changes) {
-      const response = this.onChange(change);
-      if (response !== false) {
-        this.lastResult = response;
-        resultChanged = true;
-      }
-    }
-    if (resultChanged)
-      this.nextResult(this.lastResult);
-  }
-}
-
-class QueryCollectionResult {
-  result;
-  constructor(result) {
-    this.result = result;
-  }
-  get(id3) {
-    return id3 ? this.result.find((r) => r._id === id3) : undefined;
-  }
-  map(callbackfn) {
-    return this.result.map(callbackfn);
-  }
-  toArray() {
-    return this.result;
-  }
-}
-
-class ArcFindQuery extends ArcCollectionQuery {
-  params;
-  constructor(collection, params) {
-    super(collection, params);
-    this.params = params;
-  }
-  async fetch(store) {
-    const results = await store.find(this.params, this.bindedChangeHandler);
-    return this.createResult(results);
-  }
-  checkItem(item) {
-    if (!this.params.where)
-      return true;
-    return Object.entries(this.params.where).every(([key, condition]) => {
-      const value = item[key];
-      if (typeof condition !== "object" || condition === null) {
-        return value === condition;
-      }
-      return Object.entries(condition).every(([operator, operatorValue]) => {
-        switch (operator) {
-          case "$eq":
-            return value === operatorValue;
-          case "$ne":
-            return value !== operatorValue;
-          case "$gt":
-            return typeof value === "number" && typeof operatorValue === "number" && value > operatorValue;
-          case "$gte":
-            return typeof value === "number" && typeof operatorValue === "number" && value >= operatorValue;
-          case "$lt":
-            return typeof value === "number" && typeof operatorValue === "number" && value < operatorValue;
-          case "$lte":
-            return typeof value === "number" && typeof operatorValue === "number" && value <= operatorValue;
-          case "$in":
-            return Array.isArray(operatorValue) && operatorValue.includes(value);
-          case "$nin":
-            return Array.isArray(operatorValue) && !operatorValue.includes(value);
-          case "$exists":
-            return typeof operatorValue === "boolean" ? operatorValue ? value !== undefined : value === undefined : true;
-          default:
-            return true;
-        }
-      });
-    });
-  }
-  onChange(change) {
-    const lastResult = this.lastResult;
-    const lastResultAsArray = lastResult || [];
-    const index = lastResultAsArray.findIndex((e) => e._id === (change.type === "delete" ? change.id : change.id));
-    const isInLastResult = index !== -1;
-    const shouldBeInTheResult = change.type !== "delete" && this.checkItem(change.item);
-    if (isInLastResult && shouldBeInTheResult)
-      return this.createResult(lastResultAsArray.toSpliced(index, 1, change.item));
-    else if (isInLastResult && (change.type === "delete" || !shouldBeInTheResult))
-      return this.createResult(lastResultAsArray.toSpliced(index, 1));
-    else if (!isInLastResult && shouldBeInTheResult)
-      return this.createResult(lastResultAsArray.concat(change.item));
-    return false;
-  }
-  createResult(result) {
-    return new QueryCollectionResult(result);
-  }
-}
-
-class ArcFindQueryBuilder {
-  collection;
-  queryContext;
-  options;
-  constructor(collection, queryContext, options) {
-    this.collection = collection;
-    this.queryContext = queryContext;
-    this.options = options;
-  }
-  toQuery() {
-    return this.queryContext.cacheQuery(ArcFindQuery, [
-      this.collection,
-      this.options
-    ]);
-  }
-  run() {
-    return this.queryContext.runQuery(this.toQuery());
-  }
-}
-
-class ArcCollection extends ArcContextElementWithStore {
-  name;
-  id;
-  schema;
-  options;
-  _restrictions;
-  constructor(name, id3, schema, options) {
-    super();
-    this.name = name;
-    this.id = id3;
-    this.schema = schema;
-    this.options = options;
-  }
-  storeSchema() {
-    return arcObjectToStoreSchema(this.name, this.schema);
-  }
-  restrictions(authContext) {
-    if (this._restrictions) {
-      return this._restrictions(authContext);
-    }
-    return {
-      read: false,
-      write: false,
-      modify: false,
-      delete: false
-    };
-  }
-  auth(restrictionsFn) {
-    const collection = new ArcCollection(this.name, this.id, this.schema, this.options);
-    collection._restrictions = restrictionsFn;
-    return collection;
-  }
-  serialize(data) {
-    return {
-      _id: this.id.serialize(data._id),
-      ...this.schema.serialize(data)
-    };
-  }
-  deserialize(data) {
-    return {
-      _id: this.id.deserialize(data._id),
-      ...this.schema.deserialize(data)
-    };
-  }
-  queryBuilder = (context) => {
-    return {
-      find: (options) => new ArcFindQueryBuilder(this, context, options || {})
-    };
-  };
-  commandContext = (dataStorage, publishEvent) => {
-    const store = dataStorage.getStore(this.name);
-    return {
-      add: async (data) => {
-        if (this.id instanceof ArcCustomId)
-          throw new Error("Collection with custom id not support 'add' method");
-        const id3 = this.id.generate();
-        const parsed = this.schema.parse(data);
-        const body = {
-          _id: id3,
-          lastUpdate: new Date().toISOString(),
-          ...parsed
-        };
-        await store.set(body);
-        await publishEvent({
-          type: "set",
-          to: body
-        });
-        return { id: id3 };
-      },
-      remove: async (id3) => {
-        await store.remove(id3);
-        return { success: true };
-      },
-      set: async (id3, data) => {
-        const parsed = this.schema.parse(data);
-        const body = {
-          _id: id3,
-          ...parsed
-        };
-        await store.set(body);
-        await publishEvent({
-          type: "set",
-          to: body
-        });
-        return { success: true };
-      },
-      find: async (options) => {
-        return store.find(options);
-      },
-      findOne: async (where) => {
-        const result = await store.find({
-          where,
-          limit: 1
-        });
-        return result[0];
-      },
-      modify: async (id3, data) => {
-        const deserialized = this.schema.serializePartial(data);
-        const { from, to } = await store.modify(id3, deserialized);
-        await publishEvent({
-          type: "modify",
-          changes: deserialized,
-          from,
-          to
-        });
-      },
-      edit: async (id3, editCallback) => {
-        const { from, to } = await store.mutate(id3, editCallback);
-        await publishEvent({
-          type: "mutate",
-          from,
-          to
-        });
-      }
-    };
-  };
-}
-var eventValidator = typeValidatorBuilder("object");
-var eventId = id("event");
-class QueryBuilderContext {
-  queryCache;
-  dataStorage;
-  usedQueries = new Set;
-  constructor(queryCache, dataStorage) {
-    this.queryCache = queryCache;
-    this.dataStorage = dataStorage;
-  }
-  cacheQuery(QueryConstructor, args) {
-    return new QueryConstructor(...args);
-  }
-  runQuery(query) {
-    this.usedQueries.add(query);
-    return query.run(this.dataStorage);
-  }
-  getUsedQueries() {
-    const queries = Array.from(this.usedQueries);
-    this.usedQueries.clear();
-    return queries;
-  }
-}
-function murmurHash(key, seed = 0) {
-  var remainder, bytes, h1, h1b, c1, c1b, c2, c2b, k1, i;
-  remainder = key.length & 3;
-  bytes = key.length - remainder;
-  h1 = seed;
-  c1 = 3432918353;
-  c2 = 461845907;
-  i = 0;
-  while (i < bytes) {
-    k1 = key.charCodeAt(i) & 255 | (key.charCodeAt(++i) & 255) << 8 | (key.charCodeAt(++i) & 255) << 16 | (key.charCodeAt(++i) & 255) << 24;
-    ++i;
-    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
-    k1 = k1 << 15 | k1 >>> 17;
-    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
-    h1 ^= k1;
-    h1 = h1 << 13 | h1 >>> 19;
-    h1b = (h1 & 65535) * 5 + (((h1 >>> 16) * 5 & 65535) << 16) & 4294967295;
-    h1 = (h1b & 65535) + 27492 + (((h1b >>> 16) + 58964 & 65535) << 16);
-  }
-  k1 = 0;
-  switch (remainder) {
-    case 3:
-      k1 ^= (key.charCodeAt(i + 2) & 255) << 16;
-    case 2:
-      k1 ^= (key.charCodeAt(i + 1) & 255) << 8;
-    case 1:
-      k1 ^= key.charCodeAt(i) & 255;
-      k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
-      k1 = k1 << 15 | k1 >>> 17;
-      k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
-      h1 ^= k1;
-  }
-  h1 ^= key.length;
-  h1 ^= h1 >>> 16;
-  h1 = (h1 & 65535) * 2246822507 + (((h1 >>> 16) * 2246822507 & 65535) << 16) & 4294967295;
-  h1 ^= h1 >>> 13;
-  h1 = (h1 & 65535) * 3266489909 + (((h1 >>> 16) * 3266489909 & 65535) << 16) & 4294967295;
-  h1 ^= h1 >>> 16;
-  return h1 >>> 0;
-}
-
-class QueryCache {
-  cache = new Map;
-  getIndexHash(value) {
-    if (typeof value === "number" || typeof value === "string" || typeof value === "function" || value === null || value === undefined) {
-      return value;
-    }
-    return murmurHash(value);
-  }
-  set(index, query) {
-    let current2 = this.cache;
-    for (let i = 0;i < index.length - 1; i++) {
-      const hashedIndex = this.getIndexHash(index[i]);
-      if (!current2.has(hashedIndex)) {
-        current2.set(hashedIndex, new Map);
-      }
-      current2 = current2.get(hashedIndex);
-    }
-    const lastHashedIndex = this.getIndexHash(index[index.length - 1]);
-    current2.set(lastHashedIndex, query);
-  }
-  get(index) {
-    let current2 = this.cache;
-    for (let i = 0;i < index.length - 1; i++) {
-      const hashedIndex = this.getIndexHash(index[i]);
-      if (!current2.has(hashedIndex)) {
-        return;
-      }
-      current2 = current2.get(hashedIndex);
-    }
-    const lastHashedIndex = this.getIndexHash(index[index.length - 1]);
-    return current2.get(lastHashedIndex);
-  }
-  debug() {
-    return this.cache;
-  }
-}
-
-class ReactiveQuery extends ArcQuery {
-  queryContext;
-  queryBuilder;
-  fn;
-  queries = [];
-  constructor(queryContext, queryBuilder, fn) {
-    super();
-    this.queryContext = queryContext;
-    this.queryBuilder = queryBuilder;
-    this.fn = fn;
-  }
-  run() {
-    const promise = new Promise(async (resolve) => {
-      const value = await this.runQuery();
-      resolve(value);
-    });
-    return promise;
-  }
-  onChangeHandler = this.onChange.bind(this);
-  async onChange() {
-    const value = await this.runQuery();
-    await this.nextResult(value);
-  }
-  async runQuery() {
-    const value = await this.fn(this.queryBuilder);
-    const queries = this.queryContext.getUsedQueries();
-    this.queries.forEach((query) => {
-      if (!queries.includes(query)) {
-        query.unsubscribe(this.onChangeHandler);
-      }
-    });
-    queries.forEach((query) => {
-      if (!this.queries.includes(query)) {
-        query.subscribe(this.onChangeHandler);
-      }
-    });
-    this.queries = queries;
-    return value;
-  }
-}
-class DataStorage {
-  async commitChanges(changes) {
-    await Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
-  }
-}
-function deepMerge(target, source) {
-  const output = { ...target };
-  for (const key in source) {
-    if (source[key] === undefined) {
-      output[key] = undefined;
-      continue;
-    }
-    if (isObject(source[key]) && isObject(target[key])) {
-      output[key] = deepMerge(target[key], source[key]);
-    } else {
-      output[key] = source[key];
-    }
-  }
-  return output;
-}
-function isObject(item) {
-  return item && typeof item === "object" && !Array.isArray(item);
-}
-
-class StoreState {
-  storeName;
-  dataStorage;
-  deserialize;
-  listeners = new Map;
-  constructor(storeName, dataStorage, deserialize) {
-    this.storeName = storeName;
-    this.dataStorage = dataStorage;
-    this.deserialize = deserialize;
-  }
-  fork() {
-    return new ForkedStoreState(this.storeName, this.dataStorage, this);
-  }
-  async set(item) {
-    const change = {
-      type: "set",
-      data: item
-    };
-    await this.applyChanges([change]);
-  }
-  async remove(id3) {
-    const change = {
-      type: "delete",
-      id: id3
-    };
-    await this.applyChanges([change]);
-  }
-  async modify(id3, data) {
-    const change = {
-      type: "modify",
-      id: id3,
-      data
-    };
-    const { from, to } = await this.applyChange(change);
-    return { from, to };
-  }
-  async mutate(id3, editCallback) {
-    const result = await this.find({ where: { _id: id3 } });
-    const object3 = result[0];
-    const [draft, finalize] = create(object3 || {}, { enablePatches: true });
-    await editCallback(draft);
-    const [_, patches] = finalize();
-    const change = {
-      type: "mutate",
-      id: id3,
-      patches
-    };
-    const { from, to } = await this.applyChange(change);
-    return { from, to };
-  }
-  applySerializedChanges(changes) {
-    return Promise.all(changes.map((change) => this.applyChange(change)));
-  }
-  unsubscribe(listener) {
-    this.listeners.delete(listener);
-  }
-  notifyListeners(events) {
-    for (const listener of this.listeners.values()) {
-      listener.callback(events);
-    }
-  }
-}
-
-class ForkedStoreState extends StoreState {
-  master;
-  changedItems = new Map;
-  changes = [];
-  constructor(storeName, dataStorage, master) {
-    super(storeName, dataStorage, master.deserialize);
-    this.master = master;
-  }
-  async applyChangeAndReturnEvent(change) {
-    this.changes.push(change);
-    if (change.type === "set") {
-      const item = this.deserialize ? this.deserialize(change.data) : change.data;
-      this.changedItems.set(change.data._id, item);
-      return {
-        from: null,
-        to: item,
-        event: {
-          type: "set",
-          item: change.data,
-          id: change.data._id
-        }
-      };
-    }
-    if (change.type === "delete") {
-      const from = await this.find({ where: { _id: change.id } }).then((results) => results[0] || null);
-      this.changedItems.set(change.id, null);
-      return {
-        from,
-        to: null,
-        event: {
-          type: "delete",
-          item: null,
-          id: change.id
-        }
-      };
-    }
-    if (change.type === "modify") {
-      const existing = await this.find({
-        where: { _id: change.id }
-      }).then((results) => results[0]);
-      const updated = existing ? deepMerge(existing, change.data) : { _id: change.id, ...change.data };
-      const item = this.deserialize ? this.deserialize(updated) : updated;
-      this.changedItems.set(change.id, item);
-      return {
-        from: existing || null,
-        to: item,
-        event: {
-          type: "set",
-          item,
-          id: change.id
-        }
-      };
-    }
-    if (change.type === "mutate") {
-      const existing = await this.find({
-        where: { _id: change.id }
-      }).then((results) => results[0]);
-      const updated = apply(existing || {}, change.patches);
-      const item = this.deserialize ? this.deserialize(updated) : updated;
-      this.changedItems.set(change.id, item);
-      return {
-        from: existing || null,
-        to: item,
-        event: {
-          type: "set",
-          item,
-          id: change.id
-        }
-      };
-    }
-    throw new Error("Unknown change type");
-  }
-  async applyChange(change) {
-    const { event: event3, from, to } = await this.applyChangeAndReturnEvent(change);
-    this.notifyListeners([event3]);
-    return { from, to };
-  }
-  async applyChanges(changes) {
-    const events = [];
-    for (const change of changes) {
-      const { event: event3 } = await this.applyChangeAndReturnEvent(change);
-      if (event3)
-        events.push(event3);
-    }
-    if (events.length > 0) {
-      this.notifyListeners(events);
-    }
-  }
-  async find(options, listener) {
-    if (listener) {
-      this.listeners.set(listener, { callback: listener });
-    }
-    const parentResults = await this.master.find(options);
-    const results = new Map;
-    parentResults.forEach((item) => results.set(item._id, item));
-    for (const [id3, changedItem] of this.changedItems) {
-      if (changedItem === null) {
-        results.delete(id3);
-        continue;
-      }
-      const matches = !options.where || Object.entries(options.where).every(([key, value]) => changedItem[key] === value);
-      if (matches) {
-        results.set(id3, changedItem);
-      } else {
-        results.delete(id3);
-      }
-    }
-    return Array.from(results.values());
-  }
-}
-
-class ForkedDataStorage extends DataStorage {
-  master;
-  stores = new Map;
-  constructor(master) {
-    super();
-    this.master = master;
-  }
-  getReadTransaction() {
-    return this.master.getReadTransaction();
-  }
-  getReadWriteTransaction() {
-    return this.master.getReadWriteTransaction();
-  }
-  getStore(storeName) {
-    if (this.stores.has(storeName))
-      return this.stores.get(storeName);
-    const masterStorage = this.master.getStore(storeName);
-    const storage = new ForkedStoreState(storeName, this, masterStorage);
-    this.stores.set(storeName, storage);
-    return storage;
-  }
-  fork() {
-    return new ForkedDataStorage(this);
-  }
-  async merge() {
-    const changes = Array.from(this.stores.values()).filter((store) => store.changes.length > 0).map((store) => ({
-      store: store.storeName,
-      changes: store.changes
-    }));
-    await this.master.commitChanges(changes);
-  }
-}
-
-class MasterStoreState extends StoreState {
-  constructor(storeName, dataStorage, deserialize) {
-    super(storeName, dataStorage, deserialize);
-  }
-  async applyChangeAndReturnEvent(transaction, change) {
-    if (change.type === "set") {
-      await transaction.set(this.storeName, change.data);
-      const item = this.deserialize ? this.deserialize(change.data) : change.data;
-      return {
-        from: null,
-        to: item,
-        event: {
-          type: "set",
-          item: change.data,
-          id: change.data._id
-        }
-      };
-    }
-    if (change.type === "delete") {
-      await transaction.remove(this.storeName, change.id);
-      return {
-        from: null,
-        to: null,
-        event: {
-          type: "delete",
-          item: null,
-          id: change.id
-        }
-      };
-    }
-    if (change.type === "modify") {
-      const existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
-      const updated = existing ? deepMerge(existing, change.data) : { _id: change.id, ...change.data };
-      await transaction.set(this.storeName, updated);
-      const item = this.deserialize ? this.deserialize(updated) : updated;
-      return {
-        from: null,
-        to: item,
-        event: {
-          type: "set",
-          item,
-          id: change.id
-        }
-      };
-    }
-    if (change.type === "mutate") {
-      const existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
-      const updated = apply(existing || {}, change.patches);
-      await transaction.set(this.storeName, updated);
-      const item = this.deserialize ? this.deserialize(updated) : updated;
-      return {
-        from: null,
-        to: item,
-        event: {
-          type: "set",
-          item,
-          id: change.id
-        }
-      };
-    }
-    throw new Error("Unknown change type");
-  }
-  async applyChange(change) {
-    const transaction = await this.dataStorage.getReadWriteTransaction();
-    const { event: event3, from, to } = await this.applyChangeAndReturnEvent(transaction, change);
-    await transaction.commit();
-    this.notifyListeners([event3]);
-    return { from, to };
-  }
-  async applyChanges(changes) {
-    const transaction = await this.dataStorage.getReadWriteTransaction();
-    const events = [];
-    for (const change of changes) {
-      const { event: event3 } = await this.applyChangeAndReturnEvent(transaction, change);
-      if (event3)
-        events.push(event3);
-    }
-    await transaction.commit();
-    if (events.length > 0) {
-      this.notifyListeners(events);
-    }
-  }
-  async find(options, listener) {
-    if (listener) {
-      this.listeners.set(listener, { callback: listener });
-    }
-    const transaction = await this.dataStorage.getReadTransaction();
-    const results = await transaction.find(this.storeName, options);
-    return results.map((item) => this.deserialize ? this.deserialize(item) : item);
-  }
-}
-
-class MasterDataStorage extends DataStorage {
-  dbAdapter;
-  arcContext;
-  stores = new Map;
-  rtcAdapter;
-  constructor(dbAdapter, rtcAdapterFactory, arcContext) {
-    super();
-    this.dbAdapter = dbAdapter;
-    this.arcContext = arcContext;
-    this.rtcAdapter = rtcAdapterFactory(this);
-  }
-  async getReadTransaction() {
-    return (await this.dbAdapter).readTransaction();
-  }
-  async getReadWriteTransaction() {
-    return (await this.dbAdapter).readWriteTransaction();
-  }
-  getStore(storeName) {
-    if (!this.stores.has(storeName)) {
-      this.stores.set(storeName, new MasterStoreState(storeName, this));
-    }
-    return this.stores.get(storeName);
-  }
-  async applyChanges(changes) {
-    return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
-  }
-  applySerializedChanges(changes) {
-    return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applySerializedChanges(changes2)));
-  }
-  async commitChanges(changes) {
-    await Promise.all([
-      this.applyChanges(changes),
-      this.rtcAdapter.commitChanges(changes)
-    ]);
-  }
-  fork() {
-    return new ForkedDataStorage(this);
-  }
-  async sync(progressCallback) {
-    await this.rtcAdapter.sync(progressCallback);
-  }
-}
-
-class SQLiteReadTransaction {
-  db;
-  tables;
-  constructor(db, tables) {
-    this.db = db;
-    this.tables = tables;
-  }
-  deserializeValue(value, column) {
-    if (value === null || value === undefined)
-      return null;
-    switch (column.type.toLowerCase()) {
-      case "json":
-      case "text": {
-        try {
-          const parsed = JSON.parse(value);
-          if (typeof parsed === "object" || Array.isArray(parsed)) {
-            return parsed;
-          }
-          return value;
-        } catch {
-          return value;
-        }
-      }
-      case "datetime":
-      case "timestamp":
-        return new Date(value);
-      default:
-        return value;
-    }
-  }
-  deserializeRow(row, table) {
-    const result = {};
-    for (const column of table.columns) {
-      const value = row[column.name];
-      result[column.name] = this.deserializeValue(value, column);
-    }
-    return result;
-  }
-  getId(store, id3) {
-    return id3;
-  }
-  buildWhereClause(where) {
-    if (!where) {
-      return { sql: "deleted != 1", params: [] };
-    }
-    const conditions = ["deleted != 1"];
-    const params = [];
-    Object.entries(where).forEach(([key, value]) => {
-      if (typeof value === "object" && value !== null) {
-        Object.entries(value).forEach(([operator, operand]) => {
-          switch (operator) {
-            case "$eq":
-            case "$ne":
-            case "$gt":
-            case "$gte":
-            case "$lt":
-            case "$lte":
-              conditions.push(`${key} ${this.getOperatorSymbol(operator)} ?`);
-              params.push(operand);
-              break;
-            case "$in":
-            case "$nin":
-              if (Array.isArray(operand)) {
-                conditions.push(`${key} ${operator === "$in" ? "IN" : "NOT IN"} (${operand.map(() => "?").join(", ")})`);
-                params.push(...operand);
-              }
-              break;
-            case "$exists":
-              if (typeof operand === "boolean") {
-                conditions.push(operand ? `${key} IS NOT NULL` : `${key} IS NULL`);
-              }
-              break;
-          }
-        });
-      } else {
-        conditions.push(`${key} = ?`);
-        params.push(value);
-      }
-    });
-    return {
-      sql: conditions.join(" AND "),
-      params
-    };
-  }
-  getOperatorSymbol(operator) {
-    const operators = {
-      $eq: "=",
-      $ne: "!=",
-      $gt: ">",
-      $gte: ">=",
-      $lt: "<",
-      $lte: "<="
-    };
-    return operators[operator] || "=";
-  }
-  buildOrderByClause(orderBy) {
-    if (!orderBy)
-      return "";
-    const orderClauses = Object.entries(orderBy).map(([key, direction]) => `${key} ${direction.toUpperCase()}`).join(", ");
-    return orderClauses ? `ORDER BY ${orderClauses}` : "";
-  }
-  async find(store, options) {
-    const { where, limit, offset, orderBy } = options || {};
-    const whereClause = this.buildWhereClause(where);
-    const orderByClause = this.buildOrderByClause(orderBy);
-    const table = this.tables.get(store);
-    if (!table) {
-      throw new Error(`Store ${store} not found`);
-    }
-    const query2 = `
-      SELECT * 
-      FROM ${store} 
-      WHERE ${whereClause.sql}
-      ${orderByClause}
-      ${limit ? `LIMIT ${limit}` : ""}
-      ${offset ? `OFFSET ${offset}` : ""}
-    `;
-    const rows = await this.db.exec(query2, whereClause.params);
-    return rows.map((row) => this.deserializeRow(row, table));
-  }
-}
-
-class SQLiteReadWriteTransaction extends SQLiteReadTransaction {
-  async remove(store, id3) {
-    const table = this.tables.get(store);
-    if (!table) {
-      throw new Error(`Store ${store} not found`);
-    }
-    const query2 = `UPDATE ${store} SET deleted = 1, lastUpdate = ? WHERE ${table.primaryKey} = ?`;
-    await this.db.exec(query2, [new Date().toISOString(), id3]);
-  }
-  async set(store, item) {
-    const table = this.tables.get(store);
-    if (!table) {
-      throw new Error(`Store ${store} not found`);
-    }
-    const now = new Date().toISOString();
-    const columnNames = table.columns.map((col) => col.name);
-    const values = table.columns.map((column) => {
-      let value = item[column.name];
-      if (value === undefined && column.default !== undefined) {
-        value = column.default;
-      }
-      return this.serializeValue(value, column);
-    });
-    const placeholders = columnNames.map(() => "?").join(", ");
-    const sql = `
-        INSERT OR REPLACE INTO ${table.name}
-        (${columnNames.map((c) => `"${c}"`).join(", ")})
-        VALUES (${placeholders})
-      `;
-    await this.db.exec(sql, values);
-  }
-  async commit() {
-    return Promise.resolve();
-  }
-  serializeValue(value, column) {
-    if (value === null || value === undefined)
-      return null;
-    switch (column.type.toLowerCase()) {
-      case "json":
-        return JSON.stringify(value);
-      default:
-        if (value instanceof Date) {
-          return value.toISOString();
-        }
-        if (Array.isArray(value) || typeof value === "object") {
-          return JSON.stringify(value);
-        }
-        return value;
-    }
-  }
-}
-
-class SQLiteAdapter {
-  db;
-  context;
-  tables = new Map;
-  constructor(db, context3) {
-    this.db = db;
-    this.context = context3;
-    this.context.elements.forEach((element3) => {
-      if ("storeSchema" in element3 && typeof element3.storeSchema === "function") {
-        element3.storeSchema().tables.forEach((table) => {
-          this.tables.set(table.name, table);
-        });
-      }
-    });
-  }
-  async initialize() {
-    const stores = new Set;
-    for (const element3 of this.context.elements) {
-      if ("storeSchema" in element3 && typeof element3.storeSchema === "function") {
-        const schema = element3.storeSchema();
-        stores.add(schema);
-      }
-    }
-    for (const schema of stores) {
-      for (const table of schema.tables) {
-        await this.createTableIfNotExists(table);
-      }
-    }
-  }
-  async createTableIfNotExists(table) {
-    const columns = table.columns.map((column) => {
-      const constraints = [];
-      if (!column.isOptional) {
-        constraints.push("NOT NULL");
-      }
-      if (column.default !== undefined) {
-        constraints.push(`DEFAULT ${JSON.stringify(column.default)}`);
-      }
-      if (column.name === table.primaryKey) {
-        constraints.push("PRIMARY KEY");
-      }
-      return `"${column.name}" ${column.type} ${constraints.join(" ")}`.trim();
-    });
-    const createTableSQL = `
-      CREATE TABLE IF NOT EXISTS ${table.name} (
-        ${columns.join(`,
-        `)}
-      )
-    `;
-    await this.db.exec(createTableSQL);
-  }
-  readWriteTransaction(stores) {
-    return new SQLiteReadWriteTransaction(this.db, this.tables);
-  }
-  readTransaction(stores) {
-    return new SQLiteReadTransaction(this.db, this.tables);
-  }
-}
-var createSQLiteAdapterFactory = (db) => {
-  return async (context3) => {
-    const adapter = new SQLiteAdapter(db, context3);
-    await adapter.initialize();
-    return adapter;
-  };
-};
-class EventPublisher {
-  context;
-  dataStorage;
-  authContext;
-  asyncEvents = [];
-  constructor(context3, dataStorage, authContext) {
-    this.context = context3;
-    this.dataStorage = dataStorage;
-    this.authContext = authContext;
-  }
-  async publishEvent(event3, commandDataStorage) {
-    const recursivePublishEvent = async (childEvent) => {
-      await this.publishEvent(childEvent, commandDataStorage);
-    };
-    const syncListeners = this.context.getSyncListeners(event3.type, this.authContext);
-    for (const listener3 of syncListeners) {
-      try {
-        await listener3(event3, commandDataStorage, recursivePublishEvent);
-      } catch (error) {
-        console.error("Sync listener failed:", error);
-        throw error;
-      }
-    }
-    const asyncListeners = this.context.getAsyncListeners(event3.type, this.authContext);
-    if (asyncListeners.length > 0) {
-      this.asyncEvents.push({
-        event: event3,
-        listeners: asyncListeners,
-        authContext: this.authContext
-      });
-    }
-  }
-  async runAsyncListeners() {
-    const allAsyncTasks = this.asyncEvents.flatMap(({ event: event3, listeners, authContext }) => listeners.map(async (listener3) => {
-      const listenerFork = this.dataStorage.fork();
-      const asyncPublishEvent = async (childEvent) => {
-        const childPublisher = new EventPublisher(this.context, listenerFork, authContext);
-        await childPublisher.publishEvent(childEvent, listenerFork);
-        await childPublisher.runAsyncListeners();
-      };
-      try {
-        await listener3(event3, listenerFork, asyncPublishEvent);
-        await listenerFork.merge();
-      } catch (error) {
-        console.error("Async listener failed:", error);
-      }
-    }));
-    await Promise.all(allAsyncTasks);
-    this.asyncEvents = [];
-  }
-}
-
-class ModelBase {
-  token = null;
-  setAuthToken(token) {
-    this.token = token;
-  }
-}
-
-class Model extends ModelBase {
-  context;
-  dataStorage;
-  catchErrorCallback;
-  queryCache = new QueryCache;
-  constructor(context3, dataStorage, catchErrorCallback) {
-    super();
-    this.context = context3;
-    this.dataStorage = dataStorage;
-    this.catchErrorCallback = catchErrorCallback;
-  }
-  async query(queryBuilderFn, authContext) {
-    const queryContext = new QueryBuilderContext(this.queryCache, this.dataStorage);
-    const queryBuilder = this.context.queryBuilder(queryContext, authContext);
-    const query2 = queryBuilderFn(queryBuilder).toQuery(queryContext);
-    return query2.run(this.dataStorage);
-  }
-  subscribe(queryBuilderFn, callback, authContext) {
-    const queryContext = new QueryBuilderContext(this.queryCache, this.dataStorage);
-    const queryBuilder = this.context.queryBuilder(queryContext, authContext);
-    const query2 = queryBuilderFn(queryBuilder).toQuery(queryContext);
-    query2.subscribe(callback);
-    const runPromise = query2.run(this.dataStorage);
-    runPromise.then((result) => {
-      callback(result);
-    });
-    return {
-      unsubscribe: () => {
-        query2.unsubscribe(callback);
-      },
-      result: runPromise
-    };
-  }
-  commands(authContext) {
-    return new Proxy({}, {
-      get: (_, name) => {
-        const element3 = this.context.elements.find((element4) => element4.name === name);
-        if (!element3) {
-          throw new Error(`Element "${String(name)}" not found`);
-        }
-        if (!element3.commandClient) {
-          throw new Error(`Element "${String(name)}" does not have a command client`);
-        }
-        return async (arg) => {
-          const forkedDataStorage = this.dataStorage.fork();
-          const eventPublisher = new EventPublisher(this.context, this.dataStorage, authContext);
-          const publishEvent = async (event3) => {
-            await eventPublisher.publishEvent(event3, forkedDataStorage);
-          };
-          const commandContext = this.context.commandContext(forkedDataStorage, publishEvent, authContext);
-          try {
-            const result = await element3.commandClient(commandContext, authContext)(arg);
-            await forkedDataStorage.merge();
-            eventPublisher.runAsyncListeners();
-            return result;
-          } catch (error) {
-            this.catchErrorCallback(error);
-            return error;
-          }
-        };
-      }
-    });
-  }
-  routes(authContext) {
-    return new Proxy({}, {
-      get: (_, name) => {
-        const element3 = this.context.elements.find((element4) => element4.name === name);
-        if (!element3) {
-          throw new Error(`Route element "${String(name)}" not found`);
-        }
-        if (typeof element3.getHandler !== "function") {
-          throw new Error(`Element "${String(name)}" does not have route handlers`);
-        }
-        return async (method, req, routeParams, url) => {
-          const handler = element3.getHandler(method);
-          if (!handler) {
-            throw new Error(`Method ${method} not allowed for route ${String(name)}`);
-          }
-          const forkedDataStorage = this.dataStorage.fork();
-          const eventPublisher = new EventPublisher(this.context, this.dataStorage, authContext);
-          const publishEvent = async (event3) => {
-            await eventPublisher.publishEvent(event3, forkedDataStorage);
-          };
-          const commandContext = this.context.commandContext(forkedDataStorage, publishEvent, authContext);
-          try {
-            const result = await handler(commandContext, req, routeParams, url);
-            await forkedDataStorage.merge();
-            eventPublisher.runAsyncListeners();
-            return result;
-          } catch (error) {
-            this.catchErrorCallback(error);
-            throw error;
-          }
-        };
-      }
-    });
-  }
-  get $debug() {
-    return {};
-  }
-}
-class ArcViewQuery extends ArcSerializableQuery {
-  view;
-  bindedChangeHandler = this.changeHandler.bind(this);
-  store;
-  constructor(view, params) {
-    super(params);
-    this.view = view;
-  }
-  async run(dataStorage) {
-    const store = dataStorage.getStore(this.view.name);
-    this.store = store;
-    const result = await this.fetch(store);
-    this.lastResult = result;
-    return result;
-  }
-  changeHandler(changes) {
-    let resultChanged = false;
-    for (const change of changes) {
-      const response = this.onChange(change);
-      if (response !== false) {
-        this.lastResult = response;
-        resultChanged = true;
-      }
-    }
-    if (resultChanged)
-      this.nextResult(this.lastResult);
-  }
-}
+// host.ts
+import {
+  MasterDataStorage,
+  Model,
+  QueryBuilderContext,
+  QueryCache
+} from "@arcote.tech/arc";
 
 // auth/jwt.ts
 var import_jsonwebtoken = __toESM(require_jsonwebtoken(), 1);
@@ -6860,35 +3719,35 @@ class RTCHost {
   }
   setNestedProperty(obj, path, value) {
     const keys = path.split(/[\[\]]+/).filter((key) => key !== "");
-    let current2 = obj;
+    let current = obj;
     for (let i = 0;i < keys.length - 1; i++) {
       const key = keys[i];
       const nextKey = keys[i + 1];
       if (!isNaN(Number(nextKey))) {
-        if (!current2[key]) {
-          current2[key] = [];
+        if (!current[key]) {
+          current[key] = [];
         }
-        if (!current2[key][Number(nextKey)]) {
-          current2[key][Number(nextKey)] = {};
+        if (!current[key][Number(nextKey)]) {
+          current[key][Number(nextKey)] = {};
         }
-        current2 = current2[key][Number(nextKey)];
+        current = current[key][Number(nextKey)];
         i++;
       } else {
-        if (!current2[key]) {
-          current2[key] = {};
+        if (!current[key]) {
+          current[key] = {};
         }
-        current2 = current2[key];
+        current = current[key];
       }
     }
     const finalKey = keys[keys.length - 1];
     if (!isNaN(Number(finalKey))) {
       const parentKey = keys[keys.length - 2];
-      if (!current2[parentKey]) {
-        current2[parentKey] = [];
+      if (!current[parentKey]) {
+        current[parentKey] = [];
       }
-      current2[parentKey][Number(finalKey)] = value;
+      current[parentKey][Number(finalKey)] = value;
     } else {
-      current2[finalKey] = value;
+      current[finalKey] = value;
     }
   }
   async handleCommand(req) {
@@ -7063,7 +3922,8 @@ class RTCHost {
         perMessageDeflate: true,
         backpressureLimit: 16 * 1024 * 1024
       },
-      port: 5005
+      port: 5005,
+      idleTimeout: 30
     });
   }
   isPublicEndpoint(pathname) {
@@ -7091,7 +3951,6 @@ class RTCHost {
       }
     } : {};
     const syncResults = [];
-    for (const collection of this.context.elements.filter((element) => element instanceof ArcCollection).concat([{ name: "state" }])) {}
     return new Response(JSON.stringify({
       results: syncResults,
       syncDate: syncDate.toISOString()
@@ -7124,6 +3983,9 @@ var rtcHostFactory = (context, dbAdapter) => () => {
 };
 
 // sqliteAdapter.ts
+import {
+  createSQLiteAdapterFactory
+} from "@arcote.tech/arc";
 import { Database } from "bun:sqlite";
 
 class BunSQLiteDatabase {
@@ -7152,11 +4014,57 @@ var sqliteAdapterFactory = (dbName) => {
   };
 };
 
+// postgresAdapter.ts
+import {
+  createPostgreSQLAdapterFactory
+} from "@arcote.tech/arc";
+var {SQL } = globalThis.Bun;
+
+class BunPostgreSQLDatabase {
+  connectionString;
+  sql;
+  constructor(connectionString) {
+    this.connectionString = connectionString;
+    this.sql = new SQL(this.connectionString);
+  }
+  async exec(query, params) {
+    try {
+      const result = await this.sql.unsafe(query, params);
+      return result;
+    } catch (error) {
+      console.error("PostgreSQL error:", error, query, params);
+      throw error;
+    }
+  }
+  async execBatch(queries) {
+    try {
+      return await this.sql.transaction(async (tx) => {
+        for (const query of queries) {
+          await tx.unsafe(query.sql, query.params);
+        }
+      });
+    } catch (error) {
+      console.error("PostgreSQL batch transaction error:", error);
+      throw error;
+    }
+  }
+}
+var postgreSQLAdapterFactory = (connectionString) => {
+  return async (context) => {
+    const pgDb = new BunPostgreSQLDatabase(connectionString);
+    return createPostgreSQLAdapterFactory(pgDb)(context);
+  };
+};
+
 // index.ts
 function hostLiveModel(context, options) {
   const dbAdapterFactory = sqliteAdapterFactory(options.db);
   rtcHostFactory(context, dbAdapterFactory(context))();
 }
 export {
+  postgreSQLAdapterFactory,
   hostLiveModel
 };
+
+//# debugId=3170B378AC8CEA7664756E2164756E21
+//# sourceMappingURL=index.js.map