document-model 1.0.55 → 1.1.0-debug.2

package/dist/browser/es/internal/object-9mR1JlXD.js

@@ -0,0 +1,4110 @@
+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);
+  return value;
+};
+import { produce, castDraft, castImmutable, freeze } from "immer";
+import { z } from "zod";
+import JSZip from "jszip";
+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: {} };
+(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]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/;
+  function strEscape(str) {
+    if (str.length < 5e3 && !strEscapeSequencesRegExp.test(str)) {
+      return `"${str}"`;
+    }
+    return JSON.stringify(str);
+  }
+  function insertSort(array) {
+    if (array.length > 200) {
+      return array.sort();
+    }
+    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 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 = getBooleanOption(options, "deterministic");
+    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 join = ",";
+          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}`;
+              join = `,
+${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 += join;
+            }
+            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 += `${join}"... ${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;
+            join = `,
+${indentation}`;
+            whitespace = " ";
+          }
+          const maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+          if (deterministic && !isTypedArrayWithEntries(value)) {
+            keys = insertSort(keys);
+          }
+          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 = join;
+            }
+          }
+          if (keyLength > maximumBreadth) {
+            const removedKeys = keyLength - maximumBreadth;
+            res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
+            separator = join;
+          }
+          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);
+          }
+        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 join = ",";
+          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}`;
+              join = `,
+${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 += join;
+            }
+            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 += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+            }
+            if (spacer !== "") {
+              res += `
+${originalIndentation}`;
+            }
+            stack.pop();
+            return `[${res}]`;
+          }
+          stack.push(value);
+          let whitespace = "";
+          if (spacer !== "") {
+            indentation += spacer;
+            join = `,
+${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 = join;
+            }
+          }
+          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);
+          }
+        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 join2 = `,
+${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 += join2;
+            }
+            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 += `${join2}"... ${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 join = `,
+${indentation}`;
+          let res = "";
+          let separator = "";
+          let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+          if (isTypedArrayWithEntries(value)) {
+            res += stringifyTypedArray(value, join, maximumBreadth);
+            keys = keys.slice(value.length);
+            maximumPropertiesToStringify -= value.length;
+            separator = join;
+          }
+          if (deterministic) {
+            keys = insertSort(keys);
+          }
+          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 = join;
+            }
+          }
+          if (keyLength > maximumBreadth) {
+            const removedKeys = keyLength - maximumBreadth;
+            res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
+            separator = join;
+          }
+          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);
+          }
+        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 = "";
+          if (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 (isTypedArrayWithEntries(value)) {
+            res += stringifyTypedArray(value, ",", maximumBreadth);
+            keys = keys.slice(value.length);
+            maximumPropertiesToStringify -= value.length;
+            separator = ",";
+          }
+          if (deterministic) {
+            keys = insertSort(keys);
+          }
+          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);
+          }
+        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);
+var safeStableStringifyExports = safeStableStringify.exports;
+const cjsModule = /* @__PURE__ */ getDefaultExportFromCjs(safeStableStringifyExports);
+cjsModule.configure;
+function setNameOperation(document, name) {
+  return { ...document, name };
+}
+function undoOperation(document, action, skip) {
+  const { scope, input } = action;
+  const defaultResult = {
+    document,
+    action,
+    skip
+  };
+  return produce(defaultResult, (draft) => {
+    if (draft.document.operations[scope].length < 1) {
+      throw new Error(
+        `Cannot undo: no operations in history for scope "${scope}"`
+      );
+    }
+    if (input < 1) {
+      throw new Error(
+        `Invalid UNDO action: input value must be greater than 0`
+      );
+    }
+    if (draft.skip > 0) {
+      throw new Error(
+        `Cannot undo: skip value from reducer cannot be used with UNDO action`
+      );
+    }
+    const lastOperation = draft.document.operations[scope].at(-1);
+    const isLatestOpNOOP = lastOperation && lastOperation.type === "NOOP" && lastOperation.skip > 0;
+    draft.skip += input;
+    if (isLatestOpNOOP) {
+      draft.skip += lastOperation.skip;
+      const preLastOperation = draft.document.operations[scope][draft.document.operations[scope].length - 2];
+      if (preLastOperation && lastOperation.index - preLastOperation.index === 1) {
+        draft.document.operations[scope].pop();
+      }
+    }
+    if (draft.document.operations[scope].length < draft.skip) {
+      throw new Error(
+        `Cannot undo: you can't undo more operations than the ones in the scope history`
+      );
+    }
+    const operationsLastIndex = draft.document.operations[scope].length - 1;
+    let skippedOpsLeft = input;
+    let index = isLatestOpNOOP ? operationsLastIndex - lastOperation.skip : operationsLastIndex;
+    while (skippedOpsLeft > 0 && index >= 0) {
+      const op = draft.document.operations[scope][index];
+      if (!op) {
+        skippedOpsLeft--;
+        index--;
+        continue;
+      }
+      if (op.type === "NOOP" && op.skip > 0) {
+        index = index - (op.skip + 1);
+        draft.skip += op.skip + 1;
+      } else {
+        draft.document.clipboard.push({ ...op });
+        skippedOpsLeft--;
+        index--;
+      }
+    }
+    draft.action = noop(scope);
+  });
+}
+function redoOperation(document, action, skip) {
+  const { scope, input } = action;
+  const defaultResult = {
+    document,
+    action,
+    skip
+  };
+  return produce(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";
+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/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"], "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();
+var inherits_browser = { exports: {} };
+if (typeof Object.create === "function") {
+  inherits_browser.exports = function inherits2(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor;
+      ctor.prototype = Object.create(superCtor.prototype, {
+        constructor: {
+          value: ctor,
+          enumerable: false,
+          writable: true,
+          configurable: true
+        }
+      });
+    }
+  };
+} else {
+  inherits_browser.exports = function inherits2(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor;
+      var TempCtor = function() {
+      };
+      TempCtor.prototype = superCtor.prototype;
+      ctor.prototype = new TempCtor();
+      ctor.prototype.constructor = ctor;
+    }
+  };
+}
+var inherits_browserExports = inherits_browser.exports;
+var safeBuffer = { exports: {} };
+var buffer = {};
+var base64Js = {};
+base64Js.byteLength = byteLength;
+base64Js.toByteArray = toByteArray;
+base64Js.fromByteArray = fromByteArray;
+var lookup = [];
+var revLookup = [];
+var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i];
+  revLookup[code.charCodeAt(i)] = i;
+}
+revLookup["-".charCodeAt(0)] = 62;
+revLookup["_".charCodeAt(0)] = 63;
+function getLens(b64) {
+  var len = b64.length;
+  if (len % 4 > 0) {
+    throw new Error("Invalid string. Length must be a multiple of 4");
+  }
+  var validLen = b64.indexOf("=");
+  if (validLen === -1)
+    validLen = len;
+  var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
+  return [validLen, placeHoldersLen];
+}
+function byteLength(b64) {
+  var lens = getLens(b64);
+  var validLen = lens[0];
+  var placeHoldersLen = lens[1];
+  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+}
+function _byteLength(b64, validLen, placeHoldersLen) {
+  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+}
+function toByteArray(b64) {
+  var tmp;
+  var lens = getLens(b64);
+  var validLen = lens[0];
+  var placeHoldersLen = lens[1];
+  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+  var curByte = 0;
+  var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+  var i;
+  for (i = 0; i < len; i += 4) {
+    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
+    arr[curByte++] = tmp >> 16 & 255;
+    arr[curByte++] = tmp >> 8 & 255;
+    arr[curByte++] = tmp & 255;
+  }
+  if (placeHoldersLen === 2) {
+    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
+    arr[curByte++] = tmp & 255;
+  }
+  if (placeHoldersLen === 1) {
+    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
+    arr[curByte++] = tmp >> 8 & 255;
+    arr[curByte++] = tmp & 255;
+  }
+  return arr;
+}
+function tripletToBase64(num) {
+  return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+}
+function encodeChunk(uint8, start, end) {
+  var tmp;
+  var output = [];
+  for (var i = start; i < end; i += 3) {
+    tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
+    output.push(tripletToBase64(tmp));
+  }
+  return output.join("");
+}
+function fromByteArray(uint8) {
+  var tmp;
+  var len = uint8.length;
+  var extraBytes = len % 3;
+  var parts = [];
+  var maxChunkLength = 16383;
+  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+  }
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1];
+    parts.push(
+      lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "=="
+    );
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+    parts.push(
+      lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
+    );
+  }
+  return parts.join("");
+}
+var ieee754 = {};
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+ieee754.read = function(buffer2, offset, isLE, mLen, nBytes) {
+  var e, m;
+  var eLen = nBytes * 8 - mLen - 1;
+  var eMax = (1 << eLen) - 1;
+  var eBias = eMax >> 1;
+  var nBits = -7;
+  var i = isLE ? nBytes - 1 : 0;
+  var d = isLE ? -1 : 1;
+  var s = buffer2[offset + i];
+  i += d;
+  e = s & (1 << -nBits) - 1;
+  s >>= -nBits;
+  nBits += eLen;
+  for (; nBits > 0; e = e * 256 + buffer2[offset + i], i += d, nBits -= 8) {
+  }
+  m = e & (1 << -nBits) - 1;
+  e >>= -nBits;
+  nBits += mLen;
+  for (; nBits > 0; m = m * 256 + buffer2[offset + i], i += d, nBits -= 8) {
+  }
+  if (e === 0) {
+    e = 1 - eBias;
+  } else if (e === eMax) {
+    return m ? NaN : (s ? -1 : 1) * Infinity;
+  } else {
+    m = m + Math.pow(2, mLen);
+    e = e - eBias;
+  }
+  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+};
+ieee754.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
+  var e, m, c;
+  var eLen = nBytes * 8 - mLen - 1;
+  var eMax = (1 << eLen) - 1;
+  var eBias = eMax >> 1;
+  var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+  var i = isLE ? 0 : nBytes - 1;
+  var d = isLE ? 1 : -1;
+  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+  value = Math.abs(value);
+  if (isNaN(value) || value === Infinity) {
+    m = isNaN(value) ? 1 : 0;
+    e = eMax;
+  } else {
+    e = Math.floor(Math.log(value) / Math.LN2);
+    if (value * (c = Math.pow(2, -e)) < 1) {
+      e--;
+      c *= 2;
+    }
+    if (e + eBias >= 1) {
+      value += rt / c;
+    } else {
+      value += rt * Math.pow(2, 1 - eBias);
+    }
+    if (value * c >= 2) {
+      e++;
+      c /= 2;
+    }
+    if (e + eBias >= eMax) {
+      m = 0;
+      e = eMax;
+    } else if (e + eBias >= 1) {
+      m = (value * c - 1) * Math.pow(2, mLen);
+      e = e + eBias;
+    } else {
+      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+      e = 0;
+    }
+  }
+  for (; mLen >= 8; buffer2[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
+  }
+  e = e << mLen | m;
+  eLen += mLen;
+  for (; eLen > 0; buffer2[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+  }
+  buffer2[offset + i - d] |= s * 128;
+};
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+(function(exports) {
+  var base64 = base64Js;
+  var ieee754$1 = ieee754;
+  var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+  exports.Buffer = Buffer3;
+  exports.SlowBuffer = SlowBuffer;
+  exports.INSPECT_MAX_BYTES = 50;
+  var K_MAX_LENGTH = 2147483647;
+  exports.kMaxLength = K_MAX_LENGTH;
+  Buffer3.TYPED_ARRAY_SUPPORT = typedArraySupport();
+  if (!Buffer3.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
+    console.error(
+      "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+    );
+  }
+  function typedArraySupport() {
+    try {
+      var arr = new Uint8Array(1);
+      var proto = { foo: function() {
+        return 42;
+      } };
+      Object.setPrototypeOf(proto, Uint8Array.prototype);
+      Object.setPrototypeOf(arr, proto);
+      return arr.foo() === 42;
+    } catch (e) {
+      return false;
+    }
+  }
+  Object.defineProperty(Buffer3.prototype, "parent", {
+    enumerable: true,
+    get: function() {
+      if (!Buffer3.isBuffer(this))
+        return void 0;
+      return this.buffer;
+    }
+  });
+  Object.defineProperty(Buffer3.prototype, "offset", {
+    enumerable: true,
+    get: function() {
+      if (!Buffer3.isBuffer(this))
+        return void 0;
+      return this.byteOffset;
+    }
+  });
+  function createBuffer(length) {
+    if (length > K_MAX_LENGTH) {
+      throw new RangeError('The value "' + length + '" is invalid for option "size"');
+    }
+    var buf = new Uint8Array(length);
+    Object.setPrototypeOf(buf, Buffer3.prototype);
+    return buf;
+  }
+  function Buffer3(arg, encodingOrOffset, length) {
+    if (typeof arg === "number") {
+      if (typeof encodingOrOffset === "string") {
+        throw new TypeError(
+          'The "string" argument must be of type string. Received type number'
+        );
+      }
+      return allocUnsafe(arg);
+    }
+    return from(arg, encodingOrOffset, length);
+  }
+  Buffer3.poolSize = 8192;
+  function from(value, encodingOrOffset, length) {
+    if (typeof value === "string") {
+      return fromString(value, encodingOrOffset);
+    }
+    if (ArrayBuffer.isView(value)) {
+      return fromArrayView(value);
+    }
+    if (value == null) {
+      throw new TypeError(
+        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+      );
+    }
+    if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
+      return fromArrayBuffer(value, encodingOrOffset, length);
+    }
+    if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
+      return fromArrayBuffer(value, encodingOrOffset, length);
+    }
+    if (typeof value === "number") {
+      throw new TypeError(
+        'The "value" argument must not be of type number. Received type number'
+      );
+    }
+    var valueOf = value.valueOf && value.valueOf();
+    if (valueOf != null && valueOf !== value) {
+      return Buffer3.from(valueOf, encodingOrOffset, length);
+    }
+    var b = fromObject(value);
+    if (b)
+      return b;
+    if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+      return Buffer3.from(
+        value[Symbol.toPrimitive]("string"),
+        encodingOrOffset,
+        length
+      );
+    }
+    throw new TypeError(
+      "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+    );
+  }
+  Buffer3.from = function(value, encodingOrOffset, length) {
+    return from(value, encodingOrOffset, length);
+  };
+  Object.setPrototypeOf(Buffer3.prototype, Uint8Array.prototype);
+  Object.setPrototypeOf(Buffer3, Uint8Array);
+  function assertSize(size) {
+    if (typeof size !== "number") {
+      throw new TypeError('"size" argument must be of type number');
+    } else if (size < 0) {
+      throw new RangeError('The value "' + size + '" is invalid for option "size"');
+    }
+  }
+  function alloc(size, fill, encoding) {
+    assertSize(size);
+    if (size <= 0) {
+      return createBuffer(size);
+    }
+    if (fill !== void 0) {
+      return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+    }
+    return createBuffer(size);
+  }
+  Buffer3.alloc = function(size, fill, encoding) {
+    return alloc(size, fill, encoding);
+  };
+  function allocUnsafe(size) {
+    assertSize(size);
+    return createBuffer(size < 0 ? 0 : checked(size) | 0);
+  }
+  Buffer3.allocUnsafe = function(size) {
+    return allocUnsafe(size);
+  };
+  Buffer3.allocUnsafeSlow = function(size) {
+    return allocUnsafe(size);
+  };
+  function fromString(string, encoding) {
+    if (typeof encoding !== "string" || encoding === "") {
+      encoding = "utf8";
+    }
+    if (!Buffer3.isEncoding(encoding)) {
+      throw new TypeError("Unknown encoding: " + encoding);
+    }
+    var length = byteLength2(string, encoding) | 0;
+    var buf = createBuffer(length);
+    var actual = buf.write(string, encoding);
+    if (actual !== length) {
+      buf = buf.slice(0, actual);
+    }
+    return buf;
+  }
+  function fromArrayLike(array) {
+    var length = array.length < 0 ? 0 : checked(array.length) | 0;
+    var buf = createBuffer(length);
+    for (var i = 0; i < length; i += 1) {
+      buf[i] = array[i] & 255;
+    }
+    return buf;
+  }
+  function fromArrayView(arrayView) {
+    if (isInstance(arrayView, Uint8Array)) {
+      var copy = new Uint8Array(arrayView);
+      return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+    }
+    return fromArrayLike(arrayView);
+  }
+  function fromArrayBuffer(array, byteOffset, length) {
+    if (byteOffset < 0 || array.byteLength < byteOffset) {
+      throw new RangeError('"offset" is outside of buffer bounds');
+    }
+    if (array.byteLength < byteOffset + (length || 0)) {
+      throw new RangeError('"length" is outside of buffer bounds');
+    }
+    var buf;
+    if (byteOffset === void 0 && length === void 0) {
+      buf = new Uint8Array(array);
+    } else if (length === void 0) {
+      buf = new Uint8Array(array, byteOffset);
+    } else {
+      buf = new Uint8Array(array, byteOffset, length);
+    }
+    Object.setPrototypeOf(buf, Buffer3.prototype);
+    return buf;
+  }
+  function fromObject(obj) {
+    if (Buffer3.isBuffer(obj)) {
+      var len = checked(obj.length) | 0;
+      var buf = createBuffer(len);
+      if (buf.length === 0) {
+        return buf;
+      }
+      obj.copy(buf, 0, 0, len);
+      return buf;
+    }
+    if (obj.length !== void 0) {
+      if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+        return createBuffer(0);
+      }
+      return fromArrayLike(obj);
+    }
+    if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+      return fromArrayLike(obj.data);
+    }
+  }
+  function checked(length) {
+    if (length >= K_MAX_LENGTH) {
+      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
+    }
+    return length | 0;
+  }
+  function SlowBuffer(length) {
+    if (+length != length) {
+      length = 0;
+    }
+    return Buffer3.alloc(+length);
+  }
+  Buffer3.isBuffer = function isBuffer(b) {
+    return b != null && b._isBuffer === true && b !== Buffer3.prototype;
+  };
+  Buffer3.compare = function compare(a, b) {
+    if (isInstance(a, Uint8Array))
+      a = Buffer3.from(a, a.offset, a.byteLength);
+    if (isInstance(b, Uint8Array))
+      b = Buffer3.from(b, b.offset, b.byteLength);
+    if (!Buffer3.isBuffer(a) || !Buffer3.isBuffer(b)) {
+      throw new TypeError(
+        'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+      );
+    }
+    if (a === b)
+      return 0;
+    var x = a.length;
+    var y = b.length;
+    for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+      if (a[i] !== b[i]) {
+        x = a[i];
+        y = b[i];
+        break;
+      }
+    }
+    if (x < y)
+      return -1;
+    if (y < x)
+      return 1;
+    return 0;
+  };
+  Buffer3.isEncoding = function isEncoding(encoding) {
+    switch (String(encoding).toLowerCase()) {
+      case "hex":
+      case "utf8":
+      case "utf-8":
+      case "ascii":
+      case "latin1":
+      case "binary":
+      case "base64":
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+        return true;
+      default:
+        return false;
+    }
+  };
+  Buffer3.concat = function concat(list, length) {
+    if (!Array.isArray(list)) {
+      throw new TypeError('"list" argument must be an Array of Buffers');
+    }
+    if (list.length === 0) {
+      return Buffer3.alloc(0);
+    }
+    var i;
+    if (length === void 0) {
+      length = 0;
+      for (i = 0; i < list.length; ++i) {
+        length += list[i].length;
+      }
+    }
+    var buffer2 = Buffer3.allocUnsafe(length);
+    var pos = 0;
+    for (i = 0; i < list.length; ++i) {
+      var buf = list[i];
+      if (isInstance(buf, Uint8Array)) {
+        if (pos + buf.length > buffer2.length) {
+          Buffer3.from(buf).copy(buffer2, pos);
+        } else {
+          Uint8Array.prototype.set.call(
+            buffer2,
+            buf,
+            pos
+          );
+        }
+      } else if (!Buffer3.isBuffer(buf)) {
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      } else {
+        buf.copy(buffer2, pos);
+      }
+      pos += buf.length;
+    }
+    return buffer2;
+  };
+  function byteLength2(string, encoding) {
+    if (Buffer3.isBuffer(string)) {
+      return string.length;
+    }
+    if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+      return string.byteLength;
+    }
+    if (typeof string !== "string") {
+      throw new TypeError(
+        'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
+      );
+    }
+    var len = string.length;
+    var mustMatch = arguments.length > 2 && arguments[2] === true;
+    if (!mustMatch && len === 0)
+      return 0;
+    var loweredCase = false;
+    for (; ; ) {
+      switch (encoding) {
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return len;
+        case "utf8":
+        case "utf-8":
+          return utf8ToBytes(string).length;
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return len * 2;
+        case "hex":
+          return len >>> 1;
+        case "base64":
+          return base64ToBytes(string).length;
+        default:
+          if (loweredCase) {
+            return mustMatch ? -1 : utf8ToBytes(string).length;
+          }
+          encoding = ("" + encoding).toLowerCase();
+          loweredCase = true;
+      }
+    }
+  }
+  Buffer3.byteLength = byteLength2;
+  function slowToString(encoding, start, end) {
+    var loweredCase = false;
+    if (start === void 0 || start < 0) {
+      start = 0;
+    }
+    if (start > this.length) {
+      return "";
+    }
+    if (end === void 0 || end > this.length) {
+      end = this.length;
+    }
+    if (end <= 0) {
+      return "";
+    }
+    end >>>= 0;
+    start >>>= 0;
+    if (end <= start) {
+      return "";
+    }
+    if (!encoding)
+      encoding = "utf8";
+    while (true) {
+      switch (encoding) {
+        case "hex":
+          return hexSlice(this, start, end);
+        case "utf8":
+        case "utf-8":
+          return utf8Slice(this, start, end);
+        case "ascii":
+          return asciiSlice(this, start, end);
+        case "latin1":
+        case "binary":
+          return latin1Slice(this, start, end);
+        case "base64":
+          return base64Slice(this, start, end);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return utf16leSlice(this, start, end);
+        default:
+          if (loweredCase)
+            throw new TypeError("Unknown encoding: " + encoding);
+          encoding = (encoding + "").toLowerCase();
+          loweredCase = true;
+      }
+    }
+  }
+  Buffer3.prototype._isBuffer = true;
+  function swap(b, n, m) {
+    var i = b[n];
+    b[n] = b[m];
+    b[m] = i;
+  }
+  Buffer3.prototype.swap16 = function swap16() {
+    var len = this.length;
+    if (len % 2 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 16-bits");
+    }
+    for (var i = 0; i < len; i += 2) {
+      swap(this, i, i + 1);
+    }
+    return this;
+  };
+  Buffer3.prototype.swap32 = function swap32() {
+    var len = this.length;
+    if (len % 4 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 32-bits");
+    }
+    for (var i = 0; i < len; i += 4) {
+      swap(this, i, i + 3);
+      swap(this, i + 1, i + 2);
+    }
+    return this;
+  };
+  Buffer3.prototype.swap64 = function swap64() {
+    var len = this.length;
+    if (len % 8 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 64-bits");
+    }
+    for (var i = 0; i < len; i += 8) {
+      swap(this, i, i + 7);
+      swap(this, i + 1, i + 6);
+      swap(this, i + 2, i + 5);
+      swap(this, i + 3, i + 4);
+    }
+    return this;
+  };
+  Buffer3.prototype.toString = function toString() {
+    var length = this.length;
+    if (length === 0)
+      return "";
+    if (arguments.length === 0)
+      return utf8Slice(this, 0, length);
+    return slowToString.apply(this, arguments);
+  };
+  Buffer3.prototype.toLocaleString = Buffer3.prototype.toString;
+  Buffer3.prototype.equals = function equals(b) {
+    if (!Buffer3.isBuffer(b))
+      throw new TypeError("Argument must be a Buffer");
+    if (this === b)
+      return true;
+    return Buffer3.compare(this, b) === 0;
+  };
+  Buffer3.prototype.inspect = function inspect() {
+    var str = "";
+    var max = exports.INSPECT_MAX_BYTES;
+    str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
+    if (this.length > max)
+      str += " ... ";
+    return "<Buffer " + str + ">";
+  };
+  if (customInspectSymbol) {
+    Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect;
+  }
+  Buffer3.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+    if (isInstance(target, Uint8Array)) {
+      target = Buffer3.from(target, target.offset, target.byteLength);
+    }
+    if (!Buffer3.isBuffer(target)) {
+      throw new TypeError(
+        'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
+      );
+    }
+    if (start === void 0) {
+      start = 0;
+    }
+    if (end === void 0) {
+      end = target ? target.length : 0;
+    }
+    if (thisStart === void 0) {
+      thisStart = 0;
+    }
+    if (thisEnd === void 0) {
+      thisEnd = this.length;
+    }
+    if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+      throw new RangeError("out of range index");
+    }
+    if (thisStart >= thisEnd && start >= end) {
+      return 0;
+    }
+    if (thisStart >= thisEnd) {
+      return -1;
+    }
+    if (start >= end) {
+      return 1;
+    }
+    start >>>= 0;
+    end >>>= 0;
+    thisStart >>>= 0;
+    thisEnd >>>= 0;
+    if (this === target)
+      return 0;
+    var x = thisEnd - thisStart;
+    var y = end - start;
+    var len = Math.min(x, y);
+    var thisCopy = this.slice(thisStart, thisEnd);
+    var targetCopy = target.slice(start, end);
+    for (var i = 0; i < len; ++i) {
+      if (thisCopy[i] !== targetCopy[i]) {
+        x = thisCopy[i];
+        y = targetCopy[i];
+        break;
+      }
+    }
+    if (x < y)
+      return -1;
+    if (y < x)
+      return 1;
+    return 0;
+  };
+  function bidirectionalIndexOf(buffer2, val, byteOffset, encoding, dir) {
+    if (buffer2.length === 0)
+      return -1;
+    if (typeof byteOffset === "string") {
+      encoding = byteOffset;
+      byteOffset = 0;
+    } else if (byteOffset > 2147483647) {
+      byteOffset = 2147483647;
+    } else if (byteOffset < -2147483648) {
+      byteOffset = -2147483648;
+    }
+    byteOffset = +byteOffset;
+    if (numberIsNaN(byteOffset)) {
+      byteOffset = dir ? 0 : buffer2.length - 1;
+    }
+    if (byteOffset < 0)
+      byteOffset = buffer2.length + byteOffset;
+    if (byteOffset >= buffer2.length) {
+      if (dir)
+        return -1;
+      else
+        byteOffset = buffer2.length - 1;
+    } else if (byteOffset < 0) {
+      if (dir)
+        byteOffset = 0;
+      else
+        return -1;
+    }
+    if (typeof val === "string") {
+      val = Buffer3.from(val, encoding);
+    }
+    if (Buffer3.isBuffer(val)) {
+      if (val.length === 0) {
+        return -1;
+      }
+      return arrayIndexOf(buffer2, val, byteOffset, encoding, dir);
+    } else if (typeof val === "number") {
+      val = val & 255;
+      if (typeof Uint8Array.prototype.indexOf === "function") {
+        if (dir) {
+          return Uint8Array.prototype.indexOf.call(buffer2, val, byteOffset);
+        } else {
+          return Uint8Array.prototype.lastIndexOf.call(buffer2, val, byteOffset);
+        }
+      }
+      return arrayIndexOf(buffer2, [val], byteOffset, encoding, dir);
+    }
+    throw new TypeError("val must be string, number or Buffer");
+  }
+  function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+    var indexSize = 1;
+    var arrLength = arr.length;
+    var valLength = val.length;
+    if (encoding !== void 0) {
+      encoding = String(encoding).toLowerCase();
+      if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+        if (arr.length < 2 || val.length < 2) {
+          return -1;
+        }
+        indexSize = 2;
+        arrLength /= 2;
+        valLength /= 2;
+        byteOffset /= 2;
+      }
+    }
+    function read(buf, i2) {
+      if (indexSize === 1) {
+        return buf[i2];
+      } else {
+        return buf.readUInt16BE(i2 * indexSize);
+      }
+    }
+    var i;
+    if (dir) {
+      var foundIndex = -1;
+      for (i = byteOffset; i < arrLength; i++) {
+        if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+          if (foundIndex === -1)
+            foundIndex = i;
+          if (i - foundIndex + 1 === valLength)
+            return foundIndex * indexSize;
+        } else {
+          if (foundIndex !== -1)
+            i -= i - foundIndex;
+          foundIndex = -1;
+        }
+      }
+    } else {
+      if (byteOffset + valLength > arrLength)
+        byteOffset = arrLength - valLength;
+      for (i = byteOffset; i >= 0; i--) {
+        var found = true;
+        for (var j = 0; j < valLength; j++) {
+          if (read(arr, i + j) !== read(val, j)) {
+            found = false;
+            break;
+          }
+        }
+        if (found)
+          return i;
+      }
+    }
+    return -1;
+  }
+  Buffer3.prototype.includes = function includes(val, byteOffset, encoding) {
+    return this.indexOf(val, byteOffset, encoding) !== -1;
+  };
+  Buffer3.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+    return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+  };
+  Buffer3.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+    return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+  };
+  function hexWrite(buf, string, offset, length) {
+    offset = Number(offset) || 0;
+    var remaining = buf.length - offset;
+    if (!length) {
+      length = remaining;
+    } else {
+      length = Number(length);
+      if (length > remaining) {
+        length = remaining;
+      }
+    }
+    var strLen = string.length;
+    if (length > strLen / 2) {
+      length = strLen / 2;
+    }
+    for (var i = 0; i < length; ++i) {
+      var parsed = parseInt(string.substr(i * 2, 2), 16);
+      if (numberIsNaN(parsed))
+        return i;
+      buf[offset + i] = parsed;
+    }
+    return i;
+  }
+  function utf8Write(buf, string, offset, length) {
+    return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+  }
+  function asciiWrite(buf, string, offset, length) {
+    return blitBuffer(asciiToBytes(string), buf, offset, length);
+  }
+  function base64Write(buf, string, offset, length) {
+    return blitBuffer(base64ToBytes(string), buf, offset, length);
+  }
+  function ucs2Write(buf, string, offset, length) {
+    return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+  }
+  Buffer3.prototype.write = function write(string, offset, length, encoding) {
+    if (offset === void 0) {
+      encoding = "utf8";
+      length = this.length;
+      offset = 0;
+    } else if (length === void 0 && typeof offset === "string") {
+      encoding = offset;
+      length = this.length;
+      offset = 0;
+    } else if (isFinite(offset)) {
+      offset = offset >>> 0;
+      if (isFinite(length)) {
+        length = length >>> 0;
+        if (encoding === void 0)
+          encoding = "utf8";
+      } else {
+        encoding = length;
+        length = void 0;
+      }
+    } else {
+      throw new Error(
+        "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+      );
+    }
+    var remaining = this.length - offset;
+    if (length === void 0 || length > remaining)
+      length = remaining;
+    if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
+      throw new RangeError("Attempt to write outside buffer bounds");
+    }
+    if (!encoding)
+      encoding = "utf8";
+    var loweredCase = false;
+    for (; ; ) {
+      switch (encoding) {
+        case "hex":
+          return hexWrite(this, string, offset, length);
+        case "utf8":
+        case "utf-8":
+          return utf8Write(this, string, offset, length);
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return asciiWrite(this, string, offset, length);
+        case "base64":
+          return base64Write(this, string, offset, length);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return ucs2Write(this, string, offset, length);
+        default:
+          if (loweredCase)
+            throw new TypeError("Unknown encoding: " + encoding);
+          encoding = ("" + encoding).toLowerCase();
+          loweredCase = true;
+      }
+    }
+  };
+  Buffer3.prototype.toJSON = function toJSON() {
+    return {
+      type: "Buffer",
+      data: Array.prototype.slice.call(this._arr || this, 0)
+    };
+  };
+  function base64Slice(buf, start, end) {
+    if (start === 0 && end === buf.length) {
+      return base64.fromByteArray(buf);
+    } else {
+      return base64.fromByteArray(buf.slice(start, end));
+    }
+  }
+  function utf8Slice(buf, start, end) {
+    end = Math.min(buf.length, end);
+    var res = [];
+    var i = start;
+    while (i < end) {
+      var firstByte = buf[i];
+      var codePoint = null;
+      var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+      if (i + bytesPerSequence <= end) {
+        var secondByte, thirdByte, fourthByte, tempCodePoint;
+        switch (bytesPerSequence) {
+          case 1:
+            if (firstByte < 128) {
+              codePoint = firstByte;
+            }
+            break;
+          case 2:
+            secondByte = buf[i + 1];
+            if ((secondByte & 192) === 128) {
+              tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+              if (tempCodePoint > 127) {
+                codePoint = tempCodePoint;
+              }
+            }
+            break;
+          case 3:
+            secondByte = buf[i + 1];
+            thirdByte = buf[i + 2];
+            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+              tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+              if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                codePoint = tempCodePoint;
+              }
+            }
+            break;
+          case 4:
+            secondByte = buf[i + 1];
+            thirdByte = buf[i + 2];
+            fourthByte = buf[i + 3];
+            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+              tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+              if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                codePoint = tempCodePoint;
+              }
+            }
+        }
+      }
+      if (codePoint === null) {
+        codePoint = 65533;
+        bytesPerSequence = 1;
+      } else if (codePoint > 65535) {
+        codePoint -= 65536;
+        res.push(codePoint >>> 10 & 1023 | 55296);
+        codePoint = 56320 | codePoint & 1023;
+      }
+      res.push(codePoint);
+      i += bytesPerSequence;
+    }
+    return decodeCodePointsArray(res);
+  }
+  var MAX_ARGUMENTS_LENGTH = 4096;
+  function decodeCodePointsArray(codePoints) {
+    var len = codePoints.length;
+    if (len <= MAX_ARGUMENTS_LENGTH) {
+      return String.fromCharCode.apply(String, codePoints);
+    }
+    var res = "";
+    var i = 0;
+    while (i < len) {
+      res += String.fromCharCode.apply(
+        String,
+        codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+      );
+    }
+    return res;
+  }
+  function asciiSlice(buf, start, end) {
+    var ret = "";
+    end = Math.min(buf.length, end);
+    for (var i = start; i < end; ++i) {
+      ret += String.fromCharCode(buf[i] & 127);
+    }
+    return ret;
+  }
+  function latin1Slice(buf, start, end) {
+    var ret = "";
+    end = Math.min(buf.length, end);
+    for (var i = start; i < end; ++i) {
+      ret += String.fromCharCode(buf[i]);
+    }
+    return ret;
+  }
+  function hexSlice(buf, start, end) {
+    var len = buf.length;
+    if (!start || start < 0)
+      start = 0;
+    if (!end || end < 0 || end > len)
+      end = len;
+    var out = "";
+    for (var i = start; i < end; ++i) {
+      out += hexSliceLookupTable[buf[i]];
+    }
+    return out;
+  }
+  function utf16leSlice(buf, start, end) {
+    var bytes = buf.slice(start, end);
+    var res = "";
+    for (var i = 0; i < bytes.length - 1; i += 2) {
+      res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+    }
+    return res;
+  }
+  Buffer3.prototype.slice = function slice(start, end) {
+    var len = this.length;
+    start = ~~start;
+    end = end === void 0 ? len : ~~end;
+    if (start < 0) {
+      start += len;
+      if (start < 0)
+        start = 0;
+    } else if (start > len) {
+      start = len;
+    }
+    if (end < 0) {
+      end += len;
+      if (end < 0)
+        end = 0;
+    } else if (end > len) {
+      end = len;
+    }
+    if (end < start)
+      end = start;
+    var newBuf = this.subarray(start, end);
+    Object.setPrototypeOf(newBuf, Buffer3.prototype);
+    return newBuf;
+  };
+  function checkOffset(offset, ext, length) {
+    if (offset % 1 !== 0 || offset < 0)
+      throw new RangeError("offset is not uint");
+    if (offset + ext > length)
+      throw new RangeError("Trying to access beyond buffer length");
+  }
+  Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength3, noAssert) {
+    offset = offset >>> 0;
+    byteLength3 = byteLength3 >>> 0;
+    if (!noAssert)
+      checkOffset(offset, byteLength3, this.length);
+    var val = this[offset];
+    var mul = 1;
+    var i = 0;
+    while (++i < byteLength3 && (mul *= 256)) {
+      val += this[offset + i] * mul;
+    }
+    return val;
+  };
+  Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength3, noAssert) {
+    offset = offset >>> 0;
+    byteLength3 = byteLength3 >>> 0;
+    if (!noAssert) {
+      checkOffset(offset, byteLength3, this.length);
+    }
+    var val = this[offset + --byteLength3];
+    var mul = 1;
+    while (byteLength3 > 0 && (mul *= 256)) {
+      val += this[offset + --byteLength3] * mul;
+    }
+    return val;
+  };
+  Buffer3.prototype.readUint8 = Buffer3.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 1, this.length);
+    return this[offset];
+  };
+  Buffer3.prototype.readUint16LE = Buffer3.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 2, this.length);
+    return this[offset] | this[offset + 1] << 8;
+  };
+  Buffer3.prototype.readUint16BE = Buffer3.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 2, this.length);
+    return this[offset] << 8 | this[offset + 1];
+  };
+  Buffer3.prototype.readUint32LE = Buffer3.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 4, this.length);
+    return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+  };
+  Buffer3.prototype.readUint32BE = Buffer3.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 4, this.length);
+    return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+  };
+  Buffer3.prototype.readIntLE = function readIntLE(offset, byteLength3, noAssert) {
+    offset = offset >>> 0;
+    byteLength3 = byteLength3 >>> 0;
+    if (!noAssert)
+      checkOffset(offset, byteLength3, this.length);
+    var val = this[offset];
+    var mul = 1;
+    var i = 0;
+    while (++i < byteLength3 && (mul *= 256)) {
+      val += this[offset + i] * mul;
+    }
+    mul *= 128;
+    if (val >= mul)
+      val -= Math.pow(2, 8 * byteLength3);
+    return val;
+  };
+  Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength3, noAssert) {
+    offset = offset >>> 0;
+    byteLength3 = byteLength3 >>> 0;
+    if (!noAssert)
+      checkOffset(offset, byteLength3, this.length);
+    var i = byteLength3;
+    var mul = 1;
+    var val = this[offset + --i];
+    while (i > 0 && (mul *= 256)) {
+      val += this[offset + --i] * mul;
+    }
+    mul *= 128;
+    if (val >= mul)
+      val -= Math.pow(2, 8 * byteLength3);
+    return val;
+  };
+  Buffer3.prototype.readInt8 = function readInt8(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 1, this.length);
+    if (!(this[offset] & 128))
+      return this[offset];
+    return (255 - this[offset] + 1) * -1;
+  };
+  Buffer3.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 2, this.length);
+    var val = this[offset] | this[offset + 1] << 8;
+    return val & 32768 ? val | 4294901760 : val;
+  };
+  Buffer3.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 2, this.length);
+    var val = this[offset + 1] | this[offset] << 8;
+    return val & 32768 ? val | 4294901760 : val;
+  };
+  Buffer3.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 4, this.length);
+    return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+  };
+  Buffer3.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 4, this.length);
+    return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+  };
+  Buffer3.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 4, this.length);
+    return ieee754$1.read(this, offset, true, 23, 4);
+  };
+  Buffer3.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 4, this.length);
+    return ieee754$1.read(this, offset, false, 23, 4);
+  };
+  Buffer3.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 8, this.length);
+    return ieee754$1.read(this, offset, true, 52, 8);
+  };
+  Buffer3.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkOffset(offset, 8, this.length);
+    return ieee754$1.read(this, offset, false, 52, 8);
+  };
+  function checkInt(buf, value, offset, ext, max, min) {
+    if (!Buffer3.isBuffer(buf))
+      throw new TypeError('"buffer" argument must be a Buffer instance');
+    if (value > max || value < min)
+      throw new RangeError('"value" argument is out of bounds');
+    if (offset + ext > buf.length)
+      throw new RangeError("Index out of range");
+  }
+  Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength3, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    byteLength3 = byteLength3 >>> 0;
+    if (!noAssert) {
+      var maxBytes = Math.pow(2, 8 * byteLength3) - 1;
+      checkInt(this, value, offset, byteLength3, maxBytes, 0);
+    }
+    var mul = 1;
+    var i = 0;
+    this[offset] = value & 255;
+    while (++i < byteLength3 && (mul *= 256)) {
+      this[offset + i] = value / mul & 255;
+    }
+    return offset + byteLength3;
+  };
+  Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength3, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    byteLength3 = byteLength3 >>> 0;
+    if (!noAssert) {
+      var maxBytes = Math.pow(2, 8 * byteLength3) - 1;
+      checkInt(this, value, offset, byteLength3, maxBytes, 0);
+    }
+    var i = byteLength3 - 1;
+    var mul = 1;
+    this[offset + i] = value & 255;
+    while (--i >= 0 && (mul *= 256)) {
+      this[offset + i] = value / mul & 255;
+    }
+    return offset + byteLength3;
+  };
+  Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkInt(this, value, offset, 1, 255, 0);
+    this[offset] = value & 255;
+    return offset + 1;
+  };
+  Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkInt(this, value, offset, 2, 65535, 0);
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8;
+    return offset + 2;
+  };
+  Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkInt(this, value, offset, 2, 65535, 0);
+    this[offset] = value >>> 8;
+    this[offset + 1] = value & 255;
+    return offset + 2;
+  };
+  Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkInt(this, value, offset, 4, 4294967295, 0);
+    this[offset + 3] = value >>> 24;
+    this[offset + 2] = value >>> 16;
+    this[offset + 1] = value >>> 8;
+    this[offset] = value & 255;
+    return offset + 4;
+  };
+  Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkInt(this, value, offset, 4, 4294967295, 0);
+    this[offset] = value >>> 24;
+    this[offset + 1] = value >>> 16;
+    this[offset + 2] = value >>> 8;
+    this[offset + 3] = value & 255;
+    return offset + 4;
+  };
+  Buffer3.prototype.writeIntLE = function writeIntLE(value, offset, byteLength3, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      var limit = Math.pow(2, 8 * byteLength3 - 1);
+      checkInt(this, value, offset, byteLength3, limit - 1, -limit);
+    }
+    var i = 0;
+    var mul = 1;
+    var sub = 0;
+    this[offset] = value & 255;
+    while (++i < byteLength3 && (mul *= 256)) {
+      if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+        sub = 1;
+      }
+      this[offset + i] = (value / mul >> 0) - sub & 255;
+    }
+    return offset + byteLength3;
+  };
+  Buffer3.prototype.writeIntBE = function writeIntBE(value, offset, byteLength3, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      var limit = Math.pow(2, 8 * byteLength3 - 1);
+      checkInt(this, value, offset, byteLength3, limit - 1, -limit);
+    }
+    var i = byteLength3 - 1;
+    var mul = 1;
+    var sub = 0;
+    this[offset + i] = value & 255;
+    while (--i >= 0 && (mul *= 256)) {
+      if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+        sub = 1;
+      }
+      this[offset + i] = (value / mul >> 0) - sub & 255;
+    }
+    return offset + byteLength3;
+  };
+  Buffer3.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkInt(this, value, offset, 1, 127, -128);
+    if (value < 0)
+      value = 255 + value + 1;
+    this[offset] = value & 255;
+    return offset + 1;
+  };
+  Buffer3.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkInt(this, value, offset, 2, 32767, -32768);
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8;
+    return offset + 2;
+  };
+  Buffer3.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkInt(this, value, offset, 2, 32767, -32768);
+    this[offset] = value >>> 8;
+    this[offset + 1] = value & 255;
+    return offset + 2;
+  };
+  Buffer3.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkInt(this, value, offset, 4, 2147483647, -2147483648);
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8;
+    this[offset + 2] = value >>> 16;
+    this[offset + 3] = value >>> 24;
+    return offset + 4;
+  };
+  Buffer3.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert)
+      checkInt(this, value, offset, 4, 2147483647, -2147483648);
+    if (value < 0)
+      value = 4294967295 + value + 1;
+    this[offset] = value >>> 24;
+    this[offset + 1] = value >>> 16;
+    this[offset + 2] = value >>> 8;
+    this[offset + 3] = value & 255;
+    return offset + 4;
+  };
+  function checkIEEE754(buf, value, offset, ext, max, min) {
+    if (offset + ext > buf.length)
+      throw new RangeError("Index out of range");
+    if (offset < 0)
+      throw new RangeError("Index out of range");
+  }
+  function writeFloat(buf, value, offset, littleEndian, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      checkIEEE754(buf, value, offset, 4);
+    }
+    ieee754$1.write(buf, value, offset, littleEndian, 23, 4);
+    return offset + 4;
+  }
+  Buffer3.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+    return writeFloat(this, value, offset, true, noAssert);
+  };
+  Buffer3.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+    return writeFloat(this, value, offset, false, noAssert);
+  };
+  function writeDouble(buf, value, offset, littleEndian, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      checkIEEE754(buf, value, offset, 8);
+    }
+    ieee754$1.write(buf, value, offset, littleEndian, 52, 8);
+    return offset + 8;
+  }
+  Buffer3.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+    return writeDouble(this, value, offset, true, noAssert);
+  };
+  Buffer3.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+    return writeDouble(this, value, offset, false, noAssert);
+  };
+  Buffer3.prototype.copy = function copy(target, targetStart, start, end) {
+    if (!Buffer3.isBuffer(target))
+      throw new TypeError("argument should be a Buffer");
+    if (!start)
+      start = 0;
+    if (!end && end !== 0)
+      end = this.length;
+    if (targetStart >= target.length)
+      targetStart = target.length;
+    if (!targetStart)
+      targetStart = 0;
+    if (end > 0 && end < start)
+      end = start;
+    if (end === start)
+      return 0;
+    if (target.length === 0 || this.length === 0)
+      return 0;
+    if (targetStart < 0) {
+      throw new RangeError("targetStart out of bounds");
+    }
+    if (start < 0 || start >= this.length)
+      throw new RangeError("Index out of range");
+    if (end < 0)
+      throw new RangeError("sourceEnd out of bounds");
+    if (end > this.length)
+      end = this.length;
+    if (target.length - targetStart < end - start) {
+      end = target.length - targetStart + start;
+    }
+    var len = end - start;
+    if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
+      this.copyWithin(targetStart, start, end);
+    } else {
+      Uint8Array.prototype.set.call(
+        target,
+        this.subarray(start, end),
+        targetStart
+      );
+    }
+    return len;
+  };
+  Buffer3.prototype.fill = function fill(val, start, end, encoding) {
+    if (typeof val === "string") {
+      if (typeof start === "string") {
+        encoding = start;
+        start = 0;
+        end = this.length;
+      } else if (typeof end === "string") {
+        encoding = end;
+        end = this.length;
+      }
+      if (encoding !== void 0 && typeof encoding !== "string") {
+        throw new TypeError("encoding must be a string");
+      }
+      if (typeof encoding === "string" && !Buffer3.isEncoding(encoding)) {
+        throw new TypeError("Unknown encoding: " + encoding);
+      }
+      if (val.length === 1) {
+        var code2 = val.charCodeAt(0);
+        if (encoding === "utf8" && code2 < 128 || encoding === "latin1") {
+          val = code2;
+        }
+      }
+    } else if (typeof val === "number") {
+      val = val & 255;
+    } else if (typeof val === "boolean") {
+      val = Number(val);
+    }
+    if (start < 0 || this.length < start || this.length < end) {
+      throw new RangeError("Out of range index");
+    }
+    if (end <= start) {
+      return this;
+    }
+    start = start >>> 0;
+    end = end === void 0 ? this.length : end >>> 0;
+    if (!val)
+      val = 0;
+    var i;
+    if (typeof val === "number") {
+      for (i = start; i < end; ++i) {
+        this[i] = val;
+      }
+    } else {
+      var bytes = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding);
+      var len = bytes.length;
+      if (len === 0) {
+        throw new TypeError('The value "' + val + '" is invalid for argument "value"');
+      }
+      for (i = 0; i < end - start; ++i) {
+        this[i + start] = bytes[i % len];
+      }
+    }
+    return this;
+  };
+  var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+  function base64clean(str) {
+    str = str.split("=")[0];
+    str = str.trim().replace(INVALID_BASE64_RE, "");
+    if (str.length < 2)
+      return "";
+    while (str.length % 4 !== 0) {
+      str = str + "=";
+    }
+    return str;
+  }
+  function utf8ToBytes(string, units) {
+    units = units || Infinity;
+    var codePoint;
+    var length = string.length;
+    var leadSurrogate = null;
+    var bytes = [];
+    for (var i = 0; i < length; ++i) {
+      codePoint = string.charCodeAt(i);
+      if (codePoint > 55295 && codePoint < 57344) {
+        if (!leadSurrogate) {
+          if (codePoint > 56319) {
+            if ((units -= 3) > -1)
+              bytes.push(239, 191, 189);
+            continue;
+          } else if (i + 1 === length) {
+            if ((units -= 3) > -1)
+              bytes.push(239, 191, 189);
+            continue;
+          }
+          leadSurrogate = codePoint;
+          continue;
+        }
+        if (codePoint < 56320) {
+          if ((units -= 3) > -1)
+            bytes.push(239, 191, 189);
+          leadSurrogate = codePoint;
+          continue;
+        }
+        codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+      } else if (leadSurrogate) {
+        if ((units -= 3) > -1)
+          bytes.push(239, 191, 189);
+      }
+      leadSurrogate = null;
+      if (codePoint < 128) {
+        if ((units -= 1) < 0)
+          break;
+        bytes.push(codePoint);
+      } else if (codePoint < 2048) {
+        if ((units -= 2) < 0)
+          break;
+        bytes.push(
+          codePoint >> 6 | 192,
+          codePoint & 63 | 128
+        );
+      } else if (codePoint < 65536) {
+        if ((units -= 3) < 0)
+          break;
+        bytes.push(
+          codePoint >> 12 | 224,
+          codePoint >> 6 & 63 | 128,
+          codePoint & 63 | 128
+        );
+      } else if (codePoint < 1114112) {
+        if ((units -= 4) < 0)
+          break;
+        bytes.push(
+          codePoint >> 18 | 240,
+          codePoint >> 12 & 63 | 128,
+          codePoint >> 6 & 63 | 128,
+          codePoint & 63 | 128
+        );
+      } else {
+        throw new Error("Invalid code point");
+      }
+    }
+    return bytes;
+  }
+  function asciiToBytes(str) {
+    var byteArray = [];
+    for (var i = 0; i < str.length; ++i) {
+      byteArray.push(str.charCodeAt(i) & 255);
+    }
+    return byteArray;
+  }
+  function utf16leToBytes(str, units) {
+    var c, hi, lo;
+    var byteArray = [];
+    for (var i = 0; i < str.length; ++i) {
+      if ((units -= 2) < 0)
+        break;
+      c = str.charCodeAt(i);
+      hi = c >> 8;
+      lo = c % 256;
+      byteArray.push(lo);
+      byteArray.push(hi);
+    }
+    return byteArray;
+  }
+  function base64ToBytes(str) {
+    return base64.toByteArray(base64clean(str));
+  }
+  function blitBuffer(src, dst, offset, length) {
+    for (var i = 0; i < length; ++i) {
+      if (i + offset >= dst.length || i >= src.length)
+        break;
+      dst[i + offset] = src[i];
+    }
+    return i;
+  }
+  function isInstance(obj, type) {
+    return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+  }
+  function numberIsNaN(obj) {
+    return obj !== obj;
+  }
+  var hexSliceLookupTable = function() {
+    var alphabet = "0123456789abcdef";
+    var table = new Array(256);
+    for (var i = 0; i < 16; ++i) {
+      var i16 = i * 16;
+      for (var j = 0; j < 16; ++j) {
+        table[i16 + j] = alphabet[i] + alphabet[j];
+      }
+    }
+    return table;
+  }();
+})(buffer);
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+(function(module, exports) {
+  var buffer$1 = buffer;
+  var Buffer3 = buffer$1.Buffer;
+  function copyProps(src, dst) {
+    for (var key in src) {
+      dst[key] = src[key];
+    }
+  }
+  if (Buffer3.from && Buffer3.alloc && Buffer3.allocUnsafe && Buffer3.allocUnsafeSlow) {
+    module.exports = buffer$1;
+  } else {
+    copyProps(buffer$1, exports);
+    exports.Buffer = SafeBuffer;
+  }
+  function SafeBuffer(arg, encodingOrOffset, length) {
+    return Buffer3(arg, encodingOrOffset, length);
+  }
+  SafeBuffer.prototype = Object.create(Buffer3.prototype);
+  copyProps(Buffer3, SafeBuffer);
+  SafeBuffer.from = function(arg, encodingOrOffset, length) {
+    if (typeof arg === "number") {
+      throw new TypeError("Argument must not be a number");
+    }
+    return Buffer3(arg, encodingOrOffset, length);
+  };
+  SafeBuffer.alloc = function(size, fill, encoding) {
+    if (typeof size !== "number") {
+      throw new TypeError("Argument must be a number");
+    }
+    var buf = Buffer3(size);
+    if (fill !== void 0) {
+      if (typeof encoding === "string") {
+        buf.fill(fill, encoding);
+      } else {
+        buf.fill(fill);
+      }
+    } else {
+      buf.fill(0);
+    }
+    return buf;
+  };
+  SafeBuffer.allocUnsafe = function(size) {
+    if (typeof size !== "number") {
+      throw new TypeError("Argument must be a number");
+    }
+    return Buffer3(size);
+  };
+  SafeBuffer.allocUnsafeSlow = function(size) {
+    if (typeof size !== "number") {
+      throw new TypeError("Argument must be a number");
+    }
+    return buffer$1.SlowBuffer(size);
+  };
+})(safeBuffer, safeBuffer.exports);
+var safeBufferExports = safeBuffer.exports;
+var Buffer$2 = safeBufferExports.Buffer;
+function Hash$2(blockSize, finalSize) {
+  this._block = Buffer$2.alloc(blockSize);
+  this._finalSize = finalSize;
+  this._blockSize = blockSize;
+  this._len = 0;
+}
+Hash$2.prototype.update = function(data, enc) {
+  if (typeof data === "string") {
+    enc = enc || "utf8";
+    data = Buffer$2.from(data, enc);
+  }
+  var block = this._block;
+  var blockSize = this._blockSize;
+  var length = data.length;
+  var accum = this._len;
+  for (var offset = 0; offset < length; ) {
+    var assigned = accum % blockSize;
+    var remainder = Math.min(length - offset, blockSize - assigned);
+    for (var i = 0; i < remainder; i++) {
+      block[assigned + i] = data[offset + i];
+    }
+    accum += remainder;
+    offset += remainder;
+    if (accum % blockSize === 0) {
+      this._update(block);
+    }
+  }
+  this._len += length;
+  return this;
+};
+Hash$2.prototype.digest = function(enc) {
+  var rem = this._len % this._blockSize;
+  this._block[rem] = 128;
+  this._block.fill(0, rem + 1);
+  if (rem >= this._finalSize) {
+    this._update(this._block);
+    this._block.fill(0);
+  }
+  var bits = this._len * 8;
+  if (bits <= 4294967295) {
+    this._block.writeUInt32BE(bits, this._blockSize - 4);
+  } else {
+    var lowBits = (bits & 4294967295) >>> 0;
+    var highBits = (bits - lowBits) / 4294967296;
+    this._block.writeUInt32BE(highBits, this._blockSize - 8);
+    this._block.writeUInt32BE(lowBits, this._blockSize - 4);
+  }
+  this._update(this._block);
+  var hash2 = this._hash();
+  return enc ? hash2.toString(enc) : hash2;
+};
+Hash$2.prototype._update = function() {
+  throw new Error("_update must be implemented by subclass");
+};
+var hash$1 = Hash$2;
+var inherits$1 = inherits_browserExports;
+var Hash$1 = hash$1;
+var Buffer$1 = safeBufferExports.Buffer;
+var K$1 = [
+  1518500249,
+  1859775393,
+  2400959708 | 0,
+  3395469782 | 0
+];
+var W$1 = new Array(80);
+function Sha1() {
+  this.init();
+  this._w = W$1;
+  Hash$1.call(this, 64, 56);
+}
+inherits$1(Sha1, Hash$1);
+Sha1.prototype.init = function() {
+  this._a = 1732584193;
+  this._b = 4023233417;
+  this._c = 2562383102;
+  this._d = 271733878;
+  this._e = 3285377520;
+  return this;
+};
+function rotl1(num) {
+  return num << 1 | num >>> 31;
+}
+function rotl5(num) {
+  return num << 5 | num >>> 27;
+}
+function rotl30(num) {
+  return num << 30 | num >>> 2;
+}
+function ft(s, b, c, d) {
+  if (s === 0)
+    return b & c | ~b & d;
+  if (s === 2)
+    return b & c | b & d | c & d;
+  return b ^ c ^ d;
+}
+Sha1.prototype._update = function(M) {
+  var W2 = this._w;
+  var a = this._a | 0;
+  var b = this._b | 0;
+  var c = this._c | 0;
+  var d = this._d | 0;
+  var e = this._e | 0;
+  for (var i = 0; i < 16; ++i)
+    W2[i] = M.readInt32BE(i * 4);
+  for (; i < 80; ++i)
+    W2[i] = rotl1(W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16]);
+  for (var j = 0; j < 80; ++j) {
+    var s = ~~(j / 20);
+    var t = rotl5(a) + ft(s, b, c, d) + e + W2[j] + K$1[s] | 0;
+    e = d;
+    d = c;
+    c = rotl30(b);
+    b = a;
+    a = t;
+  }
+  this._a = a + this._a | 0;
+  this._b = b + this._b | 0;
+  this._c = c + this._c | 0;
+  this._d = d + this._d | 0;
+  this._e = e + this._e | 0;
+};
+Sha1.prototype._hash = function() {
+  var H = Buffer$1.allocUnsafe(20);
+  H.writeInt32BE(this._a | 0, 0);
+  H.writeInt32BE(this._b | 0, 4);
+  H.writeInt32BE(this._c | 0, 8);
+  H.writeInt32BE(this._d | 0, 12);
+  H.writeInt32BE(this._e | 0, 16);
+  return H;
+};
+var sha1 = Sha1;
+const Sha1$1 = /* @__PURE__ */ getDefaultExportFromCjs(sha1);
+var inherits = inherits_browserExports;
+var Hash = hash$1;
+var Buffer2 = safeBufferExports.Buffer;
+var K = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+var W = new Array(64);
+function Sha256() {
+  this.init();
+  this._w = W;
+  Hash.call(this, 64, 56);
+}
+inherits(Sha256, Hash);
+Sha256.prototype.init = function() {
+  this._a = 1779033703;
+  this._b = 3144134277;
+  this._c = 1013904242;
+  this._d = 2773480762;
+  this._e = 1359893119;
+  this._f = 2600822924;
+  this._g = 528734635;
+  this._h = 1541459225;
+  return this;
+};
+function ch(x, y, z2) {
+  return z2 ^ x & (y ^ z2);
+}
+function maj(x, y, z2) {
+  return x & y | z2 & (x | y);
+}
+function sigma0(x) {
+  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10);
+}
+function sigma1(x) {
+  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7);
+}
+function gamma0(x) {
+  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3;
+}
+function gamma1(x) {
+  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ x >>> 10;
+}
+Sha256.prototype._update = function(M) {
+  var W2 = this._w;
+  var a = this._a | 0;
+  var b = this._b | 0;
+  var c = this._c | 0;
+  var d = this._d | 0;
+  var e = this._e | 0;
+  var f = this._f | 0;
+  var g = this._g | 0;
+  var h = this._h | 0;
+  for (var i = 0; i < 16; ++i)
+    W2[i] = M.readInt32BE(i * 4);
+  for (; i < 64; ++i)
+    W2[i] = gamma1(W2[i - 2]) + W2[i - 7] + gamma0(W2[i - 15]) + W2[i - 16] | 0;
+  for (var j = 0; j < 64; ++j) {
+    var T1 = h + sigma1(e) + ch(e, f, g) + K[j] + W2[j] | 0;
+    var T2 = sigma0(a) + maj(a, b, c) | 0;
+    h = g;
+    g = f;
+    f = e;
+    e = d + T1 | 0;
+    d = c;
+    c = b;
+    b = a;
+    a = T1 + T2 | 0;
+  }
+  this._a = a + this._a | 0;
+  this._b = b + this._b | 0;
+  this._c = c + this._c | 0;
+  this._d = d + this._d | 0;
+  this._e = e + this._e | 0;
+  this._f = f + this._f | 0;
+  this._g = g + this._g | 0;
+  this._h = h + this._h | 0;
+};
+Sha256.prototype._hash = function() {
+  var H = Buffer2.allocUnsafe(32);
+  H.writeInt32BE(this._a, 0);
+  H.writeInt32BE(this._b, 4);
+  H.writeInt32BE(this._c, 8);
+  H.writeInt32BE(this._d, 12);
+  H.writeInt32BE(this._e, 16);
+  H.writeInt32BE(this._f, 20);
+  H.writeInt32BE(this._g, 24);
+  H.writeInt32BE(this._h, 28);
+  return H;
+};
+var sha256 = Sha256;
+const Sha256$1 = /* @__PURE__ */ getDefaultExportFromCjs(sha256);
+const FileSystemError = new Error("File system not available.");
+function writeFile(path, name, stream) {
+  throw FileSystemError;
+}
+function readFile(path) {
+  throw FileSystemError;
+}
+function fetchFile(url) {
+  throw FileSystemError;
+}
+const getFile = async (file) => {
+  return readFile();
+};
+const hashAlgorithms = {
+  sha1: Sha1$1,
+  sha256: Sha256$1
+};
+const hash = (data, algorithm = "sha1") => {
+  if (!["sha1", "sha256"].includes(algorithm)) {
+    throw new Error("Hashing algorithm not supported: Available: sha1, sha256");
+  }
+  const Algorithm = hashAlgorithms[algorithm];
+  const sha = new Algorithm();
+  return sha.update(data).digest("base64");
+};
+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);
+    for (let i = 0; i < ops.length; i++) {
+      if (ops[i].index !== i) {
+        errors.push({
+          message: `Invalid operation index ${ops[i].index} at position ${i}`,
+          details: {
+            position: i,
+            operation: ops[i],
+            scope: ops[i].scope
+          }
+        });
+      }
+    }
+  }
+  return errors;
+}
+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("operations.json", JSON.stringify(document.operations, null, 2));
+  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);
+  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}`
+  );
+};
+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();
+  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 operationsError = validateOperations(operations);
+  if (operationsError.length) {
+    const errorMessages = operationsError.map((err) => err.message);
+    throw new Error(errorMessages.join("\n"));
+  }
+  let result = replayDocument(
+    initialState,
+    operations,
+    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: buffer2, mimeType = "application/octet-stream" } = await fetchFile();
+  const attributes = getFileAttributes(url);
+  const data = buffer2.toString("base64");
+  return {
+    data,
+    hash: hash(data),
+    mimeType,
+    ...attributes
+  };
+}
+async function getLocalFile(path) {
+  const buffer2 = await getFile();
+  const mimeType = mime.getType(path) || "application/octet-stream";
+  const attributes = getFileAttributes(path);
+  const data = buffer2.toString("base64");
+  return { data, hash: hash(data), mimeType, ...attributes };
+}
+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.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 newOperationHistory = reshuffle(
+    {
+      index: nextIndex,
+      skip: nextIndex - (maxCommonIndex + 1)
+    },
+    _targetOperations,
+    _mergeOperations
+  );
+  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 grabageCollectDocumentOperations(documentOperations) {
+  const clearedOperations = Object.entries(documentOperations).reduce(
+    (acc, entry) => {
+      const [scope, ops] = entry;
+      return {
+        ...acc,
+        [scope]: garbageCollect(sortOperations$1(ops))
+      };
+    },
+    {}
+  );
+  return {
+    ...clearedOperations
+  };
+}
+const documentHelpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  IntegrityIssueSubType,
+  IntegrityIssueType,
+  addUndo,
+  attachBranch,
+  checkCleanedOperationsIntegrity,
+  checkOperationsIntegrity,
+  garbageCollect,
+  grabageCollectDocumentOperations,
+  groupOperationsByScope,
+  merge,
+  nextSkipNumber,
+  operationsAreEqual,
+  precedes,
+  prepareOperations,
+  removeExistingOperations,
+  reshuffleByTimestamp,
+  reshuffleByTimestampAndIndex,
+  skipHeaderOperations,
+  sortOperations: sortOperations$1,
+  split
+}, Symbol.toStringTag, { value: "Module" }));
+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: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function updateOperations(document, action, skip = 0) {
+  if ([UNDO, REDO, PRUNE].includes(action.type)) {
+    return document;
+  }
+  const { scope } = action;
+  const operations = document.operations[scope].slice(
+    0,
+    document.revision[scope]
+  );
+  const latestOperation = [...operations].pop();
+  let nextIndex = ((latestOperation == null ? void 0 : latestOperation.index) ?? -1) + 1;
+  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;
+  }
+  operations.push({
+    ...action,
+    index: nextIndex,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    hash: "",
+    scope,
+    skip,
+    error: void 0
+  });
+  return {
+    ...document,
+    operations: { ...document.operations, [scope]: operations }
+  };
+}
+function updateDocument(document, action, skip = 0) {
+  let newDocument = updateOperations(document, action, skip);
+  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 };
+  }
+}
+function processSkipOperation(document, action, customReducer, skipValue) {
+  const scope = action.scope;
+  const latestOperation = document.operations[scope].at(-1);
+  if (!latestOperation)
+    return document;
+  const documentOperations = grabageCollectDocumentOperations(
+    {
+      ...document.operations,
+      [scope]: skipHeaderOperations(
+        document.operations[scope],
+        latestOperation
+      )
+    }
+  );
+  const { state } = replayOperations(
+    document.initialState,
+    documentOperations,
+    customReducer,
+    void 0,
+    void 0,
+    void 0
+  );
+  return {
+    ...document,
+    state,
+    operations: grabageCollectDocumentOperations({
+      ...document.operations
+    })
+  };
+}
+function baseReducer(document, action, customReducer, dispatch, options = {}) {
+  const { skip, ignoreSkipOperations = false, reuseHash = false } = 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
+    );
+  }
+  newDocument = produce(newDocument, (draft) => {
+    try {
+      const returnedDraft = customReducer(
+        draft.state,
+        _action,
+        dispatch
+      );
+      if (returnedDraft) {
+        return castDraft({
+          ...newDocument,
+          // clipboard: [...clipboardValue],
+          state: returnedDraft
+        });
+      } 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]
+            }
+          ]
+        });
+      }
+    }
+  });
+  return produce(newDocument, (draft) => {
+    if ([UNDO, REDO, PRUNE].includes(_action.type)) {
+      return draft;
+    }
+    const scope = _action.scope || "global";
+    const hash2 = reuseHash && Object.prototype.hasOwnProperty.call(_action, "hash") ? _action.hash : hashDocument(draft, scope);
+    draft.operations[scope][draft.operations[scope].length - 1].hash = hash2;
+    if (!isBaseAction(_action) && _action.attachments) {
+      _action.attachments.forEach((attachment) => {
+        const { hash: hash22, ...file } = attachment;
+        draft.attachments[hash22] = {
+          ...file
+        };
+      });
+    }
+  });
+}
+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 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) {
+    throw new Error(`Invalid action input: ${error}`);
+  }
+  return action;
+}
+function createReducer(reducer, documentReducer = baseReducer) {
+  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 castImmutable(freeze(value, true));
+}
+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 calculateSkipsLeft(operations, currentIndex, skip) {
+  const sortedOperations = operations.slice().sort((a, b) => a.skip - b.skip).sort((a, b) => a.index - b.index);
+  let skipsLeft = skip;
+  let skipsToPerform = 0;
+  let lastIndex = currentIndex;
+  for (const operation of sortedOperations.reverse()) {
+    const distance = lastIndex - operation.index;
+    skipsLeft = skipsLeft - distance;
+    if (skipsLeft > -1) {
+      skipsToPerform++;
+      lastIndex = operation.index;
+    } else {
+      break;
+    }
+  }
+  return skipsToPerform;
+}
+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 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 = (options == null ? void 0 : options.checkHashes) ?? true;
+  const document = createDocument(initialState);
+  const flatOperations = Object.values(operations).flat();
+  const result = flatOperations.reduce((document2, operation) => {
+    const doc = reducer(document2, operation, dispatch, {
+      skip: operation.skip,
+      ignoreSkipOperations: true,
+      reuseHash: !checkHashes
+    });
+    return doc;
+  }, document);
+  if (!checkHashes) {
+    for (const scope of Object.keys(result.state)) {
+      for (let i = flatOperations.length - 1; i >= 0; i--) {
+        const operation = flatOperations[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[curr.length - 1];
+    if ((operation == null ? void 0 : operation.timestamp) > acc) {
+      acc = operation.timestamp;
+    }
+    return acc;
+  }, initialState.lastModified);
+  return { ...result, operations: resultOperations, lastModified };
+}
+function isSameDocument(documentA, documentB) {
+  return cjsModule(documentA) === cjsModule(documentB);
+}
+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" }));
+class BaseDocument {
+  /**
+   * Constructs a BaseDocument instance with an initial state.
+   * @param reducer - The reducer function that updates the state.
+   * @param document - The initial state of the document.
+   */
+  constructor(reducer, document, signalDispatch) {
+    __publicField(this, "_document");
+    __publicField(this, "_reducer");
+    __publicField(this, "_signalDispatch");
+    this._reducer = reducer;
+    this._document = document;
+    this._signalDispatch = signalDispatch;
+  }
+  /**
+   * Dispatches an action to update the state of the document.
+   * @param action - The action to dispatch.
+   * @returns The Document instance.
+   */
+  dispatch(action, options) {
+    this._document = this._reducer(
+      this._document,
+      action,
+      this._signalDispatch,
+      options
+    );
+    return this;
+  }
+  /**
+   * Saves the state of the document to a file.
+   * @param path - The file path where the state should be saved.
+   * @param extension - The file extension to use when saving the state.
+   * @returns The file path where the state was saved.
+   */
+  saveToFile(path, extension, name) {
+    return saveToFile(this._document, path, extension, name);
+  }
+  /**
+   * Loads the state of the document from a file.
+   * @param path - The file path where the state is stored.
+   */
+  async loadFromFile(path) {
+    this._document = await loadFromFile(path, this._reducer);
+  }
+  /**
+   * Loads the state of the document from a file and returns it.
+   * @param path - The file path where the state is stored.
+   * @param reducer - The reducer function that updates the state.
+   * @returns The state of the document.
+   */
+  static async stateFromFile(path, reducer) {
+    const state = await loadFromFile(path, reducer);
+    return state;
+  }
+  /**
+   *    Gets the current state of the document.
+   */
+  get state() {
+    return readOnly(this._document.state);
+  }
+  /**
+   *    Gets the list of operations performed on the document.
+   */
+  get operations() {
+    return readOnly(this._document.operations);
+  }
+  /**
+   * Gets the name of the document.
+   */
+  get name() {
+    return this._document.name;
+  }
+  /**
+   * Gets the type of document.
+   */
+  get documentType() {
+    return this._document.documentType;
+  }
+  /**
+   * Gets the timestamp of the date the document was created.
+   */
+  get created() {
+    return this._document.created;
+  }
+  /**
+   * Gets the timestamp of the date the document was last modified.
+   */
+  get lastModified() {
+    return this._document.lastModified;
+  }
+  /**
+   * Gets the global revision number of the document.
+   */
+  get revision() {
+    return this._document.revision.global;
+  }
+  getRevision(scope) {
+    return this._document.revision[scope];
+  }
+  /**
+   * Gets the initial state of the document.
+   */
+  get initialState() {
+    return readOnly(this._document.initialState);
+  }
+  /**
+   * Returns the current document as an object
+   */
+  toDocument() {
+    return readOnly(this._document);
+  }
+  /**
+   * Gets the attachment associated with the given key.
+   * @param attachment - The key of the attachment to retrieve.
+   */
+  getAttachment(attachment) {
+    return this._document.attachments[attachment];
+  }
+  /**
+   * Sets the name of the document.
+   * @param name - The new name of the document.
+   */
+  setName(name) {
+    this.dispatch(setName(name));
+    return this;
+  }
+  /**
+   * Reverts a number of actions from the document.
+   * @param count - The number of actions to revert.
+   */
+  undo(count) {
+    this.dispatch(undo(count));
+    return this;
+  }
+  /**
+   * Reapplies a number of actions to the document.
+   * @param count - The number of actions to reapply.
+   */
+  redo(count) {
+    this.dispatch(redo(count));
+    return this;
+  }
+  /**
+   * Removes a range of operations from the document.
+   * @param start - The starting index of the range to remove.
+   * @param end - The ending index of the range to remove.
+   */
+  prune(start, end) {
+    this.dispatch(prune(start, end));
+    return this;
+  }
+  /**
+   * Loads a document state and a set of operations.
+   * @param state - The state to load.
+   * @param operations - The operations to apply to the document.
+   */
+  loadState(state, operations) {
+    this.dispatch(loadState(state, operations));
+    return this;
+  }
+}
+function applyMixins(derivedCtor, constructors) {
+  constructors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      Object.defineProperty(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        derivedCtor.prototype,
+        name,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
+        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || /* @__PURE__ */ Object.create(null)
+      );
+    });
+  });
+}
+export {
+  sortOperations as A,
+  BaseDocument as B,
+  validateOperations as C,
+  baseReducer as D,
+  processUndoRedo as E,
+  zod as F,
+  createExtendedState as a,
+  createDocument as b,
+  createReducer as c,
+  saveToFileHandle as d,
+  loadFromInput as e,
+  createAction as f,
+  applyMixins as g,
+  BaseActions as h,
+  isBaseAction as i,
+  calculateSkipsLeft as j,
+  createZip as k,
+  loadFromFile as l,
+  documentHelpers as m,
+  getLocalFile as n,
+  getRemoteFile as o,
+  hashDocument as p,
+  hashKey as q,
+  isNoopOperation as r,
+  saveToFile as s,
+  isSameDocument as t,
+  isUndoRedo as u,
+  mapSkippedOperations as v,
+  readOnly as w,
+  replayDocument as x,
+  replayOperations as y,
+  sortMappedOperations as z
+};
+//# sourceMappingURL=object-9mR1JlXD.js.map