document-model 1.7.0 → 2.0.0

package/dist/browser/es/internal/{object-CY74acQg.js → object-CU5T1DpX.js}

@@ -153,16 +153,16 @@ var safeStableStringify = { exports: {} };
   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]/;
+  const strEscapeSequencesRegExp = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
   function strEscape(str) {
     if (str.length < 5e3 && !strEscapeSequencesRegExp.test(str)) {
       return `"${str}"`;
     }
     return JSON.stringify(str);
   }
-  function insertSort(array) {
-    if (array.length > 200) {
-      return array.sort();
+  function sort(array, comparator) {
+    if (array.length > 200 || comparator) {
+      return array.sort(comparator);
     }
     for (let i = 1; i < array.length; i++) {
       const currentValue = array[i];
@@ -217,6 +217,16 @@ var safeStableStringify = { exports: {} };
     }
     return '"[Circular]"';
   }
+  function getDeterministicOption(options) {
+    let value;
+    if (hasOwnProperty.call(options, "deterministic")) {
+      value = options.deterministic;
+      if (typeof value !== "boolean" && typeof value !== "function") {
+        throw new TypeError('The "deterministic" argument must be of type boolean or comparator function');
+      }
+    }
+    return value === void 0 ? true : value;
+  }
   function getBooleanOption(options, key) {
     let value;
     if (hasOwnProperty.call(options, key)) {
@@ -286,7 +296,8 @@ var safeStableStringify = { exports: {} };
     }
     const circularValue = getCircularValueOption(options);
     const bigint = getBooleanOption(options, "bigint");
-    const deterministic = getBooleanOption(options, "deterministic");
+    const deterministic = getDeterministicOption(options);
+    const comparator = typeof deterministic === "function" ? deterministic : void 0;
     const maximumDepth = getPositiveIntegerOption(options, "maximumDepth");
     const maximumBreadth = getPositiveIntegerOption(options, "maximumBreadth");
     function stringifyFnReplacer(key, parent, stack, replacer, spacer, indentation) {
@@ -361,7 +372,7 @@ ${indentation}`;
           }
           const maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
           if (deterministic && !isTypedArrayWithEntries(value)) {
-            keys = insertSort(keys);
+            keys = sort(keys, comparator);
           }
           stack.push(value);
           for (let i = 0; i < maximumPropertiesToStringify; i++) {
@@ -562,7 +573,7 @@ ${indentation}`;
             separator = join;
           }
           if (deterministic) {
-            keys = insertSort(keys);
+            keys = sort(keys, comparator);
           }
           stack.push(value);
           for (let i = 0; i < maximumPropertiesToStringify; i++) {
@@ -621,7 +632,8 @@ ${originalIndentation}`;
             return circularValue;
           }
           let res = "";
-          if (Array.isArray(value)) {
+          const hasLength = value.length !== void 0;
+          if (hasLength && Array.isArray(value)) {
             if (value.length === 0) {
               return "[]";
             }
@@ -655,14 +667,14 @@ ${originalIndentation}`;
           }
           let separator = "";
           let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
-          if (isTypedArrayWithEntries(value)) {
+          if (hasLength && isTypedArrayWithEntries(value)) {
             res += stringifyTypedArray(value, ",", maximumBreadth);
             keys = keys.slice(value.length);
             maximumPropertiesToStringify -= value.length;
             separator = ",";
           }
           if (deterministic) {
-            keys = insertSort(keys);
+            keys = sort(keys, comparator);
           }
           stack.push(value);
           for (let i = 0; i < maximumPropertiesToStringify; i++) {
@@ -750,2083 +762,237 @@ function v4(options, buf, offset) {
   }
   options = options || {};
   const rnds = options.random || (options.rng || rng)();
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  return unsafeStringify(rnds);
-}
-function setNameOperation(document, name) {
-  return { ...document, name };
-}
-function undoOperation(document, action, skip) {
-  const { scope, input } = action;
-  const defaultResult = {
-    document,
-    action,
-    skip
-  };
-  return create(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 create(defaultResult, (draft) => {
-    if (draft.skip > 0) {
-      throw new Error(
-        `Cannot redo: skip value from reducer cannot be used with REDO action`
-      );
-    }
-    if (input > 1) {
-      throw new Error(
-        `Cannot redo: you can only redo one operation at a time`
-      );
-    }
-    if (input < 1) {
-      throw new Error(`Invalid REDO action: invalid redo input value`);
-    }
-    if (draft.document.clipboard.length < 1) {
-      throw new Error(`Cannot redo: no operations in the clipboard`);
-    }
-    const operationIndex = draft.document.clipboard.findLastIndex(
-      (op) => op.scope === scope
-    );
-    if (operationIndex < 0) {
-      throw new Error(
-        `Cannot redo: no operations in clipboard for scope "${scope}"`
-      );
-    }
-    const operation = draft.document.clipboard.splice(operationIndex, 1)[0];
-    draft.action = castDraft({
-      type: operation.type,
-      scope: operation.scope,
-      input: operation.input
-    });
-  });
-}
-function pruneOperation(document, action, wrappedReducer) {
-  const { scope } = action;
-  const operations = document.operations[scope];
-  let {
-    input: { start, end }
-  } = action;
-  start = start || 0;
-  end = end || operations.length;
-  const actionsToPrune = operations.slice(start, end);
-  const actionsToKeepStart = operations.slice(0, start);
-  const actionsToKeepEnd = operations.slice(end);
-  const newDocument = replayOperations(
-    document.initialState,
-    {
-      ...document.operations,
-      [scope]: actionsToKeepStart.concat(actionsToPrune)
-    },
-    wrappedReducer
-  );
-  const { name, state: newState } = newDocument;
-  const loadStateIndex = actionsToKeepStart.length;
-  const loadStateTimestamp = actionsToKeepStart.length ? actionsToKeepStart[actionsToKeepStart.length - 1].timestamp : actionsToKeepEnd.length ? actionsToKeepEnd[0].timestamp : (/* @__PURE__ */ new Date()).toISOString();
-  return replayOperations(
-    document.initialState,
-    {
-      ...document.operations,
-      [scope]: [
-        ...actionsToKeepStart,
-        {
-          ...loadState(
-            { name, state: newState },
-            actionsToPrune.length
-          ),
-          timestamp: loadStateTimestamp,
-          index: loadStateIndex,
-          hash: hashDocument({ state: newState }, "global")
-        },
-        ...actionsToKeepEnd.map((action2, index) => ({
-          ...action2,
-          index: loadStateIndex + index + 1
-        }))
-      ]
-    },
-    wrappedReducer
-  );
-}
-function loadStateOperation(oldDocument, newDocument) {
-  return {
-    ...oldDocument,
-    name: newDocument.name,
-    state: newDocument.state ?? { global: {}, local: {} }
-  };
-}
-const SET_NAME = "SET_NAME";
-const UNDO = "UNDO";
-const REDO = "REDO";
-const PRUNE = "PRUNE";
-const LOAD_STATE = "LOAD_STATE";
-const NOOP = "NOOP";
-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
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  return unsafeStringify(rnds);
+}
+const K = [
+  1518500249 | 0,
+  1859775393 | 0,
+  2400959708 | 0,
+  3395469782 | 0
+];
+function createHash(algorithm) {
+  return new Hash();
+}
+class Hash {
+  constructor() {
+    this.A = 1732584193 | 0;
+    this.B = 4023233417 | 0;
+    this.C = 2562383102 | 0;
+    this.D = 271733878 | 0;
+    this.E = 3285377520 | 0;
+    this._size = 0;
+    this._sp = 0;
+    if (!sharedBuffer || sharedOffset >= 8e3) {
+      sharedBuffer = new ArrayBuffer(
+        8e3
+        /* N.allocTotal */
       );
+      sharedOffset = 0;
     }
-    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;
-        }
+    this._byte = new Uint8Array(
+      sharedBuffer,
+      sharedOffset,
+      80
+      /* N.allocBytes */
+    );
+    this._word = new Int32Array(
+      sharedBuffer,
+      sharedOffset,
+      20
+      /* N.allocWords */
+    );
+    sharedOffset += 80;
+  }
+  update(data) {
+    if ("string" === typeof data) {
+      return this._utf8(data);
+    }
+    if (data == null) {
+      throw new TypeError("Invalid type: " + typeof data);
+    }
+    const byteOffset = data.byteOffset;
+    const length = data.byteLength;
+    let blocks = length / 64 | 0;
+    let offset = 0;
+    if (blocks && !(byteOffset & 3) && !(this._size % 64)) {
+      const block = new Int32Array(
+        data.buffer,
+        byteOffset,
+        blocks * 16
+        /* N.inputWords */
+      );
+      while (blocks--) {
+        this._int32(block, offset >> 2);
+        offset += 64;
       }
-    } else if (typeof val === "number") {
-      val = val & 255;
-    } else if (typeof val === "boolean") {
-      val = Number(val);
+      this._size += offset;
     }
-    if (start < 0 || this.length < start || this.length < end) {
-      throw new RangeError("Out of range index");
+    const BYTES_PER_ELEMENT = data.BYTES_PER_ELEMENT;
+    if (BYTES_PER_ELEMENT !== 1 && data.buffer) {
+      const rest = new Uint8Array(data.buffer, byteOffset + offset, length - offset);
+      return this._uint8(rest);
     }
-    if (end <= start) {
+    if (offset === length)
       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"');
+    return this._uint8(data, offset);
+  }
+  _uint8(data, offset) {
+    const { _byte, _word } = this;
+    const length = data.length;
+    offset = offset | 0;
+    while (offset < length) {
+      const start = this._size % 64;
+      let index = start;
+      while (offset < length && index < 64) {
+        _byte[index++] = data[offset++];
       }
-      for (i = 0; i < end - start; ++i) {
-        this[i + start] = bytes[i % len];
+      if (index >= 64) {
+        this._int32(_word);
       }
+      this._size += index - start;
     }
     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;
+  _utf8(text) {
+    const { _byte, _word } = this;
+    const length = text.length;
+    let surrogate = this._sp;
+    for (let offset = 0; offset < length; ) {
+      const start = this._size % 64;
+      let index = start;
+      while (offset < length && index < 64) {
+        let code = text.charCodeAt(offset++) | 0;
+        if (code < 128) {
+          _byte[index++] = code;
+        } else if (code < 2048) {
+          _byte[index++] = 192 | code >>> 6;
+          _byte[index++] = 128 | code & 63;
+        } else if (code < 55296 || code > 57343) {
+          _byte[index++] = 224 | code >>> 12;
+          _byte[index++] = 128 | code >>> 6 & 63;
+          _byte[index++] = 128 | code & 63;
+        } else if (surrogate) {
+          code = ((surrogate & 1023) << 10) + (code & 1023) + 65536;
+          _byte[index++] = 240 | code >>> 18;
+          _byte[index++] = 128 | code >>> 12 & 63;
+          _byte[index++] = 128 | code >>> 6 & 63;
+          _byte[index++] = 128 | code & 63;
+          surrogate = 0;
+        } else {
+          surrogate = code;
         }
-        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);
+      if (index >= 64) {
+        this._int32(_word);
+        _word[0] = _word[
+          16
+          /* N.inputWords */
+        ];
       }
-    } 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._size += index - start;
     }
+    this._sp = surrogate;
+    return this;
   }
-  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;
-}
+  _int32(data, offset) {
+    let { A, B, C, D, E } = this;
+    let i = 0;
+    offset = offset | 0;
+    while (i < 16) {
+      W[i++] = swap32(data[offset++]);
+    }
+    for (i = 16; i < 80; i++) {
+      W[i] = rotate1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]);
+    }
+    for (i = 0; i < 80; i++) {
+      const S = i / 20 | 0;
+      const T = rotate5(A) + ft(S, B, C, D) + E + W[i] + K[S] | 0;
+      E = D;
+      D = C;
+      C = rotate30(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;
+  }
+  digest(encoding) {
+    const { _byte, _word } = this;
+    let i = this._size % 64 | 0;
+    _byte[i++] = 128;
+    while (i & 3) {
+      _byte[i++] = 0;
+    }
+    i >>= 2;
+    if (i > 14) {
+      while (i < 16) {
+        _word[i++] = 0;
+      }
+      i = 0;
+      this._int32(_word);
+    }
+    while (i < 16) {
+      _word[i++] = 0;
+    }
+    const bits64 = this._size * 8;
+    const low32 = (bits64 & 4294967295) >>> 0;
+    const high32 = (bits64 - low32) / 4294967296;
+    if (high32)
+      _word[
+        14
+        /* N.highIndex */
+      ] = swap32(high32);
+    if (low32)
+      _word[
+        15
+        /* N.lowIndex */
+      ] = swap32(low32);
+    this._int32(_word);
+    return encoding === "hex" ? this._hex() : this._bin();
+  }
+  _hex() {
+    const { A, B, C, D, E } = this;
+    return hex32(A) + hex32(B) + hex32(C) + hex32(D) + hex32(E);
+  }
+  _bin() {
+    const { A, B, C, D, E, _byte, _word } = this;
+    _word[0] = swap32(A);
+    _word[1] = swap32(B);
+    _word[2] = swap32(C);
+    _word[3] = swap32(D);
+    _word[4] = swap32(E);
+    return _byte.slice(0, 20);
+  }
+}
+const W = new Int32Array(
+  80
+  /* N.workWords */
+);
+let sharedBuffer;
+let sharedOffset = 0;
+const hex32 = (num) => (num + 4294967296).toString(16).substr(-8);
+const swapLE = (c) => c << 24 & 4278190080 | c << 8 & 16711680 | c >> 8 & 65280 | c >> 24 & 255;
+const swapBE = (c) => c;
+const swap32 = isBE() ? swapBE : swapLE;
+const rotate1 = (num) => num << 1 | num >>> 31;
+const rotate5 = (num) => num << 5 | num >>> 27;
+const rotate30 = (num) => 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;
+  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 isBE() {
+  const buf = new Uint8Array(new Uint16Array([65279]).buffer);
+  return buf[0] === 254;
 }
-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;
@@ -2840,20 +1006,27 @@ function fetchFile(url) {
 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"
-    );
+  if (!["sha1"].includes(algorithm)) {
+    throw new Error("Hashing algorithm not supported: Available: sha1");
   }
-  const Algorithm = hashAlgorithms[algorithm];
-  const sha = new Algorithm();
-  return sha.update(data).digest("base64");
+  const hash2 = hashUIntArray(data);
+  return uint8ArrayToBase64(hash2);
 };
+function uint8ArrayToBase64(uint8Array) {
+  let binaryString = "";
+  for (let i = 0; i < uint8Array.length; i++) {
+    binaryString += String.fromCharCode(uint8Array[i]);
+  }
+  const base64String = btoa(binaryString);
+  return base64String;
+}
+function hashUIntArray(data, algorithm = "sha1") {
+  if (!["sha1"].includes(algorithm)) {
+    throw new Error("Hashing algorithm not supported: Available: sha1");
+  }
+  return createHash().update(data).digest();
+}
 function getUnixTimestamp(date) {
   return (new Date(date).getTime() / 1e3).toFixed(0);
 }
@@ -3378,6 +1551,13 @@ function filterDocumentOperationsResultingState(documentOperations) {
     {}
   );
 }
+function diffOperations(clearedOperationsA, clearedOperationsB) {
+  return clearedOperationsA.filter(
+    (operationA) => !clearedOperationsB.some(
+      (operationB) => operationA.index === operationB.index
+    )
+  );
+}
 const documentHelpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   IntegrityIssueSubType,
@@ -3386,6 +1566,7 @@ const documentHelpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.def
   attachBranch,
   checkCleanedOperationsIntegrity,
   checkOperationsIntegrity,
+  diffOperations,
   filterDocumentOperationsResultingState,
   filterDuplicatedOperations,
   garbageCollect,
@@ -3516,9 +1697,9 @@ function getFileAttributes(file) {
   return { extension, fileName };
 }
 async function getRemoteFile(url) {
-  const { buffer: buffer2, mimeType = "application/octet-stream" } = await fetchFile();
+  const { buffer, mimeType = "application/octet-stream" } = await fetchFile();
   const attributes = getFileAttributes(url);
-  const data = buffer2.toString("base64");
+  const data = buffer.toString("base64");
   return {
     data,
     hash: hash(data),
@@ -3527,12 +1708,147 @@ async function getRemoteFile(url) {
   };
 }
 async function getLocalFile(path) {
-  const buffer2 = await getFile();
+  const buffer = await getFile();
   const mimeType = mime.getType(path) || "application/octet-stream";
   const attributes = getFileAttributes(path);
-  const data = buffer2.toString("base64");
+  const data = buffer.toString("base64");
   return { data, hash: hash(data), mimeType, ...attributes };
 }
+function setNameOperation(document, name) {
+  return { ...document, name };
+}
+function undoOperation(document, action, skip) {
+  const { scope, input } = action;
+  const defaultResult = {
+    document,
+    action,
+    skip,
+    reuseLastOperationIndex: false
+  };
+  return create(defaultResult, (draft) => {
+    const operations = [...document.operations[scope]];
+    const sortedOperations = sortOperations$1(operations);
+    draft.action = noop(scope);
+    const lastOperation = sortedOperations.at(-1);
+    let nextIndex = (lastOperation == null ? void 0 : lastOperation.index) ?? -1;
+    const isNewNoop = (lastOperation == null ? void 0 : lastOperation.type) !== "NOOP";
+    if (isNewNoop) {
+      nextIndex = nextIndex + 1;
+    } else {
+      draft.reuseLastOperationIndex = true;
+    }
+    const nextOperationHistory = isNewNoop ? [...sortedOperations, { index: nextIndex, skip: 0 }] : sortedOperations;
+    draft.skip = nextSkipNumber(nextOperationHistory);
+    if (lastOperation && draft.skip > lastOperation.skip + 1) {
+      draft.skip = draft.skip + 1;
+    }
+    if (draft.skip < 0) {
+      throw new Error(
+        `Cannot undo: you can't undo more operations than the ones in the scope history`
+      );
+    }
+  });
+}
+function redoOperation(document, action, skip) {
+  const { scope, input } = action;
+  const defaultResult = {
+    document,
+    action,
+    skip,
+    reuseLastOperationIndex: false
+  };
+  return create(defaultResult, (draft) => {
+    if (draft.skip > 0) {
+      throw new Error(
+        `Cannot redo: skip value from reducer cannot be used with REDO action`
+      );
+    }
+    if (input > 1) {
+      throw new Error(
+        `Cannot redo: you can only redo one operation at a time`
+      );
+    }
+    if (input < 1) {
+      throw new Error(`Invalid REDO action: invalid redo input value`);
+    }
+    if (draft.document.clipboard.length < 1) {
+      throw new Error(`Cannot redo: no operations in the clipboard`);
+    }
+    const operationIndex = draft.document.clipboard.findLastIndex(
+      (op) => op.scope === scope
+    );
+    if (operationIndex < 0) {
+      throw new Error(
+        `Cannot redo: no operations in clipboard for scope "${scope}"`
+      );
+    }
+    const operation = draft.document.clipboard.splice(operationIndex, 1)[0];
+    draft.action = castDraft({
+      type: operation.type,
+      scope: operation.scope,
+      input: operation.input
+    });
+  });
+}
+function pruneOperation(document, action, wrappedReducer) {
+  const { scope } = action;
+  const operations = document.operations[scope];
+  let {
+    input: { start, end }
+  } = action;
+  start = start || 0;
+  end = end || operations.length;
+  const actionsToPrune = operations.slice(start, end);
+  const actionsToKeepStart = operations.slice(0, start);
+  const actionsToKeepEnd = operations.slice(end);
+  const newDocument = replayOperations(
+    document.initialState,
+    {
+      ...document.operations,
+      [scope]: actionsToKeepStart.concat(actionsToPrune)
+    },
+    wrappedReducer
+  );
+  const { name, state: newState } = newDocument;
+  const loadStateIndex = actionsToKeepStart.length;
+  const loadStateTimestamp = actionsToKeepStart.length ? actionsToKeepStart[actionsToKeepStart.length - 1].timestamp : actionsToKeepEnd.length ? actionsToKeepEnd[0].timestamp : (/* @__PURE__ */ new Date()).toISOString();
+  return replayOperations(
+    document.initialState,
+    {
+      ...document.operations,
+      [scope]: [
+        ...actionsToKeepStart,
+        {
+          ...loadState(
+            { name, state: newState },
+            actionsToPrune.length
+          ),
+          timestamp: loadStateTimestamp,
+          index: loadStateIndex,
+          hash: hashDocument({ state: newState }, "global")
+        },
+        ...actionsToKeepEnd.map((action2, index) => ({
+          ...action2,
+          index: loadStateIndex + index + 1
+        }))
+      ]
+    },
+    wrappedReducer
+  );
+}
+function loadStateOperation(oldDocument, newDocument) {
+  return {
+    ...oldDocument,
+    name: newDocument.name,
+    state: newDocument.state ?? { global: {}, local: {} }
+  };
+}
+const SET_NAME = "SET_NAME";
+const UNDO = "UNDO";
+const REDO = "REDO";
+const PRUNE = "PRUNE";
+const LOAD_STATE = "LOAD_STATE";
+const NOOP = "NOOP";
 function getNextRevision(document, action) {
   let latestOperation;
   if ("index" in action) {
@@ -3552,7 +1868,7 @@ function updateHeader(document, action) {
     lastModified: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function updateOperations(document, action, skip = 0) {
+function updateOperations(document, action, skip = 0, reuseLastOperationIndex = false) {
   if ([UNDO, REDO, PRUNE].includes(action.type)) {
     return document;
   }
@@ -3560,7 +1876,8 @@ function updateOperations(document, action, skip = 0) {
   const operations = document.operations[scope].slice();
   let operationId;
   const latestOperation = operations.at(-1);
-  let nextIndex = ((latestOperation == null ? void 0 : latestOperation.index) ?? -1) + 1;
+  const lastOperationIndex = (latestOperation == null ? void 0 : latestOperation.index) ?? -1;
+  let nextIndex = reuseLastOperationIndex ? lastOperationIndex : lastOperationIndex + 1;
   if ("index" in action) {
     if (action.index - skip > nextIndex) {
       throw new Error(
@@ -3587,8 +1904,13 @@ function updateOperations(document, action, skip = 0) {
     operations: { ...document.operations, [scope]: operations }
   };
 }
-function updateDocument(document, action, skip = 0) {
-  let newDocument = updateOperations(document, action, skip);
+function updateDocument(document, action, skip = 0, reuseLastOperationIndex = false) {
+  let newDocument = updateOperations(
+    document,
+    action,
+    skip,
+    reuseLastOperationIndex
+  );
   newDocument = updateHeader(newDocument, action);
   return newDocument;
 }
@@ -3612,7 +1934,7 @@ function processUndoRedo(document, action, skip) {
     case REDO:
       return redoOperation(document, action, skip);
     default:
-      return { document, action, skip };
+      return { document, action, skip, reuseLastOperationIndex: false };
   }
 }
 function processSkipOperation(document, action, customReducer, skipValue, reuseOperationResultingState = false, resultingStateParser = parseResultingState) {
@@ -3662,6 +1984,37 @@ function processSkipOperation(document, action, customReducer, skipValue, reuseO
     })
   };
 }
+function processUndoOperation(document, scope, customReducer, reuseOperationResultingState = false, resultingStateParser = parseResultingState) {
+  const operations = [...document.operations[scope]];
+  const sortedOperations = sortOperations$1(operations);
+  sortedOperations.pop();
+  const documentOperations = garbageCollectDocumentOperations(
+    { ...document.operations }
+  );
+  const clearedOperations = [...documentOperations[scope]];
+  const diff = diffOperations(
+    garbageCollect(sortedOperations),
+    clearedOperations
+  );
+  const doc = replayOperations(
+    document.initialState,
+    documentOperations,
+    customReducer,
+    void 0,
+    void 0,
+    void 0,
+    void 0,
+    {
+      reuseHash: true,
+      reuseOperationResultingState,
+      operationResultingStateParser: resultingStateParser
+    }
+  );
+  const clipboard = sortOperations$1(
+    [...document.clipboard, ...diff].filter((op) => op.type !== "NOOP")
+  ).reverse();
+  return { ...doc, clipboard };
+}
 function baseReducer(document, action, customReducer, dispatch, options = {}) {
   const {
     skip,
@@ -3670,14 +2023,46 @@ function baseReducer(document, action, customReducer, dispatch, options = {}) {
     reuseOperationResultingState = false,
     operationResultingStateParser
   } = options;
-  const _action = { ...action };
-  const skipValue = skip || 0;
+  let _action = { ...action };
+  let skipValue = skip || 0;
   let newDocument = { ...document };
+  let reuseLastOperationIndex = false;
   const shouldProcessSkipOperation = !ignoreSkipOperations && (skipValue > 0 || "index" in _action && _action.skip > 0);
+  if (isUndoRedo(_action)) {
+    const {
+      skip: calculatedSkip,
+      action: transformedAction,
+      document: processedDocument,
+      reuseLastOperationIndex: reuseIndex
+    } = processUndoRedo(document, _action, skipValue);
+    _action = transformedAction;
+    skipValue = calculatedSkip;
+    newDocument = processedDocument;
+    reuseLastOperationIndex = reuseIndex;
+  } else {
+    newDocument = {
+      ...newDocument,
+      clipboard: []
+    };
+  }
   if (isBaseAction(_action)) {
     newDocument = _baseReducer(newDocument, _action, customReducer);
   }
-  newDocument = updateDocument(newDocument, _action, skipValue);
+  newDocument = updateDocument(
+    newDocument,
+    _action,
+    skipValue,
+    reuseLastOperationIndex
+  );
+  const isUndoAction = isUndo(action);
+  if (isUndoAction) {
+    const result = processUndoOperation(
+      newDocument,
+      action.scope,
+      customReducer
+    );
+    return result;
+  }
   if (shouldProcessSkipOperation) {
     newDocument = processSkipOperation(
       newDocument,
@@ -3817,6 +2202,9 @@ function isNoopOperation(op) {
 function isUndoRedo(action) {
   return [UNDO, REDO].includes(action.type);
 }
+function isUndo(action) {
+  return action.type === UNDO;
+}
 function isBaseAction(action) {
   return [SET_NAME, UNDO, REDO, PRUNE, LOAD_STATE].includes(action.type);
 }
@@ -3912,23 +2300,6 @@ function mapSkippedOperations(operations, skippedHeadOperations) {
   }
   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()
@@ -4294,9 +2665,9 @@ function applyMixins(derivedCtor, constructors) {
   });
 }
 export {
-  isNoopOperation as A,
+  isSameDocument as A,
   BaseDocument as B,
-  isSameDocument as C,
+  isUndo as C,
   isUndoRedo as D,
   mapSkippedOperations as E,
   parseResultingState as F,
@@ -4328,16 +2699,16 @@ export {
   buildOperationSignatureMessage as m,
   buildOperationSignatureParams as n,
   buildSignedOperation as o,
-  calculateSkipsLeft as p,
-  createUnsafeReducer as q,
-  createZip as r,
+  createUnsafeReducer as p,
+  createZip as q,
+  documentHelpers as r,
   saveToFile as s,
-  documentHelpers as t,
-  getLocalFile as u,
-  getRemoteFile as v,
-  getUnixTimestamp as w,
-  hashDocument as x,
-  hashKey as y,
-  hex2ab as z
+  getLocalFile as t,
+  getRemoteFile as u,
+  getUnixTimestamp as v,
+  hashDocument as w,
+  hashKey as x,
+  hex2ab as y,
+  isNoopOperation as z
 };
-//# sourceMappingURL=object-CY74acQg.js.map
+//# sourceMappingURL=object-CU5T1DpX.js.map