document-model 2.20.0 → 2.21.1

package/dist/node/es/internal/creators-0lHfLHX0.js

@@ -1,2685 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import JSZip from "jszip";
-import { z, ZodError } from "zod";
-import { create, castDraft, unsafe } from "mutative";
-import crypto from "node:crypto";
-import fs from "node:fs";
-import https from "node:https";
-import { join } from "node:path";
-const isDefinedNonNullAny = (v) => v !== void 0 && v !== null;
-const definedNonNullAnySchema = z.any().refine((v) => isDefinedNonNullAny(v));
-const Load_StateSchema = z.enum(["LOAD_STATE"]);
-const PruneSchema = z.enum(["PRUNE"]);
-const RedoSchema = z.enum(["REDO"]);
-const Set_NameSchema = z.enum(["SET_NAME"]);
-const UndoSchema = z.enum(["UNDO"]);
-function ActionSchema() {
-  return z.object({
-    __typename: z.literal("Action").optional(),
-    type: z.string()
-  });
-}
-function OperationScopeSchema() {
-  return z.literal("global").or(z.literal("local"));
-}
-function BaseActionSchema() {
-  return z.union([
-    LoadStateActionSchema(),
-    PruneActionSchema(),
-    RedoActionSchema(),
-    SetNameActionSchema(),
-    UndoActionSchema()
-  ]);
-}
-function DocumentFileSchema() {
-  return z.object({
-    __typename: z.literal("DocumentFile").optional(),
-    data: z.string(),
-    extension: z.string().nullable(),
-    fileName: z.string().nullable(),
-    mimeType: z.string()
-  });
-}
-function LoadStateActionSchema() {
-  return z.object({
-    input: z.lazy(() => LoadStateActionInputSchema()),
-    type: Load_StateSchema,
-    scope: OperationScopeSchema()
-  });
-}
-function LoadStateActionInputSchema() {
-  return z.object({
-    operations: z.number(),
-    state: z.lazy(() => LoadStateActionStateInputSchema())
-  });
-}
-function LoadStateActionStateInputSchema() {
-  return z.object({
-    data: z.unknown().nullish(),
-    name: z.string()
-  });
-}
-function OperationSchema() {
-  return z.object({
-    __typename: z.literal("Operation").optional(),
-    hash: z.string(),
-    index: z.number(),
-    timestamp: z.string().datetime(),
-    type: z.string()
-  });
-}
-function PruneActionSchema() {
-  return z.object({
-    input: z.lazy(() => PruneActionInputSchema()),
-    type: PruneSchema,
-    scope: OperationScopeSchema()
-  });
-}
-function PruneActionInputSchema() {
-  return z.object({
-    end: z.number().nullish(),
-    start: z.number().nullish()
-  });
-}
-const RedoActionInputSchema = z.number;
-function RedoActionSchema() {
-  return z.object({
-    input: RedoActionInputSchema(),
-    type: RedoSchema,
-    scope: OperationScopeSchema()
-  });
-}
-const SetNameActionInputSchema = z.string;
-function SetNameActionSchema() {
-  return z.object({
-    input: SetNameActionInputSchema(),
-    type: Set_NameSchema,
-    scope: z.literal("global")
-  });
-}
-function SetNameOperationSchema() {
-  return z.object({
-    __typename: z.literal("SetNameOperation").optional(),
-    hash: z.string(),
-    index: z.number(),
-    input: z.string(),
-    timestamp: z.string().datetime(),
-    type: z.string()
-  });
-}
-const UndoActionInputSchema = z.number;
-function UndoActionSchema() {
-  return z.object({
-    input: UndoActionInputSchema(),
-    type: UndoSchema,
-    scope: OperationScopeSchema()
-  });
-}
-const zod = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  ActionSchema,
-  BaseActionSchema,
-  DocumentFileSchema,
-  LoadStateActionInputSchema,
-  LoadStateActionSchema,
-  LoadStateActionStateInputSchema,
-  Load_StateSchema,
-  OperationSchema,
-  OperationScopeSchema,
-  PruneActionInputSchema,
-  PruneActionSchema,
-  PruneSchema,
-  RedoActionInputSchema,
-  RedoActionSchema,
-  RedoSchema,
-  SetNameActionInputSchema,
-  SetNameActionSchema,
-  SetNameOperationSchema,
-  Set_NameSchema,
-  UndoActionInputSchema,
-  UndoActionSchema,
-  UndoSchema,
-  definedNonNullAnySchema,
-  isDefinedNonNullAny
-}, Symbol.toStringTag, { value: "Module" }));
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-var safeStableStringify = { exports: {} };
-var hasRequiredSafeStableStringify;
-function requireSafeStableStringify() {
-  if (hasRequiredSafeStableStringify) return safeStableStringify.exports;
-  hasRequiredSafeStableStringify = 1;
-  (function(module, exports) {
-    const { hasOwnProperty } = Object.prototype;
-    const stringify = configure();
-    stringify.configure = configure;
-    stringify.stringify = stringify;
-    stringify.default = stringify;
-    exports.stringify = stringify;
-    exports.configure = configure;
-    module.exports = stringify;
-    const strEscapeSequencesRegExp = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
-    function strEscape(str) {
-      if (str.length < 5e3 && !strEscapeSequencesRegExp.test(str)) {
-        return `"${str}"`;
-      }
-      return JSON.stringify(str);
-    }
-    function sort(array, comparator) {
-      if (array.length > 200 || comparator) {
-        return array.sort(comparator);
-      }
-      for (let i = 1; i < array.length; i++) {
-        const currentValue = array[i];
-        let position = i;
-        while (position !== 0 && array[position - 1] > currentValue) {
-          array[position] = array[position - 1];
-          position--;
-        }
-        array[position] = currentValue;
-      }
-      return array;
-    }
-    const typedArrayPrototypeGetSymbolToStringTag = Object.getOwnPropertyDescriptor(
-      Object.getPrototypeOf(
-        Object.getPrototypeOf(
-          new Int8Array()
-        )
-      ),
-      Symbol.toStringTag
-    ).get;
-    function isTypedArrayWithEntries(value) {
-      return typedArrayPrototypeGetSymbolToStringTag.call(value) !== void 0 && value.length !== 0;
-    }
-    function stringifyTypedArray(array, separator, maximumBreadth) {
-      if (array.length < maximumBreadth) {
-        maximumBreadth = array.length;
-      }
-      const whitespace = separator === "," ? "" : " ";
-      let res = `"0":${whitespace}${array[0]}`;
-      for (let i = 1; i < maximumBreadth; i++) {
-        res += `${separator}"${i}":${whitespace}${array[i]}`;
-      }
-      return res;
-    }
-    function getCircularValueOption(options) {
-      if (hasOwnProperty.call(options, "circularValue")) {
-        const circularValue = options.circularValue;
-        if (typeof circularValue === "string") {
-          return `"${circularValue}"`;
-        }
-        if (circularValue == null) {
-          return circularValue;
-        }
-        if (circularValue === Error || circularValue === TypeError) {
-          return {
-            toString() {
-              throw new TypeError("Converting circular structure to JSON");
-            }
-          };
-        }
-        throw new TypeError('The "circularValue" argument must be of type string or the value null or undefined');
-      }
-      return '"[Circular]"';
-    }
-    function getDeterministicOption(options) {
-      let value;
-      if (hasOwnProperty.call(options, "deterministic")) {
-        value = options.deterministic;
-        if (typeof value !== "boolean" && typeof value !== "function") {
-          throw new TypeError('The "deterministic" argument must be of type boolean or comparator function');
-        }
-      }
-      return value === void 0 ? true : value;
-    }
-    function getBooleanOption(options, key) {
-      let value;
-      if (hasOwnProperty.call(options, key)) {
-        value = options[key];
-        if (typeof value !== "boolean") {
-          throw new TypeError(`The "${key}" argument must be of type boolean`);
-        }
-      }
-      return value === void 0 ? true : value;
-    }
-    function getPositiveIntegerOption(options, key) {
-      let value;
-      if (hasOwnProperty.call(options, key)) {
-        value = options[key];
-        if (typeof value !== "number") {
-          throw new TypeError(`The "${key}" argument must be of type number`);
-        }
-        if (!Number.isInteger(value)) {
-          throw new TypeError(`The "${key}" argument must be an integer`);
-        }
-        if (value < 1) {
-          throw new RangeError(`The "${key}" argument must be >= 1`);
-        }
-      }
-      return value === void 0 ? Infinity : value;
-    }
-    function getItemCount(number) {
-      if (number === 1) {
-        return "1 item";
-      }
-      return `${number} items`;
-    }
-    function getUniqueReplacerSet(replacerArray) {
-      const replacerSet = /* @__PURE__ */ new Set();
-      for (const value of replacerArray) {
-        if (typeof value === "string" || typeof value === "number") {
-          replacerSet.add(String(value));
-        }
-      }
-      return replacerSet;
-    }
-    function getStrictOption(options) {
-      if (hasOwnProperty.call(options, "strict")) {
-        const value = options.strict;
-        if (typeof value !== "boolean") {
-          throw new TypeError('The "strict" argument must be of type boolean');
-        }
-        if (value) {
-          return (value2) => {
-            let message = `Object can not safely be stringified. Received type ${typeof value2}`;
-            if (typeof value2 !== "function") message += ` (${value2.toString()})`;
-            throw new Error(message);
-          };
-        }
-      }
-    }
-    function configure(options) {
-      options = { ...options };
-      const fail = getStrictOption(options);
-      if (fail) {
-        if (options.bigint === void 0) {
-          options.bigint = false;
-        }
-        if (!("circularValue" in options)) {
-          options.circularValue = Error;
-        }
-      }
-      const circularValue = getCircularValueOption(options);
-      const bigint = getBooleanOption(options, "bigint");
-      const deterministic = getDeterministicOption(options);
-      const comparator = typeof deterministic === "function" ? deterministic : void 0;
-      const maximumDepth = getPositiveIntegerOption(options, "maximumDepth");
-      const maximumBreadth = getPositiveIntegerOption(options, "maximumBreadth");
-      function stringifyFnReplacer(key, parent, stack, replacer, spacer, indentation) {
-        let value = parent[key];
-        if (typeof value === "object" && value !== null && typeof value.toJSON === "function") {
-          value = value.toJSON(key);
-        }
-        value = replacer.call(parent, key, value);
-        switch (typeof value) {
-          case "string":
-            return strEscape(value);
-          case "object": {
-            if (value === null) {
-              return "null";
-            }
-            if (stack.indexOf(value) !== -1) {
-              return circularValue;
-            }
-            let res = "";
-            let join2 = ",";
-            const originalIndentation = indentation;
-            if (Array.isArray(value)) {
-              if (value.length === 0) {
-                return "[]";
-              }
-              if (maximumDepth < stack.length + 1) {
-                return '"[Array]"';
-              }
-              stack.push(value);
-              if (spacer !== "") {
-                indentation += spacer;
-                res += `
-${indentation}`;
-                join2 = `,
-${indentation}`;
-              }
-              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
-              let i = 0;
-              for (; i < maximumValuesToStringify - 1; i++) {
-                const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
-                res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join2;
-              }
-              const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
-              res += tmp !== void 0 ? tmp : "null";
-              if (value.length - 1 > maximumBreadth) {
-                const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
-              }
-              if (spacer !== "") {
-                res += `
-${originalIndentation}`;
-              }
-              stack.pop();
-              return `[${res}]`;
-            }
-            let keys = Object.keys(value);
-            const keyLength = keys.length;
-            if (keyLength === 0) {
-              return "{}";
-            }
-            if (maximumDepth < stack.length + 1) {
-              return '"[Object]"';
-            }
-            let whitespace = "";
-            let separator = "";
-            if (spacer !== "") {
-              indentation += spacer;
-              join2 = `,
-${indentation}`;
-              whitespace = " ";
-            }
-            const maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
-            if (deterministic && !isTypedArrayWithEntries(value)) {
-              keys = sort(keys, comparator);
-            }
-            stack.push(value);
-            for (let i = 0; i < maximumPropertiesToStringify; i++) {
-              const key2 = keys[i];
-              const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
-              if (tmp !== void 0) {
-                res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join2;
-              }
-            }
-            if (keyLength > maximumBreadth) {
-              const removedKeys = keyLength - maximumBreadth;
-              res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-              separator = join2;
-            }
-            if (spacer !== "" && separator.length > 1) {
-              res = `
-${indentation}${res}
-${originalIndentation}`;
-            }
-            stack.pop();
-            return `{${res}}`;
-          }
-          case "number":
-            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
-          case "boolean":
-            return value === true ? "true" : "false";
-          case "undefined":
-            return void 0;
-          case "bigint":
-            if (bigint) {
-              return String(value);
-            }
-          // fallthrough
-          default:
-            return fail ? fail(value) : void 0;
-        }
-      }
-      function stringifyArrayReplacer(key, value, stack, replacer, spacer, indentation) {
-        if (typeof value === "object" && value !== null && typeof value.toJSON === "function") {
-          value = value.toJSON(key);
-        }
-        switch (typeof value) {
-          case "string":
-            return strEscape(value);
-          case "object": {
-            if (value === null) {
-              return "null";
-            }
-            if (stack.indexOf(value) !== -1) {
-              return circularValue;
-            }
-            const originalIndentation = indentation;
-            let res = "";
-            let join2 = ",";
-            if (Array.isArray(value)) {
-              if (value.length === 0) {
-                return "[]";
-              }
-              if (maximumDepth < stack.length + 1) {
-                return '"[Array]"';
-              }
-              stack.push(value);
-              if (spacer !== "") {
-                indentation += spacer;
-                res += `
-${indentation}`;
-                join2 = `,
-${indentation}`;
-              }
-              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
-              let i = 0;
-              for (; i < maximumValuesToStringify - 1; i++) {
-                const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
-                res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join2;
-              }
-              const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
-              res += tmp !== void 0 ? tmp : "null";
-              if (value.length - 1 > maximumBreadth) {
-                const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
-              }
-              if (spacer !== "") {
-                res += `
-${originalIndentation}`;
-              }
-              stack.pop();
-              return `[${res}]`;
-            }
-            stack.push(value);
-            let whitespace = "";
-            if (spacer !== "") {
-              indentation += spacer;
-              join2 = `,
-${indentation}`;
-              whitespace = " ";
-            }
-            let separator = "";
-            for (const key2 of replacer) {
-              const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
-              if (tmp !== void 0) {
-                res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join2;
-              }
-            }
-            if (spacer !== "" && separator.length > 1) {
-              res = `
-${indentation}${res}
-${originalIndentation}`;
-            }
-            stack.pop();
-            return `{${res}}`;
-          }
-          case "number":
-            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
-          case "boolean":
-            return value === true ? "true" : "false";
-          case "undefined":
-            return void 0;
-          case "bigint":
-            if (bigint) {
-              return String(value);
-            }
-          // fallthrough
-          default:
-            return fail ? fail(value) : void 0;
-        }
-      }
-      function stringifyIndent(key, value, stack, spacer, indentation) {
-        switch (typeof value) {
-          case "string":
-            return strEscape(value);
-          case "object": {
-            if (value === null) {
-              return "null";
-            }
-            if (typeof value.toJSON === "function") {
-              value = value.toJSON(key);
-              if (typeof value !== "object") {
-                return stringifyIndent(key, value, stack, spacer, indentation);
-              }
-              if (value === null) {
-                return "null";
-              }
-            }
-            if (stack.indexOf(value) !== -1) {
-              return circularValue;
-            }
-            const originalIndentation = indentation;
-            if (Array.isArray(value)) {
-              if (value.length === 0) {
-                return "[]";
-              }
-              if (maximumDepth < stack.length + 1) {
-                return '"[Array]"';
-              }
-              stack.push(value);
-              indentation += spacer;
-              let res2 = `
-${indentation}`;
-              const join3 = `,
-${indentation}`;
-              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
-              let i = 0;
-              for (; i < maximumValuesToStringify - 1; i++) {
-                const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
-                res2 += tmp2 !== void 0 ? tmp2 : "null";
-                res2 += join3;
-              }
-              const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
-              res2 += tmp !== void 0 ? tmp : "null";
-              if (value.length - 1 > maximumBreadth) {
-                const removedKeys = value.length - maximumBreadth - 1;
-                res2 += `${join3}"... ${getItemCount(removedKeys)} not stringified"`;
-              }
-              res2 += `
-${originalIndentation}`;
-              stack.pop();
-              return `[${res2}]`;
-            }
-            let keys = Object.keys(value);
-            const keyLength = keys.length;
-            if (keyLength === 0) {
-              return "{}";
-            }
-            if (maximumDepth < stack.length + 1) {
-              return '"[Object]"';
-            }
-            indentation += spacer;
-            const join2 = `,
-${indentation}`;
-            let res = "";
-            let separator = "";
-            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
-            if (isTypedArrayWithEntries(value)) {
-              res += stringifyTypedArray(value, join2, maximumBreadth);
-              keys = keys.slice(value.length);
-              maximumPropertiesToStringify -= value.length;
-              separator = join2;
-            }
-            if (deterministic) {
-              keys = sort(keys, comparator);
-            }
-            stack.push(value);
-            for (let i = 0; i < maximumPropertiesToStringify; i++) {
-              const key2 = keys[i];
-              const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
-              if (tmp !== void 0) {
-                res += `${separator}${strEscape(key2)}: ${tmp}`;
-                separator = join2;
-              }
-            }
-            if (keyLength > maximumBreadth) {
-              const removedKeys = keyLength - maximumBreadth;
-              res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-              separator = join2;
-            }
-            if (separator !== "") {
-              res = `
-${indentation}${res}
-${originalIndentation}`;
-            }
-            stack.pop();
-            return `{${res}}`;
-          }
-          case "number":
-            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
-          case "boolean":
-            return value === true ? "true" : "false";
-          case "undefined":
-            return void 0;
-          case "bigint":
-            if (bigint) {
-              return String(value);
-            }
-          // fallthrough
-          default:
-            return fail ? fail(value) : void 0;
-        }
-      }
-      function stringifySimple(key, value, stack) {
-        switch (typeof value) {
-          case "string":
-            return strEscape(value);
-          case "object": {
-            if (value === null) {
-              return "null";
-            }
-            if (typeof value.toJSON === "function") {
-              value = value.toJSON(key);
-              if (typeof value !== "object") {
-                return stringifySimple(key, value, stack);
-              }
-              if (value === null) {
-                return "null";
-              }
-            }
-            if (stack.indexOf(value) !== -1) {
-              return circularValue;
-            }
-            let res = "";
-            const hasLength = value.length !== void 0;
-            if (hasLength && Array.isArray(value)) {
-              if (value.length === 0) {
-                return "[]";
-              }
-              if (maximumDepth < stack.length + 1) {
-                return '"[Array]"';
-              }
-              stack.push(value);
-              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
-              let i = 0;
-              for (; i < maximumValuesToStringify - 1; i++) {
-                const tmp2 = stringifySimple(String(i), value[i], stack);
-                res += tmp2 !== void 0 ? tmp2 : "null";
-                res += ",";
-              }
-              const tmp = stringifySimple(String(i), value[i], stack);
-              res += tmp !== void 0 ? tmp : "null";
-              if (value.length - 1 > maximumBreadth) {
-                const removedKeys = value.length - maximumBreadth - 1;
-                res += `,"... ${getItemCount(removedKeys)} not stringified"`;
-              }
-              stack.pop();
-              return `[${res}]`;
-            }
-            let keys = Object.keys(value);
-            const keyLength = keys.length;
-            if (keyLength === 0) {
-              return "{}";
-            }
-            if (maximumDepth < stack.length + 1) {
-              return '"[Object]"';
-            }
-            let separator = "";
-            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
-            if (hasLength && isTypedArrayWithEntries(value)) {
-              res += stringifyTypedArray(value, ",", maximumBreadth);
-              keys = keys.slice(value.length);
-              maximumPropertiesToStringify -= value.length;
-              separator = ",";
-            }
-            if (deterministic) {
-              keys = sort(keys, comparator);
-            }
-            stack.push(value);
-            for (let i = 0; i < maximumPropertiesToStringify; i++) {
-              const key2 = keys[i];
-              const tmp = stringifySimple(key2, value[key2], stack);
-              if (tmp !== void 0) {
-                res += `${separator}${strEscape(key2)}:${tmp}`;
-                separator = ",";
-              }
-            }
-            if (keyLength > maximumBreadth) {
-              const removedKeys = keyLength - maximumBreadth;
-              res += `${separator}"...":"${getItemCount(removedKeys)} not stringified"`;
-            }
-            stack.pop();
-            return `{${res}}`;
-          }
-          case "number":
-            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
-          case "boolean":
-            return value === true ? "true" : "false";
-          case "undefined":
-            return void 0;
-          case "bigint":
-            if (bigint) {
-              return String(value);
-            }
-          // fallthrough
-          default:
-            return fail ? fail(value) : void 0;
-        }
-      }
-      function stringify2(value, replacer, space) {
-        if (arguments.length > 1) {
-          let spacer = "";
-          if (typeof space === "number") {
-            spacer = " ".repeat(Math.min(space, 10));
-          } else if (typeof space === "string") {
-            spacer = space.slice(0, 10);
-          }
-          if (replacer != null) {
-            if (typeof replacer === "function") {
-              return stringifyFnReplacer("", { "": value }, [], replacer, spacer, "");
-            }
-            if (Array.isArray(replacer)) {
-              return stringifyArrayReplacer("", value, [], getUniqueReplacerSet(replacer), spacer, "");
-            }
-          }
-          if (spacer.length !== 0) {
-            return stringifyIndent("", value, [], spacer, "");
-          }
-        }
-        return stringifySimple("", value, []);
-      }
-      return stringify2;
-    }
-  })(safeStableStringify, safeStableStringify.exports);
-  return safeStableStringify.exports;
-}
-var safeStableStringifyExports = requireSafeStableStringify();
-const cjsModule = /* @__PURE__ */ getDefaultExportFromCjs(safeStableStringifyExports);
-cjsModule.configure;
-function generateUUID(options) {
-  return crypto.randomUUID(options);
-}
-function writeFile(path, name, data) {
-  const filePath = join(path, name);
-  fs.mkdirSync(path, { recursive: true });
-  return new Promise((resolve, reject) => {
-    try {
-      fs.writeFile(filePath, data, {}, (err) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(filePath);
-        }
-      });
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-function readFile(path) {
-  return fs.readFileSync(path);
-}
-function fetchFile(url) {
-  return new Promise((resolve, reject) => {
-    https.get(url, (resp) => {
-      const data = [];
-      const mimeType = resp.headers["content-type"];
-      resp.on("data", (chunk) => {
-        data.push(chunk);
-      });
-      resp.on("end", () => {
-        resolve({ buffer: Buffer.concat(data), mimeType });
-      });
-    }).on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-const getFile = async (file) => {
-  return readFile(file);
-};
-const hash = (data, algorithm = "sha1") => {
-  return crypto.createHash(algorithm).update(data).digest("base64");
-};
-function generateId(method) {
-  if (method && method.toString() !== "UUIDv4") {
-    throw new Error(
-      `Id generation method not supported: "${method.toString()}"`
-    );
-  }
-  return generateUUID();
-}
-function getUnixTimestamp(date) {
-  return (new Date(date).getTime() / 1e3).toFixed(0);
-}
-function buildOperationSignatureParams({
-  documentId,
-  signer,
-  operation,
-  previousStateHash
-}) {
-  const { timestamp, scope, id, type } = operation;
-  return [
-    getUnixTimestamp(timestamp),
-    // timestamp,
-    signer.app.key,
-    // signer public key
-    hash(
-      // hash (docID, scope, operationID, operationName, operationInput)
-      [documentId, scope, id, type, cjsModule(operation.input)].join("")
-    ),
-    previousStateHash
-    // state hash that the operation was applied to
-  ];
-}
-const textEncode = new TextEncoder();
-function buildOperationSignatureMessage(params) {
-  const message = params.join("");
-  const prefix = "Signed Operation:\n" + message.length.toString();
-  return textEncode.encode(prefix + message);
-}
-function ab2hex(ab) {
-  const view = ArrayBuffer.isView(ab) ? ab : new Uint8Array(ab);
-  return Array.prototype.map.call(view, (x) => ("00" + x.toString(16)).slice(-2)).join("");
-}
-function hex2ab(hex) {
-  var _a;
-  return new Uint8Array(
-    ((_a = hex.match(/[\da-f]{2}/gi)) == null ? void 0 : _a.map(function(h) {
-      return parseInt(h, 16);
-    })) ?? []
-  );
-}
-async function buildOperationSignature(context, signMethod) {
-  const params = buildOperationSignatureParams(context);
-  const message = buildOperationSignatureMessage(params);
-  const signature = await signMethod(message);
-  return [...params, `0x${ab2hex(signature)}`];
-}
-async function buildSignedOperation(action, reducer, document, context, signHandler) {
-  var _a, _b;
-  const result = reducer(document, action, void 0, {
-    reuseHash: true,
-    reuseOperationResultingState: true
-  });
-  const operation = result.operations[action.scope].at(-1);
-  if (!operation) {
-    throw new Error("Action was not applied");
-  }
-  const previousStateHash = ((_a = result.operations[action.scope].at(-2)) == null ? void 0 : _a.hash) ?? "";
-  const signature = await buildOperationSignature(
-    {
-      ...context,
-      operation,
-      previousStateHash
-    },
-    signHandler
-  );
-  return {
-    ...operation,
-    context: {
-      ...operation.context,
-      signer: {
-        ...(_b = operation.context) == null ? void 0 : _b.signer,
-        ...context.signer,
-        signatures: [...context.signer.signatures ?? [], signature]
-      }
-    }
-  };
-}
-async function verifyOperationSignature(signature, signer, verifyHandler) {
-  const publicKey = signer.app.key;
-  const params = signature.slice(0, 4);
-  const signatureBytes = hex2ab(signature[4]);
-  const expectedMessage = buildOperationSignatureMessage(params);
-  return verifyHandler(publicKey, signatureBytes, expectedMessage);
-}
-class InvalidActionInputError extends Error {
-  constructor(data) {
-    super();
-    __publicField(this, "data");
-    this.name = "InvalidActionInputError";
-    this.data = data;
-    this.message = this.message || `Invalid action input: ${JSON.stringify(data, null, 2)}`;
-  }
-}
-class InvalidActionInputZodError extends InvalidActionInputError {
-  constructor(issues) {
-    super(issues);
-    __publicField(this, "issues");
-    this.issues = issues;
-    this.name = "InvalidActionInputZodError";
-  }
-}
-const types = {
-  "application/andrew-inset": ["ez"],
-  "application/appinstaller": ["appinstaller"],
-  "application/applixware": ["aw"],
-  "application/appx": ["appx"],
-  "application/appxbundle": ["appxbundle"],
-  "application/atom+xml": ["atom"],
-  "application/atomcat+xml": ["atomcat"],
-  "application/atomdeleted+xml": ["atomdeleted"],
-  "application/atomsvc+xml": ["atomsvc"],
-  "application/atsc-dwd+xml": ["dwd"],
-  "application/atsc-held+xml": ["held"],
-  "application/atsc-rsat+xml": ["rsat"],
-  "application/automationml-aml+xml": ["aml"],
-  "application/automationml-amlx+zip": ["amlx"],
-  "application/bdoc": ["bdoc"],
-  "application/calendar+xml": ["xcs"],
-  "application/ccxml+xml": ["ccxml"],
-  "application/cdfx+xml": ["cdfx"],
-  "application/cdmi-capability": ["cdmia"],
-  "application/cdmi-container": ["cdmic"],
-  "application/cdmi-domain": ["cdmid"],
-  "application/cdmi-object": ["cdmio"],
-  "application/cdmi-queue": ["cdmiq"],
-  "application/cpl+xml": ["cpl"],
-  "application/cu-seeme": ["cu"],
-  "application/cwl": ["cwl"],
-  "application/dash+xml": ["mpd"],
-  "application/dash-patch+xml": ["mpp"],
-  "application/davmount+xml": ["davmount"],
-  "application/docbook+xml": ["dbk"],
-  "application/dssc+der": ["dssc"],
-  "application/dssc+xml": ["xdssc"],
-  "application/ecmascript": ["ecma"],
-  "application/emma+xml": ["emma"],
-  "application/emotionml+xml": ["emotionml"],
-  "application/epub+zip": ["epub"],
-  "application/exi": ["exi"],
-  "application/express": ["exp"],
-  "application/fdf": ["fdf"],
-  "application/fdt+xml": ["fdt"],
-  "application/font-tdpfr": ["pfr"],
-  "application/geo+json": ["geojson"],
-  "application/gml+xml": ["gml"],
-  "application/gpx+xml": ["gpx"],
-  "application/gxf": ["gxf"],
-  "application/gzip": ["gz"],
-  "application/hjson": ["hjson"],
-  "application/hyperstudio": ["stk"],
-  "application/inkml+xml": ["ink", "inkml"],
-  "application/ipfix": ["ipfix"],
-  "application/its+xml": ["its"],
-  "application/java-archive": ["jar", "war", "ear"],
-  "application/java-serialized-object": ["ser"],
-  "application/java-vm": ["class"],
-  "application/javascript": ["*js"],
-  "application/json": ["json", "map"],
-  "application/json5": ["json5"],
-  "application/jsonml+json": ["jsonml"],
-  "application/ld+json": ["jsonld"],
-  "application/lgr+xml": ["lgr"],
-  "application/lost+xml": ["lostxml"],
-  "application/mac-binhex40": ["hqx"],
-  "application/mac-compactpro": ["cpt"],
-  "application/mads+xml": ["mads"],
-  "application/manifest+json": ["webmanifest"],
-  "application/marc": ["mrc"],
-  "application/marcxml+xml": ["mrcx"],
-  "application/mathematica": ["ma", "nb", "mb"],
-  "application/mathml+xml": ["mathml"],
-  "application/mbox": ["mbox"],
-  "application/media-policy-dataset+xml": ["mpf"],
-  "application/mediaservercontrol+xml": ["mscml"],
-  "application/metalink+xml": ["metalink"],
-  "application/metalink4+xml": ["meta4"],
-  "application/mets+xml": ["mets"],
-  "application/mmt-aei+xml": ["maei"],
-  "application/mmt-usd+xml": ["musd"],
-  "application/mods+xml": ["mods"],
-  "application/mp21": ["m21", "mp21"],
-  "application/mp4": ["*mp4", "*mpg4", "mp4s", "m4p"],
-  "application/msix": ["msix"],
-  "application/msixbundle": ["msixbundle"],
-  "application/msword": ["doc", "dot"],
-  "application/mxf": ["mxf"],
-  "application/n-quads": ["nq"],
-  "application/n-triples": ["nt"],
-  "application/node": ["cjs"],
-  "application/octet-stream": [
-    "bin",
-    "dms",
-    "lrf",
-    "mar",
-    "so",
-    "dist",
-    "distz",
-    "pkg",
-    "bpk",
-    "dump",
-    "elc",
-    "deploy",
-    "exe",
-    "dll",
-    "deb",
-    "dmg",
-    "iso",
-    "img",
-    "msi",
-    "msp",
-    "msm",
-    "buffer"
-  ],
-  "application/oda": ["oda"],
-  "application/oebps-package+xml": ["opf"],
-  "application/ogg": ["ogx"],
-  "application/omdoc+xml": ["omdoc"],
-  "application/onenote": ["onetoc", "onetoc2", "onetmp", "onepkg"],
-  "application/oxps": ["oxps"],
-  "application/p2p-overlay+xml": ["relo"],
-  "application/patch-ops-error+xml": ["xer"],
-  "application/pdf": ["pdf"],
-  "application/pgp-encrypted": ["pgp"],
-  "application/pgp-keys": ["asc"],
-  "application/pgp-signature": ["sig", "*asc"],
-  "application/pics-rules": ["prf"],
-  "application/pkcs10": ["p10"],
-  "application/pkcs7-mime": ["p7m", "p7c"],
-  "application/pkcs7-signature": ["p7s"],
-  "application/pkcs8": ["p8"],
-  "application/pkix-attr-cert": ["ac"],
-  "application/pkix-cert": ["cer"],
-  "application/pkix-crl": ["crl"],
-  "application/pkix-pkipath": ["pkipath"],
-  "application/pkixcmp": ["pki"],
-  "application/pls+xml": ["pls"],
-  "application/postscript": ["ai", "eps", "ps"],
-  "application/provenance+xml": ["provx"],
-  "application/pskc+xml": ["pskcxml"],
-  "application/raml+yaml": ["raml"],
-  "application/rdf+xml": ["rdf", "owl"],
-  "application/reginfo+xml": ["rif"],
-  "application/relax-ng-compact-syntax": ["rnc"],
-  "application/resource-lists+xml": ["rl"],
-  "application/resource-lists-diff+xml": ["rld"],
-  "application/rls-services+xml": ["rs"],
-  "application/route-apd+xml": ["rapd"],
-  "application/route-s-tsid+xml": ["sls"],
-  "application/route-usd+xml": ["rusd"],
-  "application/rpki-ghostbusters": ["gbr"],
-  "application/rpki-manifest": ["mft"],
-  "application/rpki-roa": ["roa"],
-  "application/rsd+xml": ["rsd"],
-  "application/rss+xml": ["rss"],
-  "application/rtf": ["rtf"],
-  "application/sbml+xml": ["sbml"],
-  "application/scvp-cv-request": ["scq"],
-  "application/scvp-cv-response": ["scs"],
-  "application/scvp-vp-request": ["spq"],
-  "application/scvp-vp-response": ["spp"],
-  "application/sdp": ["sdp"],
-  "application/senml+xml": ["senmlx"],
-  "application/sensml+xml": ["sensmlx"],
-  "application/set-payment-initiation": ["setpay"],
-  "application/set-registration-initiation": ["setreg"],
-  "application/shf+xml": ["shf"],
-  "application/sieve": ["siv", "sieve"],
-  "application/smil+xml": ["smi", "smil"],
-  "application/sparql-query": ["rq"],
-  "application/sparql-results+xml": ["srx"],
-  "application/sql": ["sql"],
-  "application/srgs": ["gram"],
-  "application/srgs+xml": ["grxml"],
-  "application/sru+xml": ["sru"],
-  "application/ssdl+xml": ["ssdl"],
-  "application/ssml+xml": ["ssml"],
-  "application/swid+xml": ["swidtag"],
-  "application/tei+xml": ["tei", "teicorpus"],
-  "application/thraud+xml": ["tfi"],
-  "application/timestamped-data": ["tsd"],
-  "application/toml": ["toml"],
-  "application/trig": ["trig"],
-  "application/ttml+xml": ["ttml"],
-  "application/ubjson": ["ubj"],
-  "application/urc-ressheet+xml": ["rsheet"],
-  "application/urc-targetdesc+xml": ["td"],
-  "application/voicexml+xml": ["vxml"],
-  "application/wasm": ["wasm"],
-  "application/watcherinfo+xml": ["wif"],
-  "application/widget": ["wgt"],
-  "application/winhlp": ["hlp"],
-  "application/wsdl+xml": ["wsdl"],
-  "application/wspolicy+xml": ["wspolicy"],
-  "application/xaml+xml": ["xaml"],
-  "application/xcap-att+xml": ["xav"],
-  "application/xcap-caps+xml": ["xca"],
-  "application/xcap-diff+xml": ["xdf"],
-  "application/xcap-el+xml": ["xel"],
-  "application/xcap-ns+xml": ["xns"],
-  "application/xenc+xml": ["xenc"],
-  "application/xfdf": ["xfdf"],
-  "application/xhtml+xml": ["xhtml", "xht"],
-  "application/xliff+xml": ["xlf"],
-  "application/xml": ["xml", "xsl", "xsd", "rng"],
-  "application/xml-dtd": ["dtd"],
-  "application/xop+xml": ["xop"],
-  "application/xproc+xml": ["xpl"],
-  "application/xslt+xml": ["*xsl", "xslt"],
-  "application/xspf+xml": ["xspf"],
-  "application/xv+xml": ["mxml", "xhvml", "xvml", "xvm"],
-  "application/yang": ["yang"],
-  "application/yin+xml": ["yin"],
-  "application/zip": ["zip"],
-  "audio/3gpp": ["*3gpp"],
-  "audio/aac": ["adts", "aac"],
-  "audio/adpcm": ["adp"],
-  "audio/amr": ["amr"],
-  "audio/basic": ["au", "snd"],
-  "audio/midi": ["mid", "midi", "kar", "rmi"],
-  "audio/mobile-xmf": ["mxmf"],
-  "audio/mp3": ["*mp3"],
-  "audio/mp4": ["m4a", "mp4a"],
-  "audio/mpeg": ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"],
-  "audio/ogg": ["oga", "ogg", "spx", "opus"],
-  "audio/s3m": ["s3m"],
-  "audio/silk": ["sil"],
-  "audio/wav": ["wav"],
-  "audio/wave": ["*wav"],
-  "audio/webm": ["weba"],
-  "audio/xm": ["xm"],
-  "font/collection": ["ttc"],
-  "font/otf": ["otf"],
-  "font/ttf": ["ttf"],
-  "font/woff": ["woff"],
-  "font/woff2": ["woff2"],
-  "image/aces": ["exr"],
-  "image/apng": ["apng"],
-  "image/avci": ["avci"],
-  "image/avcs": ["avcs"],
-  "image/avif": ["avif"],
-  "image/bmp": ["bmp", "dib"],
-  "image/cgm": ["cgm"],
-  "image/dicom-rle": ["drle"],
-  "image/dpx": ["dpx"],
-  "image/emf": ["emf"],
-  "image/fits": ["fits"],
-  "image/g3fax": ["g3"],
-  "image/gif": ["gif"],
-  "image/heic": ["heic"],
-  "image/heic-sequence": ["heics"],
-  "image/heif": ["heif"],
-  "image/heif-sequence": ["heifs"],
-  "image/hej2k": ["hej2"],
-  "image/hsj2": ["hsj2"],
-  "image/ief": ["ief"],
-  "image/jls": ["jls"],
-  "image/jp2": ["jp2", "jpg2"],
-  "image/jpeg": ["jpeg", "jpg", "jpe"],
-  "image/jph": ["jph"],
-  "image/jphc": ["jhc"],
-  "image/jpm": ["jpm", "jpgm"],
-  "image/jpx": ["jpx", "jpf"],
-  "image/jxl": ["jxl"],
-  "image/jxr": ["jxr"],
-  "image/jxra": ["jxra"],
-  "image/jxrs": ["jxrs"],
-  "image/jxs": ["jxs"],
-  "image/jxsc": ["jxsc"],
-  "image/jxsi": ["jxsi"],
-  "image/jxss": ["jxss"],
-  "image/ktx": ["ktx"],
-  "image/ktx2": ["ktx2"],
-  "image/png": ["png"],
-  "image/sgi": ["sgi"],
-  "image/svg+xml": ["svg", "svgz"],
-  "image/t38": ["t38"],
-  "image/tiff": ["tif", "tiff"],
-  "image/tiff-fx": ["tfx"],
-  "image/webp": ["webp"],
-  "image/wmf": ["wmf"],
-  "message/disposition-notification": ["disposition-notification"],
-  "message/global": ["u8msg"],
-  "message/global-delivery-status": ["u8dsn"],
-  "message/global-disposition-notification": ["u8mdn"],
-  "message/global-headers": ["u8hdr"],
-  "message/rfc822": ["eml", "mime"],
-  "model/3mf": ["3mf"],
-  "model/gltf+json": ["gltf"],
-  "model/gltf-binary": ["glb"],
-  "model/iges": ["igs", "iges"],
-  "model/jt": ["jt"],
-  "model/mesh": ["msh", "mesh", "silo"],
-  "model/mtl": ["mtl"],
-  "model/obj": ["obj"],
-  "model/prc": ["prc"],
-  "model/step+xml": ["stpx"],
-  "model/step+zip": ["stpz"],
-  "model/step-xml+zip": ["stpxz"],
-  "model/stl": ["stl"],
-  "model/u3d": ["u3d"],
-  "model/vrml": ["wrl", "vrml"],
-  "model/x3d+binary": ["*x3db", "x3dbz"],
-  "model/x3d+fastinfoset": ["x3db"],
-  "model/x3d+vrml": ["*x3dv", "x3dvz"],
-  "model/x3d+xml": ["x3d", "x3dz"],
-  "model/x3d-vrml": ["x3dv"],
-  "text/cache-manifest": ["appcache", "manifest"],
-  "text/calendar": ["ics", "ifb"],
-  "text/coffeescript": ["coffee", "litcoffee"],
-  "text/css": ["css"],
-  "text/csv": ["csv"],
-  "text/html": ["html", "htm", "shtml"],
-  "text/jade": ["jade"],
-  "text/javascript": ["js", "mjs"],
-  "text/jsx": ["jsx"],
-  "text/less": ["less"],
-  "text/markdown": ["md", "markdown"],
-  "text/mathml": ["mml"],
-  "text/mdx": ["mdx"],
-  "text/n3": ["n3"],
-  "text/plain": ["txt", "text", "conf", "def", "list", "log", "in", "ini"],
-  "text/richtext": ["rtx"],
-  "text/rtf": ["*rtf"],
-  "text/sgml": ["sgml", "sgm"],
-  "text/shex": ["shex"],
-  "text/slim": ["slim", "slm"],
-  "text/spdx": ["spdx"],
-  "text/stylus": ["stylus", "styl"],
-  "text/tab-separated-values": ["tsv"],
-  "text/troff": ["t", "tr", "roff", "man", "me", "ms"],
-  "text/turtle": ["ttl"],
-  "text/uri-list": ["uri", "uris", "urls"],
-  "text/vcard": ["vcard"],
-  "text/vtt": ["vtt"],
-  "text/wgsl": ["wgsl"],
-  "text/xml": ["*xml"],
-  "text/yaml": ["yaml", "yml"],
-  "video/3gpp": ["3gp", "3gpp"],
-  "video/3gpp2": ["3g2"],
-  "video/h261": ["h261"],
-  "video/h263": ["h263"],
-  "video/h264": ["h264"],
-  "video/iso.segment": ["m4s"],
-  "video/jpeg": ["jpgv"],
-  "video/jpm": ["*jpm", "*jpgm"],
-  "video/mj2": ["mj2", "mjp2"],
-  "video/mp2t": ["ts", "m2t", "m2ts", "mts"],
-  "video/mp4": ["mp4", "mp4v", "mpg4"],
-  "video/mpeg": ["mpeg", "mpg", "mpe", "m1v", "m2v"],
-  "video/ogg": ["ogv"],
-  "video/quicktime": ["qt", "mov"],
-  "video/webm": ["webm"]
-};
-Object.freeze(types);
-var __classPrivateFieldGet = function(receiver, state, kind, f) {
-  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Mime_extensionToType, _Mime_typeToExtension, _Mime_typeToExtensions;
-class Mime {
-  constructor(...args) {
-    _Mime_extensionToType.set(this, /* @__PURE__ */ new Map());
-    _Mime_typeToExtension.set(this, /* @__PURE__ */ new Map());
-    _Mime_typeToExtensions.set(this, /* @__PURE__ */ new Map());
-    for (const arg of args) {
-      this.define(arg);
-    }
-  }
-  define(typeMap, force = false) {
-    for (let [type, extensions] of Object.entries(typeMap)) {
-      type = type.toLowerCase();
-      extensions = extensions.map((ext) => ext.toLowerCase());
-      if (!__classPrivateFieldGet(this, _Mime_typeToExtensions, "f").has(type)) {
-        __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").set(type, /* @__PURE__ */ new Set());
-      }
-      const allExtensions = __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type);
-      let first = true;
-      for (let extension of extensions) {
-        const starred = extension.startsWith("*");
-        extension = starred ? extension.slice(1) : extension;
-        allExtensions == null ? void 0 : allExtensions.add(extension);
-        if (first) {
-          __classPrivateFieldGet(this, _Mime_typeToExtension, "f").set(type, extension);
-        }
-        first = false;
-        if (starred)
-          continue;
-        const currentType = __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(extension);
-        if (currentType && currentType != type && !force) {
-          throw new Error(`"${type} -> ${extension}" conflicts with "${currentType} -> ${extension}". Pass \`force=true\` to override this definition.`);
-        }
-        __classPrivateFieldGet(this, _Mime_extensionToType, "f").set(extension, type);
-      }
-    }
-    return this;
-  }
-  getType(path) {
-    if (typeof path !== "string")
-      return null;
-    const last = path.replace(/^.*[/\\]/, "").toLowerCase();
-    const ext = last.replace(/^.*\./, "").toLowerCase();
-    const hasPath = last.length < path.length;
-    const hasDot = ext.length < last.length - 1;
-    if (!hasDot && hasPath)
-      return null;
-    return __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(ext) ?? null;
-  }
-  getExtension(type) {
-    var _a;
-    if (typeof type !== "string")
-      return null;
-    type = (_a = type == null ? void 0 : type.split) == null ? void 0 : _a.call(type, ";")[0];
-    return (type && __classPrivateFieldGet(this, _Mime_typeToExtension, "f").get(type.trim().toLowerCase())) ?? null;
-  }
-  getAllExtensions(type) {
-    if (typeof type !== "string")
-      return null;
-    return __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type.toLowerCase()) ?? null;
-  }
-  _freeze() {
-    this.define = () => {
-      throw new Error("define() not allowed for built-in Mime objects. See https://github.com/broofa/mime/blob/main/README.md#custom-mime-instances");
-    };
-    Object.freeze(this);
-    for (const extensions of __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").values()) {
-      Object.freeze(extensions);
-    }
-    return this;
-  }
-  _getTestState() {
-    return {
-      types: __classPrivateFieldGet(this, _Mime_extensionToType, "f"),
-      extensions: __classPrivateFieldGet(this, _Mime_typeToExtension, "f")
-    };
-  }
-}
-_Mime_extensionToType = /* @__PURE__ */ new WeakMap(), _Mime_typeToExtension = /* @__PURE__ */ new WeakMap(), _Mime_typeToExtensions = /* @__PURE__ */ new WeakMap();
-const mime = new Mime(types)._freeze();
-function validateOperations(operations) {
-  const errors = [];
-  const scopes = Object.keys(operations);
-  for (const scope of scopes) {
-    const ops = operations[scope].sort((a, b) => a.index - b.index);
-    let opIndex = -1;
-    for (let i = 0; i < ops.length; i++) {
-      opIndex = opIndex + 1 + ops[i].skip;
-      if (ops[i].index !== opIndex) {
-        errors.push({
-          message: `Invalid operation index ${ops[i].index} at position ${i}`,
-          details: {
-            position: i,
-            operation: ops[i],
-            scope: ops[i].scope
-          }
-        });
-      }
-    }
-  }
-  return errors;
-}
-var IntegrityIssueType = /* @__PURE__ */ ((IntegrityIssueType2) => {
-  IntegrityIssueType2["UNEXPECTED_INDEX"] = "UNEXPECTED_INDEX";
-  return IntegrityIssueType2;
-})(IntegrityIssueType || {});
-var IntegrityIssueSubType = /* @__PURE__ */ ((IntegrityIssueSubType2) => {
-  IntegrityIssueSubType2["DUPLICATED_INDEX"] = "DUPLICATED_INDEX";
-  IntegrityIssueSubType2["MISSING_INDEX"] = "MISSING_INDEX";
-  return IntegrityIssueSubType2;
-})(IntegrityIssueSubType || {});
-function checkCleanedOperationsIntegrity(sortedOperations) {
-  const result = [];
-  let currentIndex = -1;
-  for (const nextOperation of sortedOperations) {
-    const nextIndex = nextOperation.index - nextOperation.skip;
-    if (nextIndex !== currentIndex + 1) {
-      result.push({
-        operation: {
-          index: nextOperation.index,
-          skip: nextOperation.skip
-        },
-        issue: "UNEXPECTED_INDEX",
-        category: nextIndex > currentIndex + 1 ? "MISSING_INDEX" : "DUPLICATED_INDEX",
-        message: `Expected index ${currentIndex + 1} with skip 0 or equivalent, got index ${nextOperation.index} with skip ${nextOperation.skip}`
-      });
-    }
-    currentIndex = nextOperation.index;
-  }
-  return result;
-}
-function garbageCollect(sortedOperations) {
-  var _a, _b, _c;
-  const result = [];
-  let i = sortedOperations.length - 1;
-  while (i > -1) {
-    result.unshift(sortedOperations[i]);
-    const skipUntil = (((_a = sortedOperations[i]) == null ? void 0 : _a.index) || 0) - (((_b = sortedOperations[i]) == null ? void 0 : _b.skip) || 0) - 1;
-    let j = i - 1;
-    while (j > -1 && (((_c = sortedOperations[j]) == null ? void 0 : _c.index) || 0) > skipUntil) {
-      j--;
-    }
-    i = j;
-  }
-  return result;
-}
-function addUndo(sortedOperations) {
-  const operationsCopy = [...sortedOperations];
-  const latestOperation = operationsCopy[operationsCopy.length - 1];
-  if (!latestOperation) return operationsCopy;
-  if (latestOperation.type === "NOOP") {
-    operationsCopy.push({
-      ...latestOperation,
-      index: latestOperation.index,
-      type: "NOOP",
-      skip: nextSkipNumber(sortedOperations)
-    });
-  } else {
-    operationsCopy.push({
-      type: "NOOP",
-      index: latestOperation.index + 1,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      input: {},
-      skip: 1,
-      scope: latestOperation.scope,
-      hash: latestOperation.hash
-    });
-  }
-  return operationsCopy;
-}
-function sortOperations$1(operations) {
-  return operations.slice().sort((a, b) => a.skip - b.skip).sort((a, b) => a.index - b.index);
-}
-const reshuffleByTimestamp = (startIndex, opsA, opsB) => {
-  return [...opsA, ...opsB].sort(
-    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
-  ).map((op, i) => ({
-    ...op,
-    index: startIndex.index + i,
-    skip: i === 0 ? startIndex.skip : 0
-  }));
-};
-const reshuffleByTimestampAndIndex = (startIndex, opsA, opsB) => {
-  return [...opsA, ...opsB].sort(
-    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
-  ).sort((a, b) => a.index - b.index).map((op, i) => ({
-    ...op,
-    index: startIndex.index + i,
-    skip: i === 0 ? startIndex.skip : 0
-  }));
-};
-function operationsAreEqual(op1, op2) {
-  return cjsModule(op1) === cjsModule(op2);
-}
-function attachBranch(trunk, newBranch) {
-  const trunkCopy = garbageCollect(sortOperations$1(trunk.slice()));
-  const newOperations = garbageCollect(sortOperations$1(newBranch.slice()));
-  if (trunkCopy.length < 1) {
-    return [newOperations, []];
-  }
-  const result = [];
-  let enteredBranch = false;
-  while (newOperations.length > 0) {
-    const newOperationCandidate = newOperations[0];
-    let nextTrunkOperation = trunkCopy.shift();
-    while (nextTrunkOperation && precedes(nextTrunkOperation, newOperationCandidate)) {
-      result.push(nextTrunkOperation);
-      nextTrunkOperation = trunkCopy.shift();
-    }
-    if (!nextTrunkOperation) {
-      enteredBranch = true;
-    } else if (!enteredBranch) {
-      if (operationsAreEqual(nextTrunkOperation, newOperationCandidate)) {
-        newOperations.shift();
-        result.push(nextTrunkOperation);
-      } else {
-        trunkCopy.unshift(nextTrunkOperation);
-        enteredBranch = true;
-      }
-    }
-    if (enteredBranch) {
-      let nextAppend = newOperations.shift();
-      while (nextAppend) {
-        result.push(nextAppend);
-        nextAppend = newOperations.shift();
-      }
-    }
-  }
-  if (!enteredBranch) {
-    let nextAppend = trunkCopy.shift();
-    while (nextAppend) {
-      result.push(nextAppend);
-      nextAppend = trunkCopy.shift();
-    }
-  }
-  return [garbageCollect(result), trunkCopy];
-}
-function precedes(op1, op2) {
-  return op1.index < op2.index || op1.index === op2.index && op1.id === op2.id && op1.skip < op2.skip;
-}
-function split(sortedTargetOperations, sortedMergeOperations) {
-  const commonOperations = [];
-  const targetDiffOperations = [];
-  const mergeDiffOperations = [];
-  const maxLength = Math.max(
-    sortedTargetOperations.length,
-    sortedMergeOperations.length
-  );
-  let splitHappened = false;
-  for (let i = 0; i < maxLength; i++) {
-    const targetOperation = sortedTargetOperations[i];
-    const mergeOperation = sortedMergeOperations[i];
-    if (targetOperation && mergeOperation) {
-      if (!splitHappened && operationsAreEqual(targetOperation, mergeOperation)) {
-        commonOperations.push(targetOperation);
-      } else {
-        splitHappened = true;
-        targetDiffOperations.push(targetOperation);
-        mergeDiffOperations.push(mergeOperation);
-      }
-    } else if (targetOperation) {
-      targetDiffOperations.push(targetOperation);
-    } else if (mergeOperation) {
-      mergeDiffOperations.push(mergeOperation);
-    }
-  }
-  return [commonOperations, targetDiffOperations, mergeDiffOperations];
-}
-function merge(sortedTargetOperations, sortedMergeOperations, reshuffle) {
-  const [_commonOperations, _targetOperations, _mergeOperations] = split(
-    garbageCollect(sortedTargetOperations),
-    garbageCollect(sortedMergeOperations)
-  );
-  const maxCommonIndex = getMaxIndex(_commonOperations);
-  const nextIndex = 1 + Math.max(
-    maxCommonIndex,
-    getMaxIndex(_targetOperations),
-    getMaxIndex(_mergeOperations)
-  );
-  const filteredMergeOperations = filterDuplicatedOperations(
-    _mergeOperations,
-    _targetOperations
-  );
-  const newOperationHistory = reshuffle(
-    {
-      index: nextIndex,
-      skip: nextIndex - (maxCommonIndex + 1)
-    },
-    _targetOperations,
-    filteredMergeOperations
-  );
-  return _commonOperations.concat(newOperationHistory);
-}
-function getMaxIndex(sortedOperations) {
-  const lastElement = sortedOperations[sortedOperations.length - 1];
-  if (!lastElement) {
-    return -1;
-  }
-  return lastElement.index;
-}
-function nextSkipNumber(sortedOperations) {
-  var _a, _b, _c;
-  if (sortedOperations.length < 1) {
-    return -1;
-  }
-  const cleanedOperations = garbageCollect(sortedOperations);
-  let nextSkip = (((_a = cleanedOperations[cleanedOperations.length - 1]) == null ? void 0 : _a.skip) || 0) + 1;
-  if (cleanedOperations.length > 1) {
-    nextSkip += ((_b = cleanedOperations[cleanedOperations.length - 2]) == null ? void 0 : _b.skip) || 0;
-  }
-  return (((_c = cleanedOperations[cleanedOperations.length - 1]) == null ? void 0 : _c.index) || -1) < nextSkip ? -1 : nextSkip;
-}
-const checkOperationsIntegrity = (operations) => {
-  return checkCleanedOperationsIntegrity(
-    garbageCollect(sortOperations$1(operations))
-  );
-};
-const groupOperationsByScope = (operations) => {
-  const result = operations.reduce((acc, operation) => {
-    var _a;
-    if (!acc[operation.scope]) {
-      acc[operation.scope] = [];
-    }
-    (_a = acc[operation.scope]) == null ? void 0 : _a.push(operation);
-    return acc;
-  }, {});
-  return result;
-};
-const prepareOperations = (operationsHistory, newOperations) => {
-  var _a;
-  const result = {
-    integrityIssues: [],
-    validOperations: [],
-    invalidOperations: [],
-    duplicatedOperations: []
-  };
-  const sortedOperationsHistory = sortOperations$1(operationsHistory);
-  const sortedOperations = sortOperations$1(newOperations);
-  const integrityErrors = checkCleanedOperationsIntegrity([
-    ...sortedOperationsHistory,
-    ...sortedOperations
-  ]);
-  const missingIndexErrors = integrityErrors.filter(
-    (integrityIssue) => integrityIssue.category === "MISSING_INDEX"
-    /* MISSING_INDEX */
-  );
-  const firstMissingIndexOperation = (_a = [...missingIndexErrors].sort((a, b) => b.operation.index - a.operation.index).pop()) == null ? void 0 : _a.operation;
-  for (const newOperation of sortedOperations) {
-    if (firstMissingIndexOperation && newOperation.index >= firstMissingIndexOperation.index) {
-      result.invalidOperations.push(newOperation);
-      continue;
-    }
-    const isDuplicatedOperation = integrityErrors.some((integrityError) => {
-      return integrityError.operation.index === newOperation.index && integrityError.operation.skip === newOperation.skip && integrityError.category === "DUPLICATED_INDEX";
-    });
-    if (isDuplicatedOperation) {
-      result.duplicatedOperations.push(newOperation);
-      continue;
-    }
-    result.validOperations.push(newOperation);
-  }
-  result.integrityIssues.push(...integrityErrors);
-  return result;
-};
-function removeExistingOperations(newOperations, operationsHistory) {
-  return newOperations.filter((newOperation) => {
-    return !operationsHistory.some((historyOperation) => {
-      return newOperation.type === "NOOP" && newOperation.skip === 0 && newOperation.index === historyOperation.index || newOperation.index === historyOperation.index && newOperation.skip === historyOperation.skip && newOperation.scope === historyOperation.scope && newOperation.hash === historyOperation.hash && newOperation.type === historyOperation.type;
-    });
-  });
-}
-function skipHeaderOperations(operations, skipHeaderOperation) {
-  const [lastOperation] = sortOperations$1(operations).slice(-1);
-  const lastIndex = (lastOperation == null ? void 0 : lastOperation.index) ?? -1;
-  const nextIndex = lastIndex + 1;
-  const skipOperationIndex = {
-    ...skipHeaderOperation,
-    index: skipHeaderOperation.index ?? nextIndex
-  };
-  if (skipOperationIndex.index < lastIndex) {
-    throw new Error(
-      `The skip header operation index must be greater than or equal to ${lastIndex}`
-    );
-  }
-  const clearedOperations = garbageCollect(
-    sortOperations$1([...operations, skipOperationIndex])
-  );
-  return (clearedOperations || []).slice(0, -1);
-}
-function garbageCollectDocumentOperations(documentOperations) {
-  const clearedOperations = Object.entries(documentOperations).reduce(
-    (acc, entry) => {
-      const [scope, ops] = entry;
-      return {
-        ...acc,
-        [scope]: garbageCollect(sortOperations$1(ops))
-      };
-    },
-    {}
-  );
-  return {
-    ...clearedOperations
-  };
-}
-function filterDuplicatedOperations(targetOperations, sourceOperations) {
-  return targetOperations.filter((op) => {
-    if (op.id) {
-      return !sourceOperations.some((targetOp) => targetOp.id === op.id);
-    }
-    return true;
-  });
-}
-function filterDocumentOperationsResultingState(documentOperations) {
-  if (!documentOperations) {
-    return {};
-  }
-  const entries = Object.entries(documentOperations);
-  return entries.reduce(
-    (acc, [scope, operations]) => ({
-      ...acc,
-      [scope]: operations.map((op) => {
-        const { resultingState, ...restProps } = op;
-        return restProps;
-      })
-    }),
-    {}
-  );
-}
-function diffOperations(clearedOperationsA, clearedOperationsB) {
-  return clearedOperationsA.filter(
-    (operationA) => !clearedOperationsB.some(
-      (operationB) => operationA.index === operationB.index
-    )
-  );
-}
-const documentHelpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  IntegrityIssueSubType,
-  IntegrityIssueType,
-  addUndo,
-  attachBranch,
-  checkCleanedOperationsIntegrity,
-  checkOperationsIntegrity,
-  diffOperations,
-  filterDocumentOperationsResultingState,
-  filterDuplicatedOperations,
-  garbageCollect,
-  garbageCollectDocumentOperations,
-  groupOperationsByScope,
-  merge,
-  nextSkipNumber,
-  operationsAreEqual,
-  precedes,
-  prepareOperations,
-  removeExistingOperations,
-  reshuffleByTimestamp,
-  reshuffleByTimestampAndIndex,
-  skipHeaderOperations,
-  sortOperations: sortOperations$1,
-  split
-}, Symbol.toStringTag, { value: "Module" }));
-const createZip = async (document) => {
-  const zip = new JSZip();
-  const { name, revision, documentType, created, lastModified } = document;
-  const header = {
-    name,
-    revision,
-    documentType,
-    created,
-    lastModified
-  };
-  zip.file("header.json", JSON.stringify(header, null, 2));
-  zip.file("state.json", JSON.stringify(document.initialState || {}, null, 2));
-  zip.file("current-state.json", JSON.stringify(document.state || {}, null, 2));
-  zip.file(
-    "operations.json",
-    JSON.stringify(
-      filterDocumentOperationsResultingState(document.operations),
-      null,
-      2
-    )
-  );
-  if (document.attachments) {
-    const attachments = Object.keys(document.attachments);
-    attachments.forEach((key) => {
-      const { data, ...attributes } = document.attachments[key];
-      zip.file(key, data, {
-        base64: true,
-        createFolders: true,
-        comment: JSON.stringify(attributes)
-      });
-    });
-  }
-  return zip;
-};
-const saveToFile = async (document, path, extension, name) => {
-  const zip = await createZip(document);
-  const file = await zip.generateAsync({
-    type: "uint8array",
-    streamFiles: true
-  });
-  const fileName = name ?? document.name;
-  const fileExtension = `.${extension}.zip`;
-  return writeFile(
-    path,
-    fileName.endsWith(fileExtension) ? fileName : `${fileName}${fileExtension}`,
-    file
-  );
-};
-const saveToFileHandle = async (document, input) => {
-  const zip = await createZip(document);
-  const blob = await zip.generateAsync({ type: "blob" });
-  const writable = await input.createWritable();
-  await writable.write(blob);
-  await writable.close();
-};
-const loadFromFile = async (path, reducer, options) => {
-  const file = readFile(path);
-  return loadFromInput(file, reducer, options);
-};
-const loadFromInput = async (input, reducer, options) => {
-  const zip = new JSZip();
-  await zip.loadAsync(input);
-  return loadFromZip(zip, reducer, options);
-};
-async function loadFromZip(zip, reducer, options) {
-  const initialStateZip = zip.file("state.json");
-  if (!initialStateZip) {
-    throw new Error("Initial state not found");
-  }
-  const initialStateStr = await initialStateZip.async("string");
-  const initialState = JSON.parse(initialStateStr);
-  const headerZip = zip.file("header.json");
-  let header = void 0;
-  if (headerZip) {
-    header = JSON.parse(await headerZip.async("string"));
-  }
-  const operationsZip = zip.file("operations.json");
-  if (!operationsZip) {
-    throw new Error("Operations history not found");
-  }
-  const operations = JSON.parse(
-    await operationsZip.async("string")
-  );
-  const clearedOperations = garbageCollectDocumentOperations(operations);
-  const operationsError = validateOperations(clearedOperations);
-  if (operationsError.length) {
-    const errorMessages = operationsError.map((err) => err.message);
-    throw new Error(errorMessages.join("\n"));
-  }
-  let result = replayDocument(
-    initialState,
-    clearedOperations,
-    reducer,
-    void 0,
-    header,
-    {},
-    options
-  );
-  if (header) {
-    result = {
-      ...result,
-      ...header
-    };
-  }
-  return result;
-}
-function getFileAttributes(file) {
-  const extension = file.replace(/^.*\./, "") || void 0;
-  const fileName = file.replace(/^.*[/\\]/, "") || void 0;
-  return { extension, fileName };
-}
-async function getRemoteFile(url) {
-  const { buffer, mimeType = "application/octet-stream" } = await fetchFile(url);
-  const attributes = getFileAttributes(url);
-  const data = buffer.toString("base64");
-  return {
-    data,
-    hash: hash(data),
-    mimeType,
-    ...attributes
-  };
-}
-async function getLocalFile(path) {
-  const buffer = await getFile(path);
-  const mimeType = mime.getType(path) || "application/octet-stream";
-  const attributes = getFileAttributes(path);
-  const data = buffer.toString("base64");
-  return { data, hash: hash(data), mimeType, ...attributes };
-}
-function setNameOperation(document, name) {
-  return { ...document, name };
-}
-function undoOperation(document, action, skip) {
-  const { scope, input } = action;
-  const defaultResult = {
-    document,
-    action,
-    skip,
-    reuseLastOperationIndex: false
-  };
-  return create(defaultResult, (draft) => {
-    const operations = [...document.operations[scope]];
-    const sortedOperations = sortOperations$1(operations);
-    draft.action = noop(scope);
-    const lastOperation = sortedOperations.at(-1);
-    let nextIndex = (lastOperation == null ? void 0 : lastOperation.index) ?? -1;
-    const isNewNoop = (lastOperation == null ? void 0 : lastOperation.type) !== "NOOP";
-    if (isNewNoop) {
-      nextIndex = nextIndex + 1;
-    } else {
-      draft.reuseLastOperationIndex = true;
-    }
-    const nextOperationHistory = isNewNoop ? [...sortedOperations, { index: nextIndex, skip: 0 }] : sortedOperations;
-    draft.skip = nextSkipNumber(nextOperationHistory);
-    if (lastOperation && draft.skip > lastOperation.skip + 1) {
-      draft.skip = draft.skip + 1;
-    }
-    if (draft.skip < 0) {
-      throw new Error(
-        `Cannot undo: you can't undo more operations than the ones in the scope history`
-      );
-    }
-  });
-}
-function redoOperation(document, action, skip) {
-  const { scope, input } = action;
-  const defaultResult = {
-    document,
-    action,
-    skip,
-    reuseLastOperationIndex: false
-  };
-  return create(defaultResult, (draft) => {
-    if (draft.skip > 0) {
-      throw new Error(
-        `Cannot redo: skip value from reducer cannot be used with REDO action`
-      );
-    }
-    if (input > 1) {
-      throw new Error(`Cannot redo: you can only redo one operation at a time`);
-    }
-    if (input < 1) {
-      throw new Error(`Invalid REDO action: invalid redo input value`);
-    }
-    if (draft.document.clipboard.length < 1) {
-      throw new Error(`Cannot redo: no operations in the clipboard`);
-    }
-    const operationIndex = draft.document.clipboard.findLastIndex(
-      (op) => op.scope === scope
-    );
-    if (operationIndex < 0) {
-      throw new Error(
-        `Cannot redo: no operations in clipboard for scope "${scope}"`
-      );
-    }
-    const operation = draft.document.clipboard.splice(operationIndex, 1)[0];
-    draft.action = castDraft({
-      type: operation.type,
-      scope: operation.scope,
-      input: operation.input
-    });
-  });
-}
-function pruneOperation(document, action, wrappedReducer) {
-  const { scope } = action;
-  const operations = document.operations[scope];
-  let {
-    input: { start, end }
-  } = action;
-  start = start || 0;
-  end = end || operations.length;
-  const actionsToPrune = operations.slice(start, end);
-  const actionsToKeepStart = operations.slice(0, start);
-  const actionsToKeepEnd = operations.slice(end);
-  const newDocument = replayOperations(
-    document.initialState,
-    {
-      ...document.operations,
-      [scope]: actionsToKeepStart.concat(actionsToPrune)
-    },
-    wrappedReducer
-  );
-  const { name, state: newState } = newDocument;
-  const loadStateIndex = actionsToKeepStart.length;
-  const loadStateTimestamp = actionsToKeepStart.length ? actionsToKeepStart[actionsToKeepStart.length - 1].timestamp : actionsToKeepEnd.length ? actionsToKeepEnd[0].timestamp : (/* @__PURE__ */ new Date()).toISOString();
-  return replayOperations(
-    document.initialState,
-    {
-      ...document.operations,
-      [scope]: [
-        ...actionsToKeepStart,
-        {
-          ...loadState({ name, state: newState }, actionsToPrune.length),
-          timestamp: loadStateTimestamp,
-          index: loadStateIndex,
-          hash: hashDocument({ state: newState }, "global")
-        },
-        ...actionsToKeepEnd.map((action2, index) => ({
-          ...action2,
-          index: loadStateIndex + index + 1
-        }))
-      ]
-    },
-    wrappedReducer
-  );
-}
-function loadStateOperation(oldDocument, newDocument) {
-  return {
-    ...oldDocument,
-    name: newDocument.name,
-    state: newDocument.state ?? { global: {}, local: {} }
-  };
-}
-const SET_NAME = "SET_NAME";
-const UNDO = "UNDO";
-const REDO = "REDO";
-const PRUNE = "PRUNE";
-const LOAD_STATE = "LOAD_STATE";
-const NOOP = "NOOP";
-function getNextRevision(document, action) {
-  let latestOperation;
-  if ("index" in action) {
-    latestOperation = { ...action };
-  } else {
-    latestOperation = document.operations[action.scope].at(-1);
-  }
-  return ((latestOperation == null ? void 0 : latestOperation.index) ?? -1) + 1;
-}
-function updateHeader(document, action) {
-  return {
-    ...document,
-    revision: {
-      ...document.revision,
-      [action.scope]: getNextRevision(document, action)
-    },
-    lastModified: getDocumentLastModified(document)
-  };
-}
-function updateOperations(document, action, skip = 0, reuseLastOperationIndex = false) {
-  if ([UNDO, REDO, PRUNE].includes(action.type)) {
-    return document;
-  }
-  const { scope } = action;
-  const operations = document.operations[scope].slice();
-  let operationId;
-  const latestOperation = operations.at(-1);
-  const lastOperationIndex = (latestOperation == null ? void 0 : latestOperation.index) ?? -1;
-  let nextIndex = reuseLastOperationIndex ? lastOperationIndex : lastOperationIndex + 1;
-  let timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  if ("index" in action) {
-    if (action.index - skip > nextIndex) {
-      throw new Error(
-        `Missing operations: expected ${nextIndex} with skip 0 or equivalent, got index ${action.index} with skip ${skip}`
-      );
-    }
-    nextIndex = action.index;
-    operationId = action.id;
-    timestamp = action.timestamp;
-  } else {
-    operationId = "id" in action ? action.id : generateId();
-  }
-  operations.push({
-    ...action,
-    id: operationId,
-    index: nextIndex,
-    timestamp,
-    hash: "",
-    scope,
-    skip,
-    error: void 0
-  });
-  return {
-    ...document,
-    operations: { ...document.operations, [scope]: operations }
-  };
-}
-function updateDocument(document, action, skip = 0, reuseLastOperationIndex = false) {
-  let newDocument = updateOperations(
-    document,
-    action,
-    skip,
-    reuseLastOperationIndex
-  );
-  newDocument = updateHeader(newDocument, action);
-  return newDocument;
-}
-function _baseReducer(document, action, wrappedReducer) {
-  BaseActionSchema().parse(action);
-  switch (action.type) {
-    case SET_NAME:
-      return setNameOperation(document, action.input);
-    case PRUNE:
-      return pruneOperation(document, action, wrappedReducer);
-    case LOAD_STATE:
-      return loadStateOperation(document, action.input.state);
-    default:
-      return document;
-  }
-}
-function processUndoRedo(document, action, skip) {
-  switch (action.type) {
-    case UNDO:
-      return undoOperation(document, action, skip);
-    case REDO:
-      return redoOperation(document, action, skip);
-    default:
-      return { document, action, skip, reuseLastOperationIndex: false };
-  }
-}
-function processSkipOperation(document, action, customReducer, skipValue, reuseOperationResultingState = false, resultingStateParser = parseResultingState) {
-  const scope = action.scope;
-  const latestOperation = document.operations[scope].at(-1);
-  if (!latestOperation) return document;
-  const documentOperations = garbageCollectDocumentOperations({
-    ...document.operations,
-    [scope]: skipHeaderOperations(
-      document.operations[scope],
-      latestOperation
-    )
-  });
-  let scopeState = void 0;
-  const lastRemainingOperation = documentOperations[scope].at(-1);
-  if (reuseOperationResultingState && (lastRemainingOperation == null ? void 0 : lastRemainingOperation.resultingState)) {
-    scopeState = resultingStateParser(lastRemainingOperation.resultingState);
-  } else {
-    const { state } = replayOperations(
-      document.initialState,
-      documentOperations,
-      customReducer,
-      void 0,
-      void 0,
-      void 0,
-      void 0,
-      {
-        reuseHash: true,
-        reuseOperationResultingState,
-        operationResultingStateParser: resultingStateParser
-      }
-    );
-    scopeState = state[scope];
-  }
-  return {
-    ...document,
-    state: {
-      ...document.state,
-      [scope]: scopeState
-    },
-    operations: garbageCollectDocumentOperations({
-      ...document.operations
-    })
-  };
-}
-function processUndoOperation(document, scope, customReducer, reuseOperationResultingState = false, resultingStateParser = parseResultingState) {
-  const operations = [...document.operations[scope]];
-  const sortedOperations = sortOperations$1(operations);
-  sortedOperations.pop();
-  const documentOperations = garbageCollectDocumentOperations({
-    ...document.operations
-  });
-  const clearedOperations = [...documentOperations[scope]];
-  const diff = diffOperations(
-    garbageCollect(sortedOperations),
-    clearedOperations
-  );
-  const doc = replayOperations(
-    document.initialState,
-    documentOperations,
-    customReducer,
-    void 0,
-    void 0,
-    void 0,
-    void 0,
-    {
-      reuseHash: true,
-      reuseOperationResultingState,
-      operationResultingStateParser: resultingStateParser
-    }
-  );
-  const clipboard = sortOperations$1(
-    [...document.clipboard, ...diff].filter((op) => op.type !== "NOOP")
-  ).reverse();
-  return { ...doc, clipboard };
-}
-function baseReducer(document, action, customReducer, dispatch, options = {}) {
-  const {
-    skip,
-    ignoreSkipOperations = false,
-    reuseHash = false,
-    reuseOperationResultingState = false,
-    operationResultingStateParser
-  } = options;
-  let _action = { ...action };
-  let skipValue = skip || 0;
-  let newDocument = { ...document };
-  let reuseLastOperationIndex = false;
-  const shouldProcessSkipOperation = !ignoreSkipOperations && (skipValue > 0 || "index" in _action && _action.skip > 0);
-  if (isUndoRedo(_action)) {
-    const {
-      skip: calculatedSkip,
-      action: transformedAction,
-      document: processedDocument,
-      reuseLastOperationIndex: reuseIndex
-    } = processUndoRedo(document, _action, skipValue);
-    _action = transformedAction;
-    skipValue = calculatedSkip;
-    newDocument = processedDocument;
-    reuseLastOperationIndex = reuseIndex;
-  } else {
-    newDocument = {
-      ...newDocument,
-      clipboard: []
-    };
-  }
-  if (isBaseAction(_action)) {
-    newDocument = _baseReducer(newDocument, _action, customReducer);
-  }
-  newDocument = updateDocument(
-    newDocument,
-    _action,
-    skipValue,
-    reuseLastOperationIndex
-  );
-  const isUndoAction = isUndo(action);
-  if (isUndoAction) {
-    const result = processUndoOperation(
-      newDocument,
-      action.scope,
-      customReducer
-    );
-    return result;
-  }
-  if (shouldProcessSkipOperation) {
-    newDocument = processSkipOperation(
-      newDocument,
-      _action,
-      customReducer,
-      skipValue,
-      reuseOperationResultingState,
-      operationResultingStateParser
-    );
-  }
-  newDocument = create(newDocument, (draft) => {
-    try {
-      const newState = customReducer(draft.state, _action, dispatch);
-      if (newState) {
-        unsafe(() => {
-          draft.state = castDraft(newState);
-        });
-      } else {
-      }
-    } catch (error) {
-      const lastOperationIndex = newDocument.operations[_action.scope].length - 1;
-      draft.operations[_action.scope][lastOperationIndex].error = error.message;
-      draft.operations[_action.scope][lastOperationIndex].skip = 0;
-      if (shouldProcessSkipOperation) {
-        draft.state = castDraft({ ...document.state });
-        draft.operations = castDraft({
-          ...document.operations,
-          [_action.scope]: [
-            ...document.operations[_action.scope],
-            {
-              ...draft.operations[_action.scope][lastOperationIndex]
-            }
-          ]
-        });
-      }
-    }
-  });
-  if ([UNDO, REDO, PRUNE].includes(_action.type)) {
-    return newDocument;
-  }
-  const scope = _action.scope || "global";
-  const hash2 = reuseHash && Object.prototype.hasOwnProperty.call(_action, "hash") ? _action.hash : hashDocument(newDocument, scope);
-  const lastOperation = newDocument.operations[scope].at(-1);
-  if (lastOperation) {
-    lastOperation.hash = hash2;
-    if (reuseOperationResultingState) {
-      lastOperation.resultingState = newDocument.state[scope];
-    }
-    if (!isBaseAction(_action) && _action.attachments) {
-      _action.attachments.forEach((attachment) => {
-        const { hash: hash22, ...file } = attachment;
-        newDocument.attachments[hash22] = {
-          ...file
-        };
-      });
-    }
-  }
-  return newDocument;
-}
-function mutableBaseReducer(document, action, customReducer, dispatch, options = {}) {
-  const {
-    skip,
-    ignoreSkipOperations = false,
-    reuseHash = false,
-    reuseOperationResultingState = false,
-    operationResultingStateParser
-  } = options;
-  const _action = { ...action };
-  const skipValue = skip || 0;
-  let newDocument = { ...document };
-  const shouldProcessSkipOperation = !ignoreSkipOperations && (skipValue > 0 || "index" in _action && _action.skip > 0);
-  if (isBaseAction(_action)) {
-    newDocument = _baseReducer(newDocument, _action, customReducer);
-  }
-  newDocument = updateDocument(newDocument, _action, skipValue);
-  if (shouldProcessSkipOperation) {
-    newDocument = processSkipOperation(
-      newDocument,
-      _action,
-      customReducer,
-      skipValue,
-      reuseOperationResultingState,
-      operationResultingStateParser
-    );
-  }
-  try {
-    const newState = customReducer(
-      newDocument.state,
-      _action,
-      dispatch
-    );
-    if (newState) {
-      newDocument.state = newState;
-    }
-  } catch (error) {
-    const lastOperationIndex = newDocument.operations[_action.scope].length - 1;
-    newDocument.operations[_action.scope][lastOperationIndex].error = error.message;
-    newDocument.operations[_action.scope][lastOperationIndex].skip = 0;
-    if (shouldProcessSkipOperation) {
-      newDocument.state = { ...document.state };
-      newDocument.operations = {
-        ...document.operations,
-        [_action.scope]: [
-          ...document.operations[_action.scope],
-          {
-            ...newDocument.operations[_action.scope][lastOperationIndex]
-          }
-        ]
-      };
-    }
-  }
-  if ([UNDO, REDO, PRUNE].includes(_action.type)) {
-    return newDocument;
-  }
-  const scope = _action.scope || "global";
-  const hash2 = reuseHash && Object.prototype.hasOwnProperty.call(_action, "hash") ? _action.hash : hashDocument(newDocument, scope);
-  const lastOperation = newDocument.operations[scope].at(-1);
-  if (lastOperation) {
-    lastOperation.hash = hash2;
-    if (reuseOperationResultingState) {
-      lastOperation.resultingState = newDocument.state[scope];
-    }
-    if (!isBaseAction(_action) && _action.attachments) {
-      _action.attachments.forEach((attachment) => {
-        const { hash: hash22, ...file } = attachment;
-        newDocument.attachments[hash22] = {
-          ...file
-        };
-      });
-    }
-  }
-  return newDocument;
-}
-function isNoopOperation(op) {
-  return op.type === NOOP && op.skip !== void 0 && op.skip > 0 && op.hash !== void 0;
-}
-function isUndoRedo(action) {
-  return [UNDO, REDO].includes(action.type);
-}
-function isUndo(action) {
-  return action.type === UNDO;
-}
-function isBaseAction(action) {
-  return [SET_NAME, UNDO, REDO, PRUNE, LOAD_STATE].includes(action.type);
-}
-function createAction(type, input, attachments, validator, scope = "global") {
-  if (!type) {
-    throw new Error("Empty action type");
-  }
-  if (typeof type !== "string") {
-    throw new Error(`Invalid action type: ${JSON.stringify(type)}`);
-  }
-  const action = { type, input, scope };
-  if (attachments) {
-    action.attachments = attachments;
-  }
-  try {
-    validator == null ? void 0 : validator().parse(action.input);
-  } catch (error) {
-    if (error instanceof ZodError) {
-      throw new InvalidActionInputZodError(error.issues);
-    } else {
-      throw new InvalidActionInputError(error);
-    }
-  }
-  return action;
-}
-function createReducer(reducer, documentReducer = baseReducer) {
-  return (document, action, dispatch, options) => {
-    return documentReducer(document, action, reducer, dispatch, options);
-  };
-}
-function createUnsafeReducer(reducer, documentReducer = mutableBaseReducer) {
-  return (document, action, dispatch, options) => {
-    return documentReducer(document, action, reducer, dispatch, options);
-  };
-}
-const createExtendedState = (initialState, createState) => {
-  return {
-    name: "",
-    documentType: "",
-    revision: {
-      global: 0,
-      local: 0
-    },
-    created: (/* @__PURE__ */ new Date()).toISOString(),
-    lastModified: (/* @__PURE__ */ new Date()).toISOString(),
-    attachments: {},
-    ...initialState,
-    state: (createState == null ? void 0 : createState(initialState == null ? void 0 : initialState.state)) ?? ((initialState == null ? void 0 : initialState.state) ?? { global: {}, local: {} })
-  };
-};
-const createDocument = (initialState, createState) => {
-  const state = createExtendedState(
-    initialState,
-    createState
-  );
-  return {
-    ...state,
-    initialState: state,
-    operations: { global: [], local: [] },
-    clipboard: []
-  };
-};
-const hashDocument = (document, scope = "global") => {
-  return hash(cjsModule(document.state[scope] || ""));
-};
-const hashKey = (date, randomLimit = 1e3) => {
-  const random = Math.random() * randomLimit;
-  return hash(`${(date ?? /* @__PURE__ */ new Date()).toISOString()}${random}`);
-};
-function readOnly(value) {
-  return Object.freeze(value);
-}
-function mapSkippedOperations(operations, skippedHeadOperations) {
-  const ops = [...operations];
-  let skipped = skippedHeadOperations || 0;
-  let latestOpIndex = ops.length > 0 ? ops[ops.length - 1].index : 0;
-  const scopeOpsWithIgnore = [];
-  for (const operation of ops.reverse()) {
-    if (skipped > 0) {
-      const operationsDiff = latestOpIndex - operation.index;
-      skipped -= operationsDiff;
-    }
-    if (skipped < 0) {
-      throw new Error("Invalid operation index, missing operations");
-    }
-    const mappedOp = {
-      ignore: skipped > 0,
-      operation
-    };
-    const operationSkip = operation.skip > 0 ? operation.skip + 1 : 0;
-    if (operationSkip > 0 && operationSkip > skipped) {
-      const skipDiff = operationSkip - skipped;
-      skipped = skipped + skipDiff;
-    }
-    latestOpIndex = operation.index;
-    scopeOpsWithIgnore.push(mappedOp);
-  }
-  return scopeOpsWithIgnore.reverse();
-}
-function sortOperations(operations) {
-  return Object.values(operations).flatMap((array) => array).sort(
-    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
-  );
-}
-function sortMappedOperations(operations) {
-  return Object.values(operations).flatMap((array) => array).sort(
-    (a, b) => new Date(a.operation.timestamp).getTime() - new Date(b.operation.timestamp).getTime()
-  );
-}
-function getDocumentLastModified(document) {
-  var _a;
-  const sortedOperations = sortOperations(document.operations);
-  const timestamp = ((_a = sortedOperations.at(-1)) == null ? void 0 : _a.timestamp) || document.initialState.lastModified;
-  return timestamp;
-}
-function replayOperations(initialState, clearedOperations, reducer, dispatch, header, documentReducer = baseReducer, skipHeaderOperations2 = {}, options) {
-  const wrappedReducer = createReducer(reducer, documentReducer);
-  return replayDocument(
-    initialState,
-    clearedOperations,
-    wrappedReducer,
-    dispatch,
-    header,
-    skipHeaderOperations2,
-    options
-  );
-}
-function replayDocument(initialState, operations, reducer, dispatch, header, skipHeaderOperations2 = {}, options) {
-  const {
-    checkHashes = true,
-    reuseOperationResultingState,
-    operationResultingStateParser = parseResultingState
-  } = options || {};
-  let documentState = initialState;
-  const operationsToReplay = [];
-  const initialOperations = {
-    global: [],
-    local: []
-  };
-  if (reuseOperationResultingState) {
-    for (const [scope, scopeOperations] of Object.entries(operations)) {
-      const index = scopeOperations.findLastIndex((s) => !!s.resultingState);
-      if (index < 0) {
-        operationsToReplay.push(...scopeOperations);
-        continue;
-      }
-      const opWithState = scopeOperations[index];
-      try {
-        const scopeState = operationResultingStateParser(
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-unnecessary-type-assertion
-          opWithState.resultingState
-        );
-        documentState = {
-          ...documentState,
-          state: {
-            ...documentState.state,
-            // TODO how to deal with attachments?
-            [scope]: scopeState
-          }
-        };
-        initialOperations[scope].push(
-          ...scopeOperations.slice(0, index + 1)
-        );
-        operationsToReplay.push(...scopeOperations.slice(index + 1));
-      } catch {
-        operationsToReplay.push(...scopeOperations);
-      }
-    }
-  } else {
-    operationsToReplay.push(...Object.values(operations).flat());
-  }
-  const document = createDocument(documentState);
-  document.initialState = initialState;
-  document.operations = initialOperations;
-  let result = document;
-  if (operationsToReplay.length) {
-    result = operationsToReplay.reduce((document2, operation) => {
-      const doc = reducer(document2, operation, dispatch, {
-        skip: operation.skip,
-        ignoreSkipOperations: true,
-        reuseHash: !checkHashes
-      });
-      return doc;
-    }, document);
-  } else {
-    for (const scopeOperations of Object.values(initialOperations)) {
-      const lastOperation = scopeOperations.at(-1);
-      if (lastOperation) {
-        result = updateHeader(result, lastOperation);
-      }
-    }
-  }
-  if (!checkHashes) {
-    for (const scope of Object.keys(result.state)) {
-      for (let i = operationsToReplay.length - 1; i >= 0; i--) {
-        const operation = operationsToReplay[i];
-        if (operation.scope !== scope) {
-          continue;
-        }
-        if (operation.hash !== hashDocument(result, scope)) {
-          throw new Error(`Hash mismatch for scope ${scope}`);
-        } else {
-          break;
-        }
-      }
-    }
-  }
-  const resultOperations = Object.keys(
-    result.operations
-  ).reduce(
-    (acc, key) => {
-      const scope = key;
-      return {
-        ...acc,
-        [scope]: [
-          ...result.operations[scope].map((operation, index) => {
-            var _a;
-            return {
-              ...operation,
-              timestamp: ((_a = operations[scope][index]) == null ? void 0 : _a.timestamp) ?? operation.timestamp
-            };
-          })
-        ]
-      };
-    },
-    { global: [], local: [] }
-  );
-  const lastModified = Object.values(resultOperations).reduce((acc, curr) => {
-    const operation = curr.at(-1);
-    if (operation && operation.timestamp > acc) {
-      acc = operation.timestamp;
-    }
-    return acc;
-  }, initialState.lastModified);
-  return { ...result, operations: resultOperations, lastModified };
-}
-function isSameDocument(documentA, documentB) {
-  return cjsModule(documentA) === cjsModule(documentB);
-}
-function parseResultingState(state) {
-  const stateType = typeof state;
-  if (stateType === "string") {
-    return JSON.parse(state);
-  } else if (stateType === "object") {
-    return state;
-  } else {
-    throw new Error(`Providing resulting state is of type: ${stateType}`);
-  }
-}
-const setName = (name) => createAction(
-  "SET_NAME",
-  name,
-  void 0,
-  SetNameActionInputSchema,
-  void 0
-);
-const undo = (skip = 1, scope = "global") => createAction(
-  "UNDO",
-  skip,
-  void 0,
-  UndoActionInputSchema,
-  scope
-);
-const redo = (count = 1, scope = "global") => createAction(
-  "REDO",
-  count,
-  void 0,
-  RedoActionInputSchema,
-  scope
-);
-const prune = (start, end, scope = "global") => createAction(
-  "PRUNE",
-  { start, end },
-  void 0,
-  PruneActionInputSchema,
-  scope
-);
-const loadState = (state, operations) => createAction(
-  "LOAD_STATE",
-  { state, operations },
-  void 0,
-  LoadStateActionInputSchema
-);
-const noop = (scope = "global") => createAction("NOOP", {}, void 0, void 0, scope);
-const BaseActions = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  loadState,
-  noop,
-  prune,
-  redo,
-  setName,
-  undo
-}, Symbol.toStringTag, { value: "Module" }));
-export {
-  buildSignedOperation as A,
-  BaseActions as B,
-  createUnsafeReducer as C,
-  createZip as D,
-  documentHelpers as E,
-  generateId as F,
-  getDocumentLastModified as G,
-  getLocalFile as H,
-  InvalidActionInputError as I,
-  getRemoteFile as J,
-  getUnixTimestamp as K,
-  hashDocument as L,
-  hashKey as M,
-  hex2ab as N,
-  isNoopOperation as O,
-  isSameDocument as P,
-  isUndo as Q,
-  isUndoRedo as R,
-  mapSkippedOperations as S,
-  parseResultingState as T,
-  replayDocument as U,
-  replayOperations as V,
-  sortMappedOperations as W,
-  sortOperations as X,
-  validateOperations as Y,
-  verifyOperationSignature as Z,
-  createExtendedState as a,
-  createDocument as b,
-  createReducer as c,
-  saveToFileHandle as d,
-  loadFromInput as e,
-  createAction as f,
-  baseReducer as g,
-  updateHeader as h,
-  isBaseAction as i,
-  setName as j,
-  undo as k,
-  loadFromFile as l,
-  mutableBaseReducer as m,
-  redo as n,
-  prune as o,
-  processUndoRedo as p,
-  loadState as q,
-  readOnly as r,
-  saveToFile as s,
-  InvalidActionInputZodError as t,
-  updateDocument as u,
-  ab2hex as v,
-  buildOperationSignature as w,
-  buildOperationSignatureMessage as x,
-  buildOperationSignatureParams as y,
-  zod as z
-};
-//# sourceMappingURL=creators-0lHfLHX0.js.map