@arcote.tech/arc-react 0.0.5 → 0.0.7

package/dist/index.js

@@ -1,1651 +1,7 @@
-// ../../node_modules/mutative/dist/mutative.esm.mjs
-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;
-}
-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);
-  }
-}
-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;
-}
-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);
-}
-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 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 = {};
-var propIsEnum = Object.prototype.propertyIsEnumerable;
-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 current2 = latest(getProxyDraft(this));
-    return current2.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 current2 = peek(latest(target), key);
-    const currentProxyDraft = getProxyDraft(current2);
-    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, current2) && (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;
-  }
-};
-internal.createDraft = createDraft;
-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();
-var constructorString = Object.prototype.constructor.toString();
-
-// /Users/pkrasinski/Projects/arcote.tech/arc/node_modules/@arcote.tech/arc/dist/index.js
-import {BehaviorSubject, debounceTime, Subject} from "rxjs";
-import {Subject as Subject2} from "rxjs";
-function model(context3, dependencies) {
-  return new ArcModel(context3, dependencies.dbAdapterFactory, dependencies.rtcAdapterFactory);
-}
-class ArcCollectionQuery {
-  collection;
-  result$ = new Subject;
-  resultQueue$;
-  subscriptions = [];
-  constructor(collection) {
-    this.collection = collection;
-  }
-  getLastResult() {
-    return this.resultQueue$.getValue();
-  }
-  async run(db, changes$) {
-    const subscription = changes$.subscribe(this.changeHandler.bind(this));
-    this.subscriptions.push(subscription);
-    const transaction = await db.readTransaction([this.collection]);
-    const result = await this.fetch(transaction);
-    this.resultQueue$ = new BehaviorSubject(result);
-    const subscriptionDebounce = this.resultQueue$.pipe(debounceTime(50)).subscribe(this.result$);
-    this.subscriptions.push(subscriptionDebounce);
-  }
-  changeHandler(change) {
-    if (change.collection !== this.collection.name)
-      return;
-    if (!this.resultQueue$)
-      return;
-    const response = this.onChange(change);
-    if (response !== false)
-      this.nextResult(response);
-  }
-  unsubscribe() {
-    this.subscriptions.forEach((sub) => sub.unsubscribe());
-  }
-  nextResult(result) {
-    if (!this.resultQueue$)
-      return console.warn("Weird, it shouldn't happen :/");
-    this.resultQueue$.next(result);
-  }
-  isUnsubscribed() {
-    return this.subscriptions.every((sub) => sub.closed);
-  }
-}
-
-class QueryCollectionResult {
-  result;
-  constructor(result) {
-    this.result = result;
-  }
-  get(id) {
-    return this.result.find((r) => r._id === id);
-  }
-  map(callbackfn) {
-    return this.result.map(callbackfn);
-  }
-  toArray() {
-    return this.result;
-  }
-}
-
-class ArcManyItemsQuery extends ArcCollectionQuery {
-  filterFn;
-  sortFn;
-  constructor(collection, filterFn, sortFn) {
-    super(collection);
-    this.filterFn = filterFn;
-    this.sortFn = sortFn;
-  }
-  onChange(change) {
-    const lastResult = this.getLastResult();
-    const lastResultAsArray = lastResult.toArray();
-    const index = lastResultAsArray.findIndex((e) => e._id === (change.type === "delete" ? change.id : change.body._id));
-    const isInLastResult = index !== -1;
-    const shouldBeInTheResult = change.type !== "delete" && this.checkItem(change.body);
-    if (isInLastResult && shouldBeInTheResult)
-      return this.createResult(lastResultAsArray.toSpliced(index, 1, change.body));
-    else if (isInLastResult && (change.type === "delete" || !shouldBeInTheResult))
-      return this.createResult(lastResultAsArray.toSpliced(index, 1));
-    else if (!isInLastResult && shouldBeInTheResult)
-      return this.createResult(lastResultAsArray.concat(change.body));
-    return false;
-  }
-  createResult(result) {
-    if (this.sortFn)
-      return new QueryCollectionResult(result.sort(this.sortFn));
-    return new QueryCollectionResult(result);
-  }
-  createFiltredResult(result) {
-    if (this.filterFn)
-      return this.createResult(result.filter(this.filterFn));
-    return this.createResult(result);
-  }
-  checkItem(item) {
-    if (this.filterFn)
-      return this.filterFn(item);
-    return true;
-  }
-}
-
-class ArcAllItemsQuery extends ArcManyItemsQuery {
-  async fetch(transaction) {
-    return this.createFiltredResult(await transaction.findAll(this.collection));
-  }
-}
-
-class ArcQueryBuilder {
-}
-
-class ArcManyItemsQueryBuilder extends ArcQueryBuilder {
-  filterFn;
-  sortFn;
-  filter(callback) {
-    this.filterFn = callback;
-    return this;
-  }
-  sort(callback) {
-    this.sortFn = callback;
-    return this;
-  }
-}
-
-class ArcAllItemsQueryBuilder extends ArcManyItemsQueryBuilder {
-  collection;
-  constructor(collection) {
-    super();
-    this.collection = collection;
-  }
-  toQuery() {
-    return new ArcAllItemsQuery(this.collection, this.filterFn, this.sortFn);
-  }
-}
-
-class ArcIndexedItemsQuery extends ArcManyItemsQuery {
-  index;
-  data;
-  filterFn;
-  sortFn;
-  constructor(collection, index, data, filterFn, sortFn) {
-    super(collection, filterFn, sortFn);
-    this.index = index;
-    this.data = data;
-    this.filterFn = filterFn;
-    this.sortFn = sortFn;
-  }
-  checkItem(item) {
-    if (!super.checkItem(item))
-      return false;
-    const notCorrect = Object.entries(this.data).find(([key, value]) => item[key] !== value);
-    if (notCorrect)
-      return false;
-    return true;
-  }
-  async fetch(transaction) {
-    return this.createFiltredResult(await transaction.findByIndex(this.collection, this.index, this.data));
-  }
-}
-
-class ArcIndexedItemsQueryBuilder extends ArcManyItemsQueryBuilder {
-  collection;
-  index;
-  data;
-  constructor(collection, index, data) {
-    super();
-    this.collection = collection;
-    this.index = index;
-    this.data = data;
-  }
-  toQuery() {
-    return new ArcIndexedItemsQuery(this.collection, this.index, this.data, this.filterFn, this.sortFn);
-  }
-}
-
-class ArcOneItemQuery extends ArcCollectionQuery {
-  id;
-  constructor(collection, id) {
-    super(collection);
-    this.id = id;
-  }
-  onChange(change) {
-    if (change.type === "delete" && change.id === this.id)
-      return;
-    if (change.type === "set" && change.body._id === this.id)
-      return change.body;
-    return false;
-  }
-  fetch(transaction) {
-    if (!this.id)
-      return;
-    return transaction.findById(this.collection, this.id);
-  }
-}
-
-class ArcOneItemQueryBuilder extends ArcQueryBuilder {
-  collection;
-  id;
-  constructor(collection, id) {
-    super();
-    this.collection = collection;
-    this.id = id;
-  }
-  toQuery() {
-    return new ArcOneItemQuery(this.collection, this.id);
-  }
-}
-
-class ArcCollection {
-  name;
-  id;
-  schema;
-  constructor(name, id, schema) {
-    this.name = name;
-    this.id = id;
-    this.schema = schema;
-  }
-  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() {
-    return {
-      all: () => new ArcAllItemsQueryBuilder(this),
-      one: (id) => new ArcOneItemQueryBuilder(this, id)
-    };
-  }
-  commandContext(transaction, changes, getDraft) {
-    return {
-      add: (data) => {
-        const id = this.id.generate();
-        const parsed = this.schema.parse(data);
-        const body = {
-          _id: id,
-          ...parsed
-        };
-        changes.push({ type: "set", collection: this.name, body });
-        return { id };
-      },
-      remove: (id) => {
-        changes.push({ type: "delete", collection: this.name, id });
-        return { success: true };
-      },
-      set: (id, data) => {
-        const parsed = this.schema.parse(data);
-        const body = {
-          _id: id,
-          ...parsed
-        };
-        changes.push({ type: "set", collection: this.name, body });
-        return { success: true };
-      },
-      one: async (id) => {
-        const object = await transaction.findById(this, id);
-        return getDraft(this.name, object);
-      }
-    };
-  }
-  async applyChange(transaction, change, events) {
-    switch (change.type) {
-      case "set":
-        await transaction.set(this, change.body);
-        events.push(change);
-        break;
-      case "delete":
-        await transaction.remove(this, change.id);
-        events.push(change);
-        break;
-      case "mutate":
-        const existingObject = await transaction.findById(this, change.id);
-        if (existingObject) {
-          const updatedObject = apply(existingObject, change.patches);
-          await transaction.set(this, updatedObject);
-          events.push({
-            type: "set",
-            collection: change.collection,
-            body: updatedObject
-          });
-        }
-        break;
-    }
-  }
-  indexBy(indexes) {
-    return new ArcIndexedCollection(this.name, this.id, this.schema, indexes);
-  }
-}
-
-class ArcIndexedCollection extends ArcCollection {
-  indexes;
-  constructor(name, id, schema, indexes) {
-    super(name, id, schema);
-    this.indexes = indexes;
-  }
-  queryBuilder() {
-    const superQueryBuilder = super.queryBuilder();
-    return new Proxy({}, {
-      get: (target, name) => {
-        if (name in superQueryBuilder)
-          return superQueryBuilder[name];
-        if (!(name in this.indexes)) {
-          throw new Error(`Index "${name}" not found in collection "${this.name}"`);
-        }
-        return (data) => new ArcIndexedItemsQueryBuilder(this, name, data);
-      }
-    });
-  }
-}
-class ArcModel {
-  context3;
-  rtc;
-  dbAdapterPromise;
-  changes$ = new Subject2;
-  constructor(context3, dbAdapterFactory, rtcAdapterFactory) {
-    this.context = context3;
-    this.rtc = rtcAdapterFactory(this);
-    this.dbAdapterPromise = dbAdapterFactory(this.context);
-  }
-  query(queryFactory) {
-    const queryBuilder = this.context.queryBuilder();
-    const query = queryFactory(queryBuilder).toQuery();
-    this.runQuery(query);
-    return query;
-  }
-  async runQuery(query) {
-    if (query instanceof ArcCollectionQuery) {
-      const dbAdapter = await this.dbAdapterPromise;
-      query.run(dbAdapter, this.changes$);
-    }
-  }
-  commands() {
-    return new Proxy({}, {
-      get: (target, name) => {
-        if (name in this.context.commands) {
-          return async (...args) => {
-            const { result } = await this.executeCommand(this.context.commands[name], ...args);
-            return result;
-          };
-        }
-        console.warn(`Command '${name}' not found in the context.`);
-        return;
-      }
-    });
-  }
-  async executeCommand(command, ...args) {
-    const dbAdapter = await this.dbAdapterPromise;
-    const transaction = await dbAdapter.readWriteTransaction(this.context.collections);
-    const { context: context3, finalize } = await this.context.commandContext(transaction);
-    const result = await command(context3, ...args);
-    const changes = await finalize();
-    await this.applyChangesForTransaction(transaction, changes);
-    this.rtc.commandExecuted(command.name, changes);
-    return { changes, result };
-  }
-  async applyChangesForTransaction(transaction, changes) {
-    const events = [];
-    for (const change of changes) {
-      await this.context.applyChange(transaction, change, events);
-    }
-    await transaction.commit();
-    events.forEach((change) => this.notifyChange(change));
-  }
-  notifyChange(change) {
-    this.changes$.next(change);
-  }
-  async applyChanges(changes) {
-    const dbAdapter = await this.dbAdapterPromise;
-    const transaction = await dbAdapter.readWriteTransaction(this.context.collections);
-    await this.applyChangesForTransaction(transaction, changes);
-  }
-  getCollection(name) {
-    return this.context.collectionsMap[name];
-  }
-}
-
 // idb.ts
+import {
+ArcIndexedCollection
+} from "@arcote.tech/arc";
 var idbAdapterFactory = (name, version) => (context) => new Promise((resolve, reject) => {
   const dbRequest = indexedDB.open(name, version);
   dbRequest.addEventListener("error", (err) => {
@@ -1761,6 +117,10 @@ class IDBAdapter {
   }
 }
 // reactModel.tsx
+import {
+ArcCollectionQuery,
+model
+} from "@arcote.tech/arc";
 import {createContext, useContext, useEffect, useRef, useState} from "react";
 import {
 jsxDEV