{"version":3,"file":"./build/core-data/index.min.js","mappings":"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","sources":["webpack://wp/./node_modules/equivalent-key-map/equivalent-key-map.js","webpack://wp/./node_modules/fast-deep-equal/es6/index.js","webpack://wp/./node_modules/simple-peer/simplepeer.min.js","webpack://wp/webpack/bootstrap","webpack://wp/webpack/runtime/compat get default export","webpack://wp/webpack/runtime/define property getters","webpack://wp/webpack/runtime/global","webpack://wp/webpack/runtime/hasOwnProperty shorthand","webpack://wp/webpack/runtime/make namespace object","webpack://wp/external window [\"wp\",\"data\"]","webpack://wp/external window [\"wp\",\"compose\"]","webpack://wp/external window [\"wp\",\"isShallowEqual\"]","../../packages/undo-manager/src/index.js","../../packages/core-data/src/utils/if-matching-action.js","../../packages/core-data/src/utils/replace-action.js","../../packages/core-data/src/utils/on-sub-key.js","webpack://wp/./node_modules/tslib/tslib.es6.mjs","webpack://wp/./node_modules/lower-case/src/index.ts","webpack://wp/./node_modules/no-case/src/index.ts","webpack://wp/./node_modules/capital-case/src/index.ts","webpack://wp/./node_modules/upper-case-first/src/index.ts","webpack://wp/./node_modules/pascal-case/src/index.ts","webpack://wp/external window [\"wp\",\"apiFetch\"]","webpack://wp/external window [\"wp\",\"i18n\"]","webpack://wp/external window [\"wp\",\"richText\"]","../../packages/core-data/src/entities.js","webpack://wp/external window [\"wp\",\"url\"]","../../packages/core-data/src/utils/get-normalized-comma-separable.js","../../packages/core-data/src/queried-data/get-query-parts.js","../../packages/core-data/src/utils/with-weak-map-cache.js","../../packages/core-data/src/queried-data/reducer.js","../../packages/core-data/src/utils/conservative-map-item.js","../../packages/core-data/src/reducer.js","webpack://wp/external window [\"wp\",\"deprecated\"]","../../packages/core-data/src/name.js","../../packages/core-data/src/utils/set-nested-value.js","../../packages/core-data/src/queried-data/selectors.js","../../packages/core-data/src/utils/user-permissions.js","../../packages/core-data/src/selectors.ts","../../packages/core-data/src/utils/is-numeric-id.js","../../packages/core-data/src/utils/is-raw-attribute.js","webpack://wp/external window [\"wp\",\"privateApis\"]","../../packages/core-data/src/lock-unlock.ts","../../packages/core-data/src/private-selectors.ts","webpack://wp/./packages/core-data/node_modules/uuid/dist/esm-browser/rng.js","webpack://wp/./packages/core-data/node_modules/uuid/dist/esm-browser/regex.js","webpack://wp/./packages/core-data/node_modules/uuid/dist/esm-browser/stringify.js","webpack://wp/./packages/core-data/node_modules/uuid/dist/esm-browser/validate.js","webpack://wp/./packages/core-data/node_modules/uuid/dist/esm-browser/v4.js","../../packages/core-data/src/utils/get-nested-value.js","../../packages/core-data/src/queried-data/actions.js","../../packages/core-data/src/batch/default-processor.js","../../packages/core-data/src/batch/create-batch.js","webpack://wp/./node_modules/lib0/map.js","webpack://wp/./node_modules/lib0/set.js","webpack://wp/./node_modules/lib0/array.js","webpack://wp/./node_modules/lib0/observable.js","webpack://wp/./node_modules/lib0/math.js","webpack://wp/./node_modules/lib0/string.js","webpack://wp/./node_modules/lib0/storage.js","webpack://wp/./node_modules/lib0/object.js","webpack://wp/./node_modules/lib0/function.js","webpack://wp/./node_modules/lib0/environment.js","webpack://wp/./node_modules/lib0/conditions.js","webpack://wp/./node_modules/lib0/buffer.js","webpack://wp/./node_modules/lib0/binary.js","webpack://wp/./node_modules/lib0/number.js","webpack://wp/./node_modules/lib0/encoding.js","webpack://wp/./node_modules/lib0/error.js","webpack://wp/./node_modules/lib0/decoding.js","webpack://wp/./node_modules/lib0/webcrypto.js","webpack://wp/./node_modules/lib0/random.js","webpack://wp/./node_modules/lib0/promise.js","webpack://wp/./node_modules/lib0/pair.js","webpack://wp/./node_modules/lib0/dom.js","webpack://wp/./node_modules/lib0/symbol.js","webpack://wp/./node_modules/lib0/time.js","webpack://wp/./node_modules/lib0/logging.common.js","webpack://wp/./node_modules/lib0/logging.js","webpack://wp/./node_modules/lib0/iterator.js","webpack://wp/./node_modules/yjs/dist/yjs.mjs","../../packages/sync/src/provider.js","webpack://wp/./node_modules/lib0/indexeddb.js","webpack://wp/./node_modules/y-indexeddb/src/y-indexeddb.js","../../packages/sync/src/connect-indexdb.js","webpack://wp/./node_modules/lib0/websocket.js","webpack://wp/./node_modules/lib0/broadcastchannel.js","webpack://wp/./node_modules/y-protocols/sync.js","webpack://wp/./node_modules/y-protocols/awareness.js","../../packages/sync/src/y-webrtc/crypto.js","../../packages/sync/src/y-webrtc/y-webrtc.js","webpack://wp/./node_modules/lib0/mutex.js","../../packages/sync/src/webrtc-http-stream-signaling.js","../../packages/core-data/src/sync.js","../../packages/sync/src/create-webrtc-connection.js","../../packages/core-data/src/actions.js","../../packages/core-data/src/private-actions.js","webpack://wp/./node_modules/camel-case/src/index.ts","webpack://wp/external window [\"wp\",\"htmlEntities\"]","../../packages/core-data/src/utils/forward-resolver.js","../../packages/core-data/src/utils/receive-intermediate-results.js","../../packages/core-data/src/fetch/__experimental-fetch-link-suggestions.ts","../../packages/core-data/src/fetch/__experimental-fetch-url-data.js","../../packages/core-data/src/fetch/index.js","../../packages/core-data/src/resolvers.js","../../packages/core-data/src/locks/utils.js","../../packages/core-data/src/locks/reducer.js","../../packages/core-data/src/locks/selectors.js","../../packages/core-data/src/locks/engine.js","webpack://wp/external window [\"wp\",\"element\"]","../../packages/core-data/src/entity-context.js","webpack://wp/external window \"ReactJSXRuntime\"","../../packages/core-data/src/entity-provider.js","../../packages/core-data/src/hooks/constants.ts","../../packages/core-data/src/hooks/use-query-select.ts","webpack://wp/./node_modules/memize/dist/index.js","../../packages/core-data/src/hooks/use-entity-record.ts","../../packages/core-data/src/hooks/use-entity-records.ts","../../packages/core-data/src/hooks/use-resource-permissions.ts","webpack://wp/external window [\"wp\",\"warning\"]","webpack://wp/external window [\"wp\",\"blocks\"]","../../packages/core-data/src/hooks/use-entity-id.js","webpack://wp/external window [\"wp\",\"blockEditor\"]","../../packages/core-data/src/footnotes/get-rich-text-values-cached.js","../../packages/core-data/src/footnotes/get-footnotes-order.js","../../packages/core-data/src/footnotes/index.js","../../packages/core-data/src/hooks/use-entity-block-editor.js","../../packages/core-data/src/hooks/use-entity-prop.js","../../packages/core-data/src/private-apis.js","../../packages/core-data/src/index.js","../../packages/core-data/src/locks/actions.js"],"sourcesContent":["'use strict';\n\nfunction _typeof(obj) {\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function (obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function (obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\n/**\n * Given an instance of EquivalentKeyMap, returns its internal value pair tuple\n * for a key, if one exists. The tuple members consist of the last reference\n * value for the key (used in efficient subsequent lookups) and the value\n * assigned for the key at the leaf node.\n *\n * @param {EquivalentKeyMap} instance EquivalentKeyMap instance.\n * @param {*} key                     The key for which to return value pair.\n *\n * @return {?Array} Value pair, if exists.\n */\nfunction getValuePair(instance, key) {\n  var _map = instance._map,\n      _arrayTreeMap = instance._arrayTreeMap,\n      _objectTreeMap = instance._objectTreeMap; // Map keeps a reference to the last object-like key used to set the\n  // value, which can be used to shortcut immediately to the value.\n\n  if (_map.has(key)) {\n    return _map.get(key);\n  } // Sort keys to ensure stable retrieval from tree.\n\n\n  var properties = Object.keys(key).sort(); // Tree by type to avoid conflicts on numeric object keys, empty value.\n\n  var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap;\n\n  for (var i = 0; i < properties.length; i++) {\n    var property = properties[i];\n    map = map.get(property);\n\n    if (map === undefined) {\n      return;\n    }\n\n    var propertyValue = key[property];\n    map = map.get(propertyValue);\n\n    if (map === undefined) {\n      return;\n    }\n  }\n\n  var valuePair = map.get('_ekm_value');\n\n  if (!valuePair) {\n    return;\n  } // If reached, it implies that an object-like key was set with another\n  // reference, so delete the reference and replace with the current.\n\n\n  _map.delete(valuePair[0]);\n\n  valuePair[0] = key;\n  map.set('_ekm_value', valuePair);\n\n  _map.set(key, valuePair);\n\n  return valuePair;\n}\n/**\n * Variant of a Map object which enables lookup by equivalent (deeply equal)\n * object and array keys.\n */\n\n\nvar EquivalentKeyMap =\n/*#__PURE__*/\nfunction () {\n  /**\n   * Constructs a new instance of EquivalentKeyMap.\n   *\n   * @param {Iterable.<*>} iterable Initial pair of key, value for map.\n   */\n  function EquivalentKeyMap(iterable) {\n    _classCallCheck(this, EquivalentKeyMap);\n\n    this.clear();\n\n    if (iterable instanceof EquivalentKeyMap) {\n      // Map#forEach is only means of iterating with support for IE11.\n      var iterablePairs = [];\n      iterable.forEach(function (value, key) {\n        iterablePairs.push([key, value]);\n      });\n      iterable = iterablePairs;\n    }\n\n    if (iterable != null) {\n      for (var i = 0; i < iterable.length; i++) {\n        this.set(iterable[i][0], iterable[i][1]);\n      }\n    }\n  }\n  /**\n   * Accessor property returning the number of elements.\n   *\n   * @return {number} Number of elements.\n   */\n\n\n  _createClass(EquivalentKeyMap, [{\n    key: \"set\",\n\n    /**\n     * Add or update an element with a specified key and value.\n     *\n     * @param {*} key   The key of the element to add.\n     * @param {*} value The value of the element to add.\n     *\n     * @return {EquivalentKeyMap} Map instance.\n     */\n    value: function set(key, value) {\n      // Shortcut non-object-like to set on internal Map.\n      if (key === null || _typeof(key) !== 'object') {\n        this._map.set(key, value);\n\n        return this;\n      } // Sort keys to ensure stable assignment into tree.\n\n\n      var properties = Object.keys(key).sort();\n      var valuePair = [key, value]; // Tree by type to avoid conflicts on numeric object keys, empty value.\n\n      var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap;\n\n      for (var i = 0; i < properties.length; i++) {\n        var property = properties[i];\n\n        if (!map.has(property)) {\n          map.set(property, new EquivalentKeyMap());\n        }\n\n        map = map.get(property);\n        var propertyValue = key[property];\n\n        if (!map.has(propertyValue)) {\n          map.set(propertyValue, new EquivalentKeyMap());\n        }\n\n        map = map.get(propertyValue);\n      } // If an _ekm_value exists, there was already an equivalent key. Before\n      // overriding, ensure that the old key reference is removed from map to\n      // avoid memory leak of accumulating equivalent keys. This is, in a\n      // sense, a poor man's WeakMap, while still enabling iterability.\n\n\n      var previousValuePair = map.get('_ekm_value');\n\n      if (previousValuePair) {\n        this._map.delete(previousValuePair[0]);\n      }\n\n      map.set('_ekm_value', valuePair);\n\n      this._map.set(key, valuePair);\n\n      return this;\n    }\n    /**\n     * Returns a specified element.\n     *\n     * @param {*} key The key of the element to return.\n     *\n     * @return {?*} The element associated with the specified key or undefined\n     *              if the key can't be found.\n     */\n\n  }, {\n    key: \"get\",\n    value: function get(key) {\n      // Shortcut non-object-like to get from internal Map.\n      if (key === null || _typeof(key) !== 'object') {\n        return this._map.get(key);\n      }\n\n      var valuePair = getValuePair(this, key);\n\n      if (valuePair) {\n        return valuePair[1];\n      }\n    }\n    /**\n     * Returns a boolean indicating whether an element with the specified key\n     * exists or not.\n     *\n     * @param {*} key The key of the element to test for presence.\n     *\n     * @return {boolean} Whether an element with the specified key exists.\n     */\n\n  }, {\n    key: \"has\",\n    value: function has(key) {\n      if (key === null || _typeof(key) !== 'object') {\n        return this._map.has(key);\n      } // Test on the _presence_ of the pair, not its value, as even undefined\n      // can be a valid member value for a key.\n\n\n      return getValuePair(this, key) !== undefined;\n    }\n    /**\n     * Removes the specified element.\n     *\n     * @param {*} key The key of the element to remove.\n     *\n     * @return {boolean} Returns true if an element existed and has been\n     *                   removed, or false if the element does not exist.\n     */\n\n  }, {\n    key: \"delete\",\n    value: function _delete(key) {\n      if (!this.has(key)) {\n        return false;\n      } // This naive implementation will leave orphaned child trees. A better\n      // implementation should traverse and remove orphans.\n\n\n      this.set(key, undefined);\n      return true;\n    }\n    /**\n     * Executes a provided function once per each key/value pair, in insertion\n     * order.\n     *\n     * @param {Function} callback Function to execute for each element.\n     * @param {*}        thisArg  Value to use as `this` when executing\n     *                            `callback`.\n     */\n\n  }, {\n    key: \"forEach\",\n    value: function forEach(callback) {\n      var _this = this;\n\n      var thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;\n\n      this._map.forEach(function (value, key) {\n        // Unwrap value from object-like value pair.\n        if (key !== null && _typeof(key) === 'object') {\n          value = value[1];\n        }\n\n        callback.call(thisArg, value, key, _this);\n      });\n    }\n    /**\n     * Removes all elements.\n     */\n\n  }, {\n    key: \"clear\",\n    value: function clear() {\n      this._map = new Map();\n      this._arrayTreeMap = new Map();\n      this._objectTreeMap = new Map();\n    }\n  }, {\n    key: \"size\",\n    get: function get() {\n      return this._map.size;\n    }\n  }]);\n\n  return EquivalentKeyMap;\n}();\n\nmodule.exports = EquivalentKeyMap;\n","'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n  var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';\n\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n    if ((a instanceof Map) && (b instanceof Map)) {\n      if (a.size !== b.size) return false;\n      for (i of a.entries())\n        if (!b.has(i[0])) return false;\n      for (i of a.entries())\n        if (!equal(i[1], b.get(i[0]))) return false;\n      return true;\n    }\n\n    if ((a instanceof Set) && (b instanceof Set)) {\n      if (a.size !== b.size) return false;\n      for (i of a.entries())\n        if (!b.has(i[0])) return false;\n      return true;\n    }\n\n    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (a[i] !== b[i]) return false;\n      return true;\n    }\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n","(function(e){if(\"object\"==typeof exports&&\"undefined\"!=typeof module)module.exports=e();else if(\"function\"==typeof define&&define.amd)define([],e);else{var t;t=\"undefined\"==typeof window?\"undefined\"==typeof global?\"undefined\"==typeof self?this:self:global:window,t.SimplePeer=e()}})(function(){var t=Math.floor,n=Math.abs,r=Math.pow;return function(){function d(s,e,n){function t(o,i){if(!e[o]){if(!s[o]){var l=\"function\"==typeof require&&require;if(!i&&l)return l(o,!0);if(r)return r(o,!0);var c=new Error(\"Cannot find module '\"+o+\"'\");throw c.code=\"MODULE_NOT_FOUND\",c}var a=e[o]={exports:{}};s[o][0].call(a.exports,function(e){var r=s[o][1][e];return t(r||e)},a,a.exports,d,s,e,n)}return e[o].exports}for(var r=\"function\"==typeof require&&require,a=0;a<n.length;a++)t(n[a]);return t}return d}()({1:[function(e,t,n){'use strict';function r(e){var t=e.length;if(0<t%4)throw new Error(\"Invalid string. Length must be a multiple of 4\");var n=e.indexOf(\"=\");-1===n&&(n=t);var r=n===t?0:4-n%4;return[n,r]}function a(e,t,n){return 3*(t+n)/4-n}function o(e){var t,n,o=r(e),d=o[0],s=o[1],l=new p(a(e,d,s)),c=0,f=0<s?d-4:d;for(n=0;n<f;n+=4)t=u[e.charCodeAt(n)]<<18|u[e.charCodeAt(n+1)]<<12|u[e.charCodeAt(n+2)]<<6|u[e.charCodeAt(n+3)],l[c++]=255&t>>16,l[c++]=255&t>>8,l[c++]=255&t;return 2===s&&(t=u[e.charCodeAt(n)]<<2|u[e.charCodeAt(n+1)]>>4,l[c++]=255&t),1===s&&(t=u[e.charCodeAt(n)]<<10|u[e.charCodeAt(n+1)]<<4|u[e.charCodeAt(n+2)]>>2,l[c++]=255&t>>8,l[c++]=255&t),l}function d(e){return c[63&e>>18]+c[63&e>>12]+c[63&e>>6]+c[63&e]}function s(e,t,n){for(var r,a=[],o=t;o<n;o+=3)r=(16711680&e[o]<<16)+(65280&e[o+1]<<8)+(255&e[o+2]),a.push(d(r));return a.join(\"\")}function l(e){for(var t,n=e.length,r=n%3,a=[],o=16383,d=0,l=n-r;d<l;d+=o)a.push(s(e,d,d+o>l?l:d+o));return 1===r?(t=e[n-1],a.push(c[t>>2]+c[63&t<<4]+\"==\")):2===r&&(t=(e[n-2]<<8)+e[n-1],a.push(c[t>>10]+c[63&t>>4]+c[63&t<<2]+\"=\")),a.join(\"\")}n.byteLength=function(e){var t=r(e),n=t[0],a=t[1];return 3*(n+a)/4-a},n.toByteArray=o,n.fromByteArray=l;for(var c=[],u=[],p=\"undefined\"==typeof Uint8Array?Array:Uint8Array,f=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\",g=0,_=f.length;g<_;++g)c[g]=f[g],u[f.charCodeAt(g)]=g;u[45]=62,u[95]=63},{}],2:[function(){},{}],3:[function(e,t,n){(function(){(function(){/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */'use strict';var t=String.fromCharCode,o=Math.min;function d(e){if(2147483647<e)throw new RangeError(\"The value \\\"\"+e+\"\\\" is invalid for option \\\"size\\\"\");var t=new Uint8Array(e);return t.__proto__=s.prototype,t}function s(e,t,n){if(\"number\"==typeof e){if(\"string\"==typeof t)throw new TypeError(\"The \\\"string\\\" argument must be of type string. Received type number\");return p(e)}return l(e,t,n)}function l(e,t,n){if(\"string\"==typeof e)return f(e,t);if(ArrayBuffer.isView(e))return g(e);if(null==e)throw TypeError(\"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type \"+typeof e);if(K(e,ArrayBuffer)||e&&K(e.buffer,ArrayBuffer))return _(e,t,n);if(\"number\"==typeof e)throw new TypeError(\"The \\\"value\\\" argument must not be of type number. Received type number\");var r=e.valueOf&&e.valueOf();if(null!=r&&r!==e)return s.from(r,t,n);var a=h(e);if(a)return a;if(\"undefined\"!=typeof Symbol&&null!=Symbol.toPrimitive&&\"function\"==typeof e[Symbol.toPrimitive])return s.from(e[Symbol.toPrimitive](\"string\"),t,n);throw new TypeError(\"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type \"+typeof e)}function c(e){if(\"number\"!=typeof e)throw new TypeError(\"\\\"size\\\" argument must be of type number\");else if(0>e)throw new RangeError(\"The value \\\"\"+e+\"\\\" is invalid for option \\\"size\\\"\")}function u(e,t,n){return c(e),0>=e?d(e):void 0===t?d(e):\"string\"==typeof n?d(e).fill(t,n):d(e).fill(t)}function p(e){return c(e),d(0>e?0:0|m(e))}function f(e,t){if((\"string\"!=typeof t||\"\"===t)&&(t=\"utf8\"),!s.isEncoding(t))throw new TypeError(\"Unknown encoding: \"+t);var n=0|b(e,t),r=d(n),a=r.write(e,t);return a!==n&&(r=r.slice(0,a)),r}function g(e){for(var t=0>e.length?0:0|m(e.length),n=d(t),r=0;r<t;r+=1)n[r]=255&e[r];return n}function _(e,t,n){if(0>t||e.byteLength<t)throw new RangeError(\"\\\"offset\\\" is outside of buffer bounds\");if(e.byteLength<t+(n||0))throw new RangeError(\"\\\"length\\\" is outside of buffer bounds\");var r;return r=void 0===t&&void 0===n?new Uint8Array(e):void 0===n?new Uint8Array(e,t):new Uint8Array(e,t,n),r.__proto__=s.prototype,r}function h(e){if(s.isBuffer(e)){var t=0|m(e.length),n=d(t);return 0===n.length?n:(e.copy(n,0,0,t),n)}return void 0===e.length?\"Buffer\"===e.type&&Array.isArray(e.data)?g(e.data):void 0:\"number\"!=typeof e.length||X(e.length)?d(0):g(e)}function m(e){if(e>=2147483647)throw new RangeError(\"Attempt to allocate Buffer larger than maximum size: 0x\"+2147483647 .toString(16)+\" bytes\");return 0|e}function b(e,t){if(s.isBuffer(e))return e.length;if(ArrayBuffer.isView(e)||K(e,ArrayBuffer))return e.byteLength;if(\"string\"!=typeof e)throw new TypeError(\"The \\\"string\\\" argument must be one of type string, Buffer, or ArrayBuffer. Received type \"+typeof e);var n=e.length,r=2<arguments.length&&!0===arguments[2];if(!r&&0===n)return 0;for(var a=!1;;)switch(t){case\"ascii\":case\"latin1\":case\"binary\":return n;case\"utf8\":case\"utf-8\":return H(e).length;case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return 2*n;case\"hex\":return n>>>1;case\"base64\":return z(e).length;default:if(a)return r?-1:H(e).length;t=(\"\"+t).toLowerCase(),a=!0;}}function y(e,t,n){var r=!1;if((void 0===t||0>t)&&(t=0),t>this.length)return\"\";if((void 0===n||n>this.length)&&(n=this.length),0>=n)return\"\";if(n>>>=0,t>>>=0,n<=t)return\"\";for(e||(e=\"utf8\");;)switch(e){case\"hex\":return P(this,t,n);case\"utf8\":case\"utf-8\":return x(this,t,n);case\"ascii\":return D(this,t,n);case\"latin1\":case\"binary\":return I(this,t,n);case\"base64\":return A(this,t,n);case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return M(this,t,n);default:if(r)throw new TypeError(\"Unknown encoding: \"+e);e=(e+\"\").toLowerCase(),r=!0;}}function C(e,t,n){var r=e[t];e[t]=e[n],e[n]=r}function R(e,t,n,r,a){if(0===e.length)return-1;if(\"string\"==typeof n?(r=n,n=0):2147483647<n?n=2147483647:-2147483648>n&&(n=-2147483648),n=+n,X(n)&&(n=a?0:e.length-1),0>n&&(n=e.length+n),n>=e.length){if(a)return-1;n=e.length-1}else if(0>n)if(a)n=0;else return-1;if(\"string\"==typeof t&&(t=s.from(t,r)),s.isBuffer(t))return 0===t.length?-1:E(e,t,n,r,a);if(\"number\"==typeof t)return t&=255,\"function\"==typeof Uint8Array.prototype.indexOf?a?Uint8Array.prototype.indexOf.call(e,t,n):Uint8Array.prototype.lastIndexOf.call(e,t,n):E(e,[t],n,r,a);throw new TypeError(\"val must be string, number or Buffer\")}function E(e,t,n,r,a){function o(e,t){return 1===d?e[t]:e.readUInt16BE(t*d)}var d=1,s=e.length,l=t.length;if(void 0!==r&&(r=(r+\"\").toLowerCase(),\"ucs2\"===r||\"ucs-2\"===r||\"utf16le\"===r||\"utf-16le\"===r)){if(2>e.length||2>t.length)return-1;d=2,s/=2,l/=2,n/=2}var c;if(a){var u=-1;for(c=n;c<s;c++)if(o(e,c)!==o(t,-1===u?0:c-u))-1!==u&&(c-=c-u),u=-1;else if(-1===u&&(u=c),c-u+1===l)return u*d}else for(n+l>s&&(n=s-l),c=n;0<=c;c--){for(var p=!0,f=0;f<l;f++)if(o(e,c+f)!==o(t,f)){p=!1;break}if(p)return c}return-1}function w(e,t,n,r){n=+n||0;var a=e.length-n;r?(r=+r,r>a&&(r=a)):r=a;var o=t.length;r>o/2&&(r=o/2);for(var d,s=0;s<r;++s){if(d=parseInt(t.substr(2*s,2),16),X(d))return s;e[n+s]=d}return s}function S(e,t,n,r){return G(H(t,e.length-n),e,n,r)}function T(e,t,n,r){return G(Y(t),e,n,r)}function v(e,t,n,r){return T(e,t,n,r)}function k(e,t,n,r){return G(z(t),e,n,r)}function L(e,t,n,r){return G(V(t,e.length-n),e,n,r)}function A(e,t,n){return 0===t&&n===e.length?$.fromByteArray(e):$.fromByteArray(e.slice(t,n))}function x(e,t,n){n=o(e.length,n);for(var r=[],a=t;a<n;){var d=e[a],s=null,l=239<d?4:223<d?3:191<d?2:1;if(a+l<=n){var c,u,p,f;1===l?128>d&&(s=d):2===l?(c=e[a+1],128==(192&c)&&(f=(31&d)<<6|63&c,127<f&&(s=f))):3===l?(c=e[a+1],u=e[a+2],128==(192&c)&&128==(192&u)&&(f=(15&d)<<12|(63&c)<<6|63&u,2047<f&&(55296>f||57343<f)&&(s=f))):4===l?(c=e[a+1],u=e[a+2],p=e[a+3],128==(192&c)&&128==(192&u)&&128==(192&p)&&(f=(15&d)<<18|(63&c)<<12|(63&u)<<6|63&p,65535<f&&1114112>f&&(s=f))):void 0}null===s?(s=65533,l=1):65535<s&&(s-=65536,r.push(55296|1023&s>>>10),s=56320|1023&s),r.push(s),a+=l}return N(r)}function N(e){var n=e.length;if(n<=4096)return t.apply(String,e);for(var r=\"\",a=0;a<n;)r+=t.apply(String,e.slice(a,a+=4096));return r}function D(e,n,r){var a=\"\";r=o(e.length,r);for(var d=n;d<r;++d)a+=t(127&e[d]);return a}function I(e,n,r){var a=\"\";r=o(e.length,r);for(var d=n;d<r;++d)a+=t(e[d]);return a}function P(e,t,n){var r=e.length;(!t||0>t)&&(t=0),(!n||0>n||n>r)&&(n=r);for(var a=\"\",o=t;o<n;++o)a+=W(e[o]);return a}function M(e,n,r){for(var a=e.slice(n,r),o=\"\",d=0;d<a.length;d+=2)o+=t(a[d]+256*a[d+1]);return o}function O(e,t,n){if(0!=e%1||0>e)throw new RangeError(\"offset is not uint\");if(e+t>n)throw new RangeError(\"Trying to access beyond buffer length\")}function F(e,t,n,r,a,o){if(!s.isBuffer(e))throw new TypeError(\"\\\"buffer\\\" argument must be a Buffer instance\");if(t>a||t<o)throw new RangeError(\"\\\"value\\\" argument is out of bounds\");if(n+r>e.length)throw new RangeError(\"Index out of range\")}function B(e,t,n,r){if(n+r>e.length)throw new RangeError(\"Index out of range\");if(0>n)throw new RangeError(\"Index out of range\")}function U(e,t,n,r,a){return t=+t,n>>>=0,a||B(e,t,n,4,34028234663852886e22,-34028234663852886e22),J.write(e,t,n,r,23,4),n+4}function j(e,t,n,r,a){return t=+t,n>>>=0,a||B(e,t,n,8,17976931348623157e292,-17976931348623157e292),J.write(e,t,n,r,52,8),n+8}function q(e){if(e=e.split(\"=\")[0],e=e.trim().replace(Q,\"\"),2>e.length)return\"\";for(;0!=e.length%4;)e+=\"=\";return e}function W(e){return 16>e?\"0\"+e.toString(16):e.toString(16)}function H(e,t){t=t||1/0;for(var n,r=e.length,a=null,o=[],d=0;d<r;++d){if(n=e.charCodeAt(d),55295<n&&57344>n){if(!a){if(56319<n){-1<(t-=3)&&o.push(239,191,189);continue}else if(d+1===r){-1<(t-=3)&&o.push(239,191,189);continue}a=n;continue}if(56320>n){-1<(t-=3)&&o.push(239,191,189),a=n;continue}n=(a-55296<<10|n-56320)+65536}else a&&-1<(t-=3)&&o.push(239,191,189);if(a=null,128>n){if(0>(t-=1))break;o.push(n)}else if(2048>n){if(0>(t-=2))break;o.push(192|n>>6,128|63&n)}else if(65536>n){if(0>(t-=3))break;o.push(224|n>>12,128|63&n>>6,128|63&n)}else if(1114112>n){if(0>(t-=4))break;o.push(240|n>>18,128|63&n>>12,128|63&n>>6,128|63&n)}else throw new Error(\"Invalid code point\")}return o}function Y(e){for(var t=[],n=0;n<e.length;++n)t.push(255&e.charCodeAt(n));return t}function V(e,t){for(var n,r,a,o=[],d=0;d<e.length&&!(0>(t-=2));++d)n=e.charCodeAt(d),r=n>>8,a=n%256,o.push(a),o.push(r);return o}function z(e){return $.toByteArray(q(e))}function G(e,t,n,r){for(var a=0;a<r&&!(a+n>=t.length||a>=e.length);++a)t[a+n]=e[a];return a}function K(e,t){return e instanceof t||null!=e&&null!=e.constructor&&null!=e.constructor.name&&e.constructor.name===t.name}function X(e){return e!==e}var $=e(\"base64-js\"),J=e(\"ieee754\");n.Buffer=s,n.SlowBuffer=function(e){return+e!=e&&(e=0),s.alloc(+e)},n.INSPECT_MAX_BYTES=50;n.kMaxLength=2147483647,s.TYPED_ARRAY_SUPPORT=function(){try{var e=new Uint8Array(1);return e.__proto__={__proto__:Uint8Array.prototype,foo:function(){return 42}},42===e.foo()}catch(t){return!1}}(),s.TYPED_ARRAY_SUPPORT||\"undefined\"==typeof console||\"function\"!=typeof console.error||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.\"),Object.defineProperty(s.prototype,\"parent\",{enumerable:!0,get:function(){return s.isBuffer(this)?this.buffer:void 0}}),Object.defineProperty(s.prototype,\"offset\",{enumerable:!0,get:function(){return s.isBuffer(this)?this.byteOffset:void 0}}),\"undefined\"!=typeof Symbol&&null!=Symbol.species&&s[Symbol.species]===s&&Object.defineProperty(s,Symbol.species,{value:null,configurable:!0,enumerable:!1,writable:!1}),s.poolSize=8192,s.from=function(e,t,n){return l(e,t,n)},s.prototype.__proto__=Uint8Array.prototype,s.__proto__=Uint8Array,s.alloc=function(e,t,n){return u(e,t,n)},s.allocUnsafe=function(e){return p(e)},s.allocUnsafeSlow=function(e){return p(e)},s.isBuffer=function(e){return null!=e&&!0===e._isBuffer&&e!==s.prototype},s.compare=function(e,t){if(K(e,Uint8Array)&&(e=s.from(e,e.offset,e.byteLength)),K(t,Uint8Array)&&(t=s.from(t,t.offset,t.byteLength)),!s.isBuffer(e)||!s.isBuffer(t))throw new TypeError(\"The \\\"buf1\\\", \\\"buf2\\\" arguments must be one of type Buffer or Uint8Array\");if(e===t)return 0;for(var n=e.length,r=t.length,d=0,l=o(n,r);d<l;++d)if(e[d]!==t[d]){n=e[d],r=t[d];break}return n<r?-1:r<n?1:0},s.isEncoding=function(e){switch((e+\"\").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!0;default:return!1;}},s.concat=function(e,t){if(!Array.isArray(e))throw new TypeError(\"\\\"list\\\" argument must be an Array of Buffers\");if(0===e.length)return s.alloc(0);var n;if(t===void 0)for(t=0,n=0;n<e.length;++n)t+=e[n].length;var r=s.allocUnsafe(t),a=0;for(n=0;n<e.length;++n){var o=e[n];if(K(o,Uint8Array)&&(o=s.from(o)),!s.isBuffer(o))throw new TypeError(\"\\\"list\\\" argument must be an Array of Buffers\");o.copy(r,a),a+=o.length}return r},s.byteLength=b,s.prototype._isBuffer=!0,s.prototype.swap16=function(){var e=this.length;if(0!=e%2)throw new RangeError(\"Buffer size must be a multiple of 16-bits\");for(var t=0;t<e;t+=2)C(this,t,t+1);return this},s.prototype.swap32=function(){var e=this.length;if(0!=e%4)throw new RangeError(\"Buffer size must be a multiple of 32-bits\");for(var t=0;t<e;t+=4)C(this,t,t+3),C(this,t+1,t+2);return this},s.prototype.swap64=function(){var e=this.length;if(0!=e%8)throw new RangeError(\"Buffer size must be a multiple of 64-bits\");for(var t=0;t<e;t+=8)C(this,t,t+7),C(this,t+1,t+6),C(this,t+2,t+5),C(this,t+3,t+4);return this},s.prototype.toString=function(){var e=this.length;return 0===e?\"\":0===arguments.length?x(this,0,e):y.apply(this,arguments)},s.prototype.toLocaleString=s.prototype.toString,s.prototype.equals=function(e){if(!s.isBuffer(e))throw new TypeError(\"Argument must be a Buffer\");return this===e||0===s.compare(this,e)},s.prototype.inspect=function(){var e=\"\",t=n.INSPECT_MAX_BYTES;return e=this.toString(\"hex\",0,t).replace(/(.{2})/g,\"$1 \").trim(),this.length>t&&(e+=\" ... \"),\"<Buffer \"+e+\">\"},s.prototype.compare=function(e,t,n,r,a){if(K(e,Uint8Array)&&(e=s.from(e,e.offset,e.byteLength)),!s.isBuffer(e))throw new TypeError(\"The \\\"target\\\" argument must be one of type Buffer or Uint8Array. Received type \"+typeof e);if(void 0===t&&(t=0),void 0===n&&(n=e?e.length:0),void 0===r&&(r=0),void 0===a&&(a=this.length),0>t||n>e.length||0>r||a>this.length)throw new RangeError(\"out of range index\");if(r>=a&&t>=n)return 0;if(r>=a)return-1;if(t>=n)return 1;if(t>>>=0,n>>>=0,r>>>=0,a>>>=0,this===e)return 0;for(var d=a-r,l=n-t,c=o(d,l),u=this.slice(r,a),p=e.slice(t,n),f=0;f<c;++f)if(u[f]!==p[f]){d=u[f],l=p[f];break}return d<l?-1:l<d?1:0},s.prototype.includes=function(e,t,n){return-1!==this.indexOf(e,t,n)},s.prototype.indexOf=function(e,t,n){return R(this,e,t,n,!0)},s.prototype.lastIndexOf=function(e,t,n){return R(this,e,t,n,!1)},s.prototype.write=function(e,t,n,r){if(void 0===t)r=\"utf8\",n=this.length,t=0;else if(void 0===n&&\"string\"==typeof t)r=t,n=this.length,t=0;else if(isFinite(t))t>>>=0,isFinite(n)?(n>>>=0,void 0===r&&(r=\"utf8\")):(r=n,n=void 0);else throw new Error(\"Buffer.write(string, encoding, offset[, length]) is no longer supported\");var a=this.length-t;if((void 0===n||n>a)&&(n=a),0<e.length&&(0>n||0>t)||t>this.length)throw new RangeError(\"Attempt to write outside buffer bounds\");r||(r=\"utf8\");for(var o=!1;;)switch(r){case\"hex\":return w(this,e,t,n);case\"utf8\":case\"utf-8\":return S(this,e,t,n);case\"ascii\":return T(this,e,t,n);case\"latin1\":case\"binary\":return v(this,e,t,n);case\"base64\":return k(this,e,t,n);case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return L(this,e,t,n);default:if(o)throw new TypeError(\"Unknown encoding: \"+r);r=(\"\"+r).toLowerCase(),o=!0;}},s.prototype.toJSON=function(){return{type:\"Buffer\",data:Array.prototype.slice.call(this._arr||this,0)}};s.prototype.slice=function(e,t){var n=this.length;e=~~e,t=t===void 0?n:~~t,0>e?(e+=n,0>e&&(e=0)):e>n&&(e=n),0>t?(t+=n,0>t&&(t=0)):t>n&&(t=n),t<e&&(t=e);var r=this.subarray(e,t);return r.__proto__=s.prototype,r},s.prototype.readUIntLE=function(e,t,n){e>>>=0,t>>>=0,n||O(e,t,this.length);for(var r=this[e],a=1,o=0;++o<t&&(a*=256);)r+=this[e+o]*a;return r},s.prototype.readUIntBE=function(e,t,n){e>>>=0,t>>>=0,n||O(e,t,this.length);for(var r=this[e+--t],a=1;0<t&&(a*=256);)r+=this[e+--t]*a;return r},s.prototype.readUInt8=function(e,t){return e>>>=0,t||O(e,1,this.length),this[e]},s.prototype.readUInt16LE=function(e,t){return e>>>=0,t||O(e,2,this.length),this[e]|this[e+1]<<8},s.prototype.readUInt16BE=function(e,t){return e>>>=0,t||O(e,2,this.length),this[e]<<8|this[e+1]},s.prototype.readUInt32LE=function(e,t){return e>>>=0,t||O(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},s.prototype.readUInt32BE=function(e,t){return e>>>=0,t||O(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},s.prototype.readIntLE=function(e,t,n){e>>>=0,t>>>=0,n||O(e,t,this.length);for(var a=this[e],o=1,d=0;++d<t&&(o*=256);)a+=this[e+d]*o;return o*=128,a>=o&&(a-=r(2,8*t)),a},s.prototype.readIntBE=function(e,t,n){e>>>=0,t>>>=0,n||O(e,t,this.length);for(var a=t,o=1,d=this[e+--a];0<a&&(o*=256);)d+=this[e+--a]*o;return o*=128,d>=o&&(d-=r(2,8*t)),d},s.prototype.readInt8=function(e,t){return e>>>=0,t||O(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},s.prototype.readInt16LE=function(e,t){e>>>=0,t||O(e,2,this.length);var n=this[e]|this[e+1]<<8;return 32768&n?4294901760|n:n},s.prototype.readInt16BE=function(e,t){e>>>=0,t||O(e,2,this.length);var n=this[e+1]|this[e]<<8;return 32768&n?4294901760|n:n},s.prototype.readInt32LE=function(e,t){return e>>>=0,t||O(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},s.prototype.readInt32BE=function(e,t){return e>>>=0,t||O(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},s.prototype.readFloatLE=function(e,t){return e>>>=0,t||O(e,4,this.length),J.read(this,e,!0,23,4)},s.prototype.readFloatBE=function(e,t){return e>>>=0,t||O(e,4,this.length),J.read(this,e,!1,23,4)},s.prototype.readDoubleLE=function(e,t){return e>>>=0,t||O(e,8,this.length),J.read(this,e,!0,52,8)},s.prototype.readDoubleBE=function(e,t){return e>>>=0,t||O(e,8,this.length),J.read(this,e,!1,52,8)},s.prototype.writeUIntLE=function(e,t,n,a){if(e=+e,t>>>=0,n>>>=0,!a){var o=r(2,8*n)-1;F(this,e,t,n,o,0)}var d=1,s=0;for(this[t]=255&e;++s<n&&(d*=256);)this[t+s]=255&e/d;return t+n},s.prototype.writeUIntBE=function(e,t,n,a){if(e=+e,t>>>=0,n>>>=0,!a){var o=r(2,8*n)-1;F(this,e,t,n,o,0)}var d=n-1,s=1;for(this[t+d]=255&e;0<=--d&&(s*=256);)this[t+d]=255&e/s;return t+n},s.prototype.writeUInt8=function(e,t,n){return e=+e,t>>>=0,n||F(this,e,t,1,255,0),this[t]=255&e,t+1},s.prototype.writeUInt16LE=function(e,t,n){return e=+e,t>>>=0,n||F(this,e,t,2,65535,0),this[t]=255&e,this[t+1]=e>>>8,t+2},s.prototype.writeUInt16BE=function(e,t,n){return e=+e,t>>>=0,n||F(this,e,t,2,65535,0),this[t]=e>>>8,this[t+1]=255&e,t+2},s.prototype.writeUInt32LE=function(e,t,n){return e=+e,t>>>=0,n||F(this,e,t,4,4294967295,0),this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e,t+4},s.prototype.writeUInt32BE=function(e,t,n){return e=+e,t>>>=0,n||F(this,e,t,4,4294967295,0),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e,t+4},s.prototype.writeIntLE=function(e,t,n,a){if(e=+e,t>>>=0,!a){var o=r(2,8*n-1);F(this,e,t,n,o-1,-o)}var d=0,s=1,l=0;for(this[t]=255&e;++d<n&&(s*=256);)0>e&&0===l&&0!==this[t+d-1]&&(l=1),this[t+d]=255&(e/s>>0)-l;return t+n},s.prototype.writeIntBE=function(e,t,n,a){if(e=+e,t>>>=0,!a){var o=r(2,8*n-1);F(this,e,t,n,o-1,-o)}var d=n-1,s=1,l=0;for(this[t+d]=255&e;0<=--d&&(s*=256);)0>e&&0===l&&0!==this[t+d+1]&&(l=1),this[t+d]=255&(e/s>>0)-l;return t+n},s.prototype.writeInt8=function(e,t,n){return e=+e,t>>>=0,n||F(this,e,t,1,127,-128),0>e&&(e=255+e+1),this[t]=255&e,t+1},s.prototype.writeInt16LE=function(e,t,n){return e=+e,t>>>=0,n||F(this,e,t,2,32767,-32768),this[t]=255&e,this[t+1]=e>>>8,t+2},s.prototype.writeInt16BE=function(e,t,n){return e=+e,t>>>=0,n||F(this,e,t,2,32767,-32768),this[t]=e>>>8,this[t+1]=255&e,t+2},s.prototype.writeInt32LE=function(e,t,n){return e=+e,t>>>=0,n||F(this,e,t,4,2147483647,-2147483648),this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24,t+4},s.prototype.writeInt32BE=function(e,t,n){return e=+e,t>>>=0,n||F(this,e,t,4,2147483647,-2147483648),0>e&&(e=4294967295+e+1),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e,t+4},s.prototype.writeFloatLE=function(e,t,n){return U(this,e,t,!0,n)},s.prototype.writeFloatBE=function(e,t,n){return U(this,e,t,!1,n)},s.prototype.writeDoubleLE=function(e,t,n){return j(this,e,t,!0,n)},s.prototype.writeDoubleBE=function(e,t,n){return j(this,e,t,!1,n)},s.prototype.copy=function(e,t,n,r){if(!s.isBuffer(e))throw new TypeError(\"argument should be a Buffer\");if(n||(n=0),r||0===r||(r=this.length),t>=e.length&&(t=e.length),t||(t=0),0<r&&r<n&&(r=n),r===n)return 0;if(0===e.length||0===this.length)return 0;if(0>t)throw new RangeError(\"targetStart out of bounds\");if(0>n||n>=this.length)throw new RangeError(\"Index out of range\");if(0>r)throw new RangeError(\"sourceEnd out of bounds\");r>this.length&&(r=this.length),e.length-t<r-n&&(r=e.length-t+n);var a=r-n;if(this===e&&\"function\"==typeof Uint8Array.prototype.copyWithin)this.copyWithin(t,n,r);else if(this===e&&n<t&&t<r)for(var o=a-1;0<=o;--o)e[o+t]=this[o+n];else Uint8Array.prototype.set.call(e,this.subarray(n,r),t);return a},s.prototype.fill=function(e,t,n,r){if(\"string\"==typeof e){if(\"string\"==typeof t?(r=t,t=0,n=this.length):\"string\"==typeof n&&(r=n,n=this.length),void 0!==r&&\"string\"!=typeof r)throw new TypeError(\"encoding must be a string\");if(\"string\"==typeof r&&!s.isEncoding(r))throw new TypeError(\"Unknown encoding: \"+r);if(1===e.length){var a=e.charCodeAt(0);(\"utf8\"===r&&128>a||\"latin1\"===r)&&(e=a)}}else\"number\"==typeof e&&(e&=255);if(0>t||this.length<t||this.length<n)throw new RangeError(\"Out of range index\");if(n<=t)return this;t>>>=0,n=n===void 0?this.length:n>>>0,e||(e=0);var o;if(\"number\"==typeof e)for(o=t;o<n;++o)this[o]=e;else{var d=s.isBuffer(e)?e:s.from(e,r),l=d.length;if(0===l)throw new TypeError(\"The value \\\"\"+e+\"\\\" is invalid for argument \\\"value\\\"\");for(o=0;o<n-t;++o)this[o+t]=d[o%l]}return this};var Q=/[^+/0-9A-Za-z-_]/g}).call(this)}).call(this,e(\"buffer\").Buffer)},{\"base64-js\":1,buffer:3,ieee754:9}],4:[function(e,t,n){(function(a){(function(){function r(){let e;try{e=n.storage.getItem(\"debug\")}catch(e){}return!e&&\"undefined\"!=typeof a&&\"env\"in a&&(e=a.env.DEBUG),e}n.formatArgs=function(e){if(e[0]=(this.useColors?\"%c\":\"\")+this.namespace+(this.useColors?\" %c\":\" \")+e[0]+(this.useColors?\"%c \":\" \")+\"+\"+t.exports.humanize(this.diff),!this.useColors)return;const n=\"color: \"+this.color;e.splice(1,0,n,\"color: inherit\");let r=0,a=0;e[0].replace(/%[a-zA-Z%]/g,e=>{\"%%\"===e||(r++,\"%c\"===e&&(a=r))}),e.splice(a,0,n)},n.save=function(e){try{e?n.storage.setItem(\"debug\",e):n.storage.removeItem(\"debug\")}catch(e){}},n.load=r,n.useColors=function(){return!!(\"undefined\"!=typeof window&&window.process&&(\"renderer\"===window.process.type||window.process.__nwjs))||!(\"undefined\"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/(edge|trident)\\/(\\d+)/))&&(\"undefined\"!=typeof document&&document.documentElement&&document.documentElement.style&&document.documentElement.style.WebkitAppearance||\"undefined\"!=typeof window&&window.console&&(window.console.firebug||window.console.exception&&window.console.table)||\"undefined\"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/)&&31<=parseInt(RegExp.$1,10)||\"undefined\"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/))},n.storage=function(){try{return localStorage}catch(e){}}(),n.destroy=(()=>{let e=!1;return()=>{e||(e=!0,console.warn(\"Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.\"))}})(),n.colors=[\"#0000CC\",\"#0000FF\",\"#0033CC\",\"#0033FF\",\"#0066CC\",\"#0066FF\",\"#0099CC\",\"#0099FF\",\"#00CC00\",\"#00CC33\",\"#00CC66\",\"#00CC99\",\"#00CCCC\",\"#00CCFF\",\"#3300CC\",\"#3300FF\",\"#3333CC\",\"#3333FF\",\"#3366CC\",\"#3366FF\",\"#3399CC\",\"#3399FF\",\"#33CC00\",\"#33CC33\",\"#33CC66\",\"#33CC99\",\"#33CCCC\",\"#33CCFF\",\"#6600CC\",\"#6600FF\",\"#6633CC\",\"#6633FF\",\"#66CC00\",\"#66CC33\",\"#9900CC\",\"#9900FF\",\"#9933CC\",\"#9933FF\",\"#99CC00\",\"#99CC33\",\"#CC0000\",\"#CC0033\",\"#CC0066\",\"#CC0099\",\"#CC00CC\",\"#CC00FF\",\"#CC3300\",\"#CC3333\",\"#CC3366\",\"#CC3399\",\"#CC33CC\",\"#CC33FF\",\"#CC6600\",\"#CC6633\",\"#CC9900\",\"#CC9933\",\"#CCCC00\",\"#CCCC33\",\"#FF0000\",\"#FF0033\",\"#FF0066\",\"#FF0099\",\"#FF00CC\",\"#FF00FF\",\"#FF3300\",\"#FF3333\",\"#FF3366\",\"#FF3399\",\"#FF33CC\",\"#FF33FF\",\"#FF6600\",\"#FF6633\",\"#FF9900\",\"#FF9933\",\"#FFCC00\",\"#FFCC33\"],n.log=console.debug||console.log||(()=>{}),t.exports=e(\"./common\")(n);const{formatters:o}=t.exports;o.j=function(e){try{return JSON.stringify(e)}catch(e){return\"[UnexpectedJSONParseError]: \"+e.message}}}).call(this)}).call(this,e(\"_process\"))},{\"./common\":5,_process:12}],5:[function(e,t){t.exports=function(t){function r(e){function t(...e){if(!t.enabled)return;const a=t,o=+new Date,i=o-(n||o);a.diff=i,a.prev=n,a.curr=o,n=o,e[0]=r.coerce(e[0]),\"string\"!=typeof e[0]&&e.unshift(\"%O\");let d=0;e[0]=e[0].replace(/%([a-zA-Z%])/g,(t,n)=>{if(\"%%\"===t)return\"%\";d++;const o=r.formatters[n];if(\"function\"==typeof o){const n=e[d];t=o.call(a,n),e.splice(d,1),d--}return t}),r.formatArgs.call(a,e);const s=a.log||r.log;s.apply(a,e)}let n,o=null;return t.namespace=e,t.useColors=r.useColors(),t.color=r.selectColor(e),t.extend=a,t.destroy=r.destroy,Object.defineProperty(t,\"enabled\",{enumerable:!0,configurable:!1,get:()=>null===o?r.enabled(e):o,set:e=>{o=e}}),\"function\"==typeof r.init&&r.init(t),t}function a(e,t){const n=r(this.namespace+(\"undefined\"==typeof t?\":\":t)+e);return n.log=this.log,n}function o(e){return e.toString().substring(2,e.toString().length-2).replace(/\\.\\*\\?$/,\"*\")}return r.debug=r,r.default=r,r.coerce=function(e){return e instanceof Error?e.stack||e.message:e},r.disable=function(){const e=[...r.names.map(o),...r.skips.map(o).map(e=>\"-\"+e)].join(\",\");return r.enable(\"\"),e},r.enable=function(e){r.save(e),r.names=[],r.skips=[];let t;const n=(\"string\"==typeof e?e:\"\").split(/[\\s,]+/),a=n.length;for(t=0;t<a;t++)n[t]&&(e=n[t].replace(/\\*/g,\".*?\"),\"-\"===e[0]?r.skips.push(new RegExp(\"^\"+e.substr(1)+\"$\")):r.names.push(new RegExp(\"^\"+e+\"$\")))},r.enabled=function(e){if(\"*\"===e[e.length-1])return!0;let t,n;for(t=0,n=r.skips.length;t<n;t++)if(r.skips[t].test(e))return!1;for(t=0,n=r.names.length;t<n;t++)if(r.names[t].test(e))return!0;return!1},r.humanize=e(\"ms\"),r.destroy=function(){console.warn(\"Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.\")},Object.keys(t).forEach(e=>{r[e]=t[e]}),r.names=[],r.skips=[],r.formatters={},r.selectColor=function(e){let t=0;for(let n=0;n<e.length;n++)t=(t<<5)-t+e.charCodeAt(n),t|=0;return r.colors[n(t)%r.colors.length]},r.enable(r.load()),r}},{ms:11}],6:[function(e,t){'use strict';function n(e,t){for(const n in t)Object.defineProperty(e,n,{value:t[n],enumerable:!0,configurable:!0});return e}t.exports=function(e,t,r){if(!e||\"string\"==typeof e)throw new TypeError(\"Please pass an Error to err-code\");r||(r={}),\"object\"==typeof t&&(r=t,t=\"\"),t&&(r.code=t);try{return n(e,r)}catch(t){r.message=e.message,r.stack=e.stack;const a=function(){};a.prototype=Object.create(Object.getPrototypeOf(e));const o=n(new a,r);return o}}},{}],7:[function(e,t){'use strict';function n(e){console&&console.warn&&console.warn(e)}function r(){r.init.call(this)}function a(e){if(\"function\"!=typeof e)throw new TypeError(\"The \\\"listener\\\" argument must be of type Function. Received type \"+typeof e)}function o(e){return void 0===e._maxListeners?r.defaultMaxListeners:e._maxListeners}function i(e,t,r,i){var d,s,l;if(a(r),s=e._events,void 0===s?(s=e._events=Object.create(null),e._eventsCount=0):(void 0!==s.newListener&&(e.emit(\"newListener\",t,r.listener?r.listener:r),s=e._events),l=s[t]),void 0===l)l=s[t]=r,++e._eventsCount;else if(\"function\"==typeof l?l=s[t]=i?[r,l]:[l,r]:i?l.unshift(r):l.push(r),d=o(e),0<d&&l.length>d&&!l.warned){l.warned=!0;var c=new Error(\"Possible EventEmitter memory leak detected. \"+l.length+\" \"+(t+\" listeners added. Use emitter.setMaxListeners() to increase limit\"));c.name=\"MaxListenersExceededWarning\",c.emitter=e,c.type=t,c.count=l.length,n(c)}return e}function d(){if(!this.fired)return this.target.removeListener(this.type,this.wrapFn),this.fired=!0,0===arguments.length?this.listener.call(this.target):this.listener.apply(this.target,arguments)}function s(e,t,n){var r={fired:!1,wrapFn:void 0,target:e,type:t,listener:n},a=d.bind(r);return a.listener=n,r.wrapFn=a,a}function l(e,t,n){var r=e._events;if(r===void 0)return[];var a=r[t];return void 0===a?[]:\"function\"==typeof a?n?[a.listener||a]:[a]:n?f(a):u(a,a.length)}function c(e){var t=this._events;if(t!==void 0){var n=t[e];if(\"function\"==typeof n)return 1;if(void 0!==n)return n.length}return 0}function u(e,t){for(var n=Array(t),r=0;r<t;++r)n[r]=e[r];return n}function p(e,t){for(;t+1<e.length;t++)e[t]=e[t+1];e.pop()}function f(e){for(var t=Array(e.length),n=0;n<t.length;++n)t[n]=e[n].listener||e[n];return t}function g(e,t,n){\"function\"==typeof e.on&&_(e,\"error\",t,n)}function _(e,t,n,r){if(\"function\"==typeof e.on)r.once?e.once(t,n):e.on(t,n);else if(\"function\"==typeof e.addEventListener)e.addEventListener(t,function a(o){r.once&&e.removeEventListener(t,a),n(o)});else throw new TypeError(\"The \\\"emitter\\\" argument must be of type EventEmitter. Received type \"+typeof e)}var h,m=\"object\"==typeof Reflect?Reflect:null,b=m&&\"function\"==typeof m.apply?m.apply:function(e,t,n){return Function.prototype.apply.call(e,t,n)};h=m&&\"function\"==typeof m.ownKeys?m.ownKeys:Object.getOwnPropertySymbols?function(e){return Object.getOwnPropertyNames(e).concat(Object.getOwnPropertySymbols(e))}:function(e){return Object.getOwnPropertyNames(e)};var y=Number.isNaN||function(e){return e!==e};t.exports=r,t.exports.once=function(e,t){return new Promise(function(n,r){function a(n){e.removeListener(t,o),r(n)}function o(){\"function\"==typeof e.removeListener&&e.removeListener(\"error\",a),n([].slice.call(arguments))}_(e,t,o,{once:!0}),\"error\"!==t&&g(e,a,{once:!0})})},r.EventEmitter=r,r.prototype._events=void 0,r.prototype._eventsCount=0,r.prototype._maxListeners=void 0;var C=10;Object.defineProperty(r,\"defaultMaxListeners\",{enumerable:!0,get:function(){return C},set:function(e){if(\"number\"!=typeof e||0>e||y(e))throw new RangeError(\"The value of \\\"defaultMaxListeners\\\" is out of range. It must be a non-negative number. Received \"+e+\".\");C=e}}),r.init=function(){(this._events===void 0||this._events===Object.getPrototypeOf(this)._events)&&(this._events=Object.create(null),this._eventsCount=0),this._maxListeners=this._maxListeners||void 0},r.prototype.setMaxListeners=function(e){if(\"number\"!=typeof e||0>e||y(e))throw new RangeError(\"The value of \\\"n\\\" is out of range. It must be a non-negative number. Received \"+e+\".\");return this._maxListeners=e,this},r.prototype.getMaxListeners=function(){return o(this)},r.prototype.emit=function(e){for(var t=[],n=1;n<arguments.length;n++)t.push(arguments[n]);var r=\"error\"===e,a=this._events;if(a!==void 0)r=r&&a.error===void 0;else if(!r)return!1;if(r){var o;if(0<t.length&&(o=t[0]),o instanceof Error)throw o;var d=new Error(\"Unhandled error.\"+(o?\" (\"+o.message+\")\":\"\"));throw d.context=o,d}var s=a[e];if(s===void 0)return!1;if(\"function\"==typeof s)b(s,this,t);else for(var l=s.length,c=u(s,l),n=0;n<l;++n)b(c[n],this,t);return!0},r.prototype.addListener=function(e,t){return i(this,e,t,!1)},r.prototype.on=r.prototype.addListener,r.prototype.prependListener=function(e,t){return i(this,e,t,!0)},r.prototype.once=function(e,t){return a(t),this.on(e,s(this,e,t)),this},r.prototype.prependOnceListener=function(e,t){return a(t),this.prependListener(e,s(this,e,t)),this},r.prototype.removeListener=function(e,t){var n,r,o,d,s;if(a(t),r=this._events,void 0===r)return this;if(n=r[e],void 0===n)return this;if(n===t||n.listener===t)0==--this._eventsCount?this._events=Object.create(null):(delete r[e],r.removeListener&&this.emit(\"removeListener\",e,n.listener||t));else if(\"function\"!=typeof n){for(o=-1,d=n.length-1;0<=d;d--)if(n[d]===t||n[d].listener===t){s=n[d].listener,o=d;break}if(0>o)return this;0===o?n.shift():p(n,o),1===n.length&&(r[e]=n[0]),void 0!==r.removeListener&&this.emit(\"removeListener\",e,s||t)}return this},r.prototype.off=r.prototype.removeListener,r.prototype.removeAllListeners=function(e){var t,n,r;if(n=this._events,void 0===n)return this;if(void 0===n.removeListener)return 0===arguments.length?(this._events=Object.create(null),this._eventsCount=0):void 0!==n[e]&&(0==--this._eventsCount?this._events=Object.create(null):delete n[e]),this;if(0===arguments.length){var a,o=Object.keys(n);for(r=0;r<o.length;++r)a=o[r],\"removeListener\"!==a&&this.removeAllListeners(a);return this.removeAllListeners(\"removeListener\"),this._events=Object.create(null),this._eventsCount=0,this}if(t=n[e],\"function\"==typeof t)this.removeListener(e,t);else if(void 0!==t)for(r=t.length-1;0<=r;r--)this.removeListener(e,t[r]);return this},r.prototype.listeners=function(e){return l(this,e,!0)},r.prototype.rawListeners=function(e){return l(this,e,!1)},r.listenerCount=function(e,t){return\"function\"==typeof e.listenerCount?e.listenerCount(t):c.call(e,t)},r.prototype.listenerCount=c,r.prototype.eventNames=function(){return 0<this._eventsCount?h(this._events):[]}},{}],8:[function(e,t){t.exports=function(){if(\"undefined\"==typeof globalThis)return null;var e={RTCPeerConnection:globalThis.RTCPeerConnection||globalThis.mozRTCPeerConnection||globalThis.webkitRTCPeerConnection,RTCSessionDescription:globalThis.RTCSessionDescription||globalThis.mozRTCSessionDescription||globalThis.webkitRTCSessionDescription,RTCIceCandidate:globalThis.RTCIceCandidate||globalThis.mozRTCIceCandidate||globalThis.webkitRTCIceCandidate};return e.RTCPeerConnection?e:null}},{}],9:[function(e,a,o){/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */o.read=function(t,n,a,o,l){var c,u,p=8*l-o-1,f=(1<<p)-1,g=f>>1,_=-7,h=a?l-1:0,b=a?-1:1,d=t[n+h];for(h+=b,c=d&(1<<-_)-1,d>>=-_,_+=p;0<_;c=256*c+t[n+h],h+=b,_-=8);for(u=c&(1<<-_)-1,c>>=-_,_+=o;0<_;u=256*u+t[n+h],h+=b,_-=8);if(0===c)c=1-g;else{if(c===f)return u?NaN:(d?-1:1)*(1/0);u+=r(2,o),c-=g}return(d?-1:1)*u*r(2,c-o)},o.write=function(a,o,l,u,p,f){var h,b,y,g=Math.LN2,_=Math.log,C=8*f-p-1,R=(1<<C)-1,E=R>>1,w=23===p?r(2,-24)-r(2,-77):0,S=u?0:f-1,T=u?1:-1,d=0>o||0===o&&0>1/o?1:0;for(o=n(o),isNaN(o)||o===1/0?(b=isNaN(o)?1:0,h=R):(h=t(_(o)/g),1>o*(y=r(2,-h))&&(h--,y*=2),o+=1<=h+E?w/y:w*r(2,1-E),2<=o*y&&(h++,y/=2),h+E>=R?(b=0,h=R):1<=h+E?(b=(o*y-1)*r(2,p),h+=E):(b=o*r(2,E-1)*r(2,p),h=0));8<=p;a[l+S]=255&b,S+=T,b/=256,p-=8);for(h=h<<p|b,C+=p;0<C;a[l+S]=255&h,S+=T,h/=256,C-=8);a[l+S-T]|=128*d}},{}],10:[function(e,t){t.exports=\"function\"==typeof Object.create?function(e,t){t&&(e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}))}:function(e,t){if(t){e.super_=t;var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.prototype.constructor=e}}},{}],11:[function(e,t){var r=Math.round;function a(e){if(e+=\"\",!(100<e.length)){var t=/^(-?(?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(e);if(t){var r=parseFloat(t[1]),n=(t[2]||\"ms\").toLowerCase();return\"years\"===n||\"year\"===n||\"yrs\"===n||\"yr\"===n||\"y\"===n?31557600000*r:\"weeks\"===n||\"week\"===n||\"w\"===n?604800000*r:\"days\"===n||\"day\"===n||\"d\"===n?86400000*r:\"hours\"===n||\"hour\"===n||\"hrs\"===n||\"hr\"===n||\"h\"===n?3600000*r:\"minutes\"===n||\"minute\"===n||\"mins\"===n||\"min\"===n||\"m\"===n?60000*r:\"seconds\"===n||\"second\"===n||\"secs\"===n||\"sec\"===n||\"s\"===n?1000*r:\"milliseconds\"===n||\"millisecond\"===n||\"msecs\"===n||\"msec\"===n||\"ms\"===n?r:void 0}}}function o(e){var t=n(e);return 86400000<=t?r(e/86400000)+\"d\":3600000<=t?r(e/3600000)+\"h\":60000<=t?r(e/60000)+\"m\":1000<=t?r(e/1000)+\"s\":e+\"ms\"}function i(e){var t=n(e);return 86400000<=t?s(e,t,86400000,\"day\"):3600000<=t?s(e,t,3600000,\"hour\"):60000<=t?s(e,t,60000,\"minute\"):1000<=t?s(e,t,1000,\"second\"):e+\" ms\"}function s(e,t,a,n){return r(e/a)+\" \"+n+(t>=1.5*a?\"s\":\"\")}var l=24*(60*60000);t.exports=function(e,t){t=t||{};var n=typeof e;if(\"string\"==n&&0<e.length)return a(e);if(\"number\"===n&&isFinite(e))return t.long?i(e):o(e);throw new Error(\"val is not a non-empty string or a valid number. val=\"+JSON.stringify(e))}},{}],12:[function(e,t){function n(){throw new Error(\"setTimeout has not been defined\")}function r(){throw new Error(\"clearTimeout has not been defined\")}function a(t){if(c===setTimeout)return setTimeout(t,0);if((c===n||!c)&&setTimeout)return c=setTimeout,setTimeout(t,0);try{return c(t,0)}catch(n){try{return c.call(null,t,0)}catch(n){return c.call(this,t,0)}}}function o(t){if(u===clearTimeout)return clearTimeout(t);if((u===r||!u)&&clearTimeout)return u=clearTimeout,clearTimeout(t);try{return u(t)}catch(n){try{return u.call(null,t)}catch(n){return u.call(this,t)}}}function i(){_&&f&&(_=!1,f.length?g=f.concat(g):h=-1,g.length&&d())}function d(){if(!_){var e=a(i);_=!0;for(var t=g.length;t;){for(f=g,g=[];++h<t;)f&&f[h].run();h=-1,t=g.length}f=null,_=!1,o(e)}}function s(e,t){this.fun=e,this.array=t}function l(){}var c,u,p=t.exports={};(function(){try{c=\"function\"==typeof setTimeout?setTimeout:n}catch(t){c=n}try{u=\"function\"==typeof clearTimeout?clearTimeout:r}catch(t){u=r}})();var f,g=[],_=!1,h=-1;p.nextTick=function(e){var t=Array(arguments.length-1);if(1<arguments.length)for(var n=1;n<arguments.length;n++)t[n-1]=arguments[n];g.push(new s(e,t)),1!==g.length||_||a(d)},s.prototype.run=function(){this.fun.apply(null,this.array)},p.title=\"browser\",p.browser=!0,p.env={},p.argv=[],p.version=\"\",p.versions={},p.on=l,p.addListener=l,p.once=l,p.off=l,p.removeListener=l,p.removeAllListeners=l,p.emit=l,p.prependListener=l,p.prependOnceListener=l,p.listeners=function(){return[]},p.binding=function(){throw new Error(\"process.binding is not supported\")},p.cwd=function(){return\"/\"},p.chdir=function(){throw new Error(\"process.chdir is not supported\")},p.umask=function(){return 0}},{}],13:[function(e,t){(function(e){(function(){/*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */let n;t.exports=\"function\"==typeof queueMicrotask?queueMicrotask.bind(\"undefined\"==typeof window?e:window):e=>(n||(n=Promise.resolve())).then(e).catch(e=>setTimeout(()=>{throw e},0))}).call(this)}).call(this,\"undefined\"==typeof global?\"undefined\"==typeof self?\"undefined\"==typeof window?{}:window:self:global)},{}],14:[function(e,t){(function(n,r){(function(){'use strict';var a=e(\"safe-buffer\").Buffer,o=r.crypto||r.msCrypto;t.exports=o&&o.getRandomValues?function(e,t){if(e>4294967295)throw new RangeError(\"requested too many random bytes\");var r=a.allocUnsafe(e);if(0<e)if(65536<e)for(var i=0;i<e;i+=65536)o.getRandomValues(r.slice(i,i+65536));else o.getRandomValues(r);return\"function\"==typeof t?n.nextTick(function(){t(null,r)}):r}:function(){throw new Error(\"Secure random number generation is not supported by this browser.\\nUse Chrome, Firefox or Internet Explorer 11\")}}).call(this)}).call(this,e(\"_process\"),\"undefined\"==typeof global?\"undefined\"==typeof self?\"undefined\"==typeof window?{}:window:self:global)},{_process:12,\"safe-buffer\":30}],15:[function(e,t){'use strict';function n(e,t){e.prototype=Object.create(t.prototype),e.prototype.constructor=e,e.__proto__=t}function r(e,t,r){function a(e,n,r){return\"string\"==typeof t?t:t(e,n,r)}r||(r=Error);var o=function(e){function t(t,n,r){return e.call(this,a(t,n,r))||this}return n(t,e),t}(r);o.prototype.name=r.name,o.prototype.code=e,s[e]=o}function a(e,t){if(Array.isArray(e)){var n=e.length;return e=e.map(function(e){return e+\"\"}),2<n?\"one of \".concat(t,\" \").concat(e.slice(0,n-1).join(\", \"),\", or \")+e[n-1]:2===n?\"one of \".concat(t,\" \").concat(e[0],\" or \").concat(e[1]):\"of \".concat(t,\" \").concat(e[0])}return\"of \".concat(t,\" \").concat(e+\"\")}function o(e,t,n){return e.substr(!n||0>n?0:+n,t.length)===t}function i(e,t,n){return(void 0===n||n>e.length)&&(n=e.length),e.substring(n-t.length,n)===t}function d(e,t,n){return\"number\"!=typeof n&&(n=0),!(n+t.length>e.length)&&-1!==e.indexOf(t,n)}var s={};r(\"ERR_INVALID_OPT_VALUE\",function(e,t){return\"The value \\\"\"+t+\"\\\" is invalid for option \\\"\"+e+\"\\\"\"},TypeError),r(\"ERR_INVALID_ARG_TYPE\",function(e,t,n){var r;\"string\"==typeof t&&o(t,\"not \")?(r=\"must not be\",t=t.replace(/^not /,\"\")):r=\"must be\";var s;if(i(e,\" argument\"))s=\"The \".concat(e,\" \").concat(r,\" \").concat(a(t,\"type\"));else{var l=d(e,\".\")?\"property\":\"argument\";s=\"The \\\"\".concat(e,\"\\\" \").concat(l,\" \").concat(r,\" \").concat(a(t,\"type\"))}return s+=\". Received type \".concat(typeof n),s},TypeError),r(\"ERR_STREAM_PUSH_AFTER_EOF\",\"stream.push() after EOF\"),r(\"ERR_METHOD_NOT_IMPLEMENTED\",function(e){return\"The \"+e+\" method is not implemented\"}),r(\"ERR_STREAM_PREMATURE_CLOSE\",\"Premature close\"),r(\"ERR_STREAM_DESTROYED\",function(e){return\"Cannot call \"+e+\" after a stream was destroyed\"}),r(\"ERR_MULTIPLE_CALLBACK\",\"Callback called multiple times\"),r(\"ERR_STREAM_CANNOT_PIPE\",\"Cannot pipe, not readable\"),r(\"ERR_STREAM_WRITE_AFTER_END\",\"write after end\"),r(\"ERR_STREAM_NULL_VALUES\",\"May not write null values to stream\",TypeError),r(\"ERR_UNKNOWN_ENCODING\",function(e){return\"Unknown encoding: \"+e},TypeError),r(\"ERR_STREAM_UNSHIFT_AFTER_END_EVENT\",\"stream.unshift() after end event\"),t.exports.codes=s},{}],16:[function(e,t){(function(n){(function(){'use strict';function r(e){return this instanceof r?void(d.call(this,e),s.call(this,e),this.allowHalfOpen=!0,e&&(!1===e.readable&&(this.readable=!1),!1===e.writable&&(this.writable=!1),!1===e.allowHalfOpen&&(this.allowHalfOpen=!1,this.once(\"end\",a)))):new r(e)}function a(){this._writableState.ended||n.nextTick(o,this)}function o(e){e.end()}var i=Object.keys||function(e){var t=[];for(var n in e)t.push(n);return t};t.exports=r;var d=e(\"./_stream_readable\"),s=e(\"./_stream_writable\");e(\"inherits\")(r,d);for(var l,c=i(s.prototype),u=0;u<c.length;u++)l=c[u],r.prototype[l]||(r.prototype[l]=s.prototype[l]);Object.defineProperty(r.prototype,\"writableHighWaterMark\",{enumerable:!1,get:function(){return this._writableState.highWaterMark}}),Object.defineProperty(r.prototype,\"writableBuffer\",{enumerable:!1,get:function(){return this._writableState&&this._writableState.getBuffer()}}),Object.defineProperty(r.prototype,\"writableLength\",{enumerable:!1,get:function(){return this._writableState.length}}),Object.defineProperty(r.prototype,\"destroyed\",{enumerable:!1,get:function(){return void 0!==this._readableState&&void 0!==this._writableState&&this._readableState.destroyed&&this._writableState.destroyed},set:function(e){void 0===this._readableState||void 0===this._writableState||(this._readableState.destroyed=e,this._writableState.destroyed=e)}})}).call(this)}).call(this,e(\"_process\"))},{\"./_stream_readable\":18,\"./_stream_writable\":20,_process:12,inherits:10}],17:[function(e,t){'use strict';function n(e){return this instanceof n?void r.call(this,e):new n(e)}t.exports=n;var r=e(\"./_stream_transform\");e(\"inherits\")(n,r),n.prototype._transform=function(e,t,n){n(null,e)}},{\"./_stream_transform\":19,inherits:10}],18:[function(e,t){(function(n,r){(function(){'use strict';function a(e){return P.from(e)}function o(e){return P.isBuffer(e)||e instanceof M}function i(e,t,n){return\"function\"==typeof e.prependListener?e.prependListener(t,n):void(e._events&&e._events[t]?Array.isArray(e._events[t])?e._events[t].unshift(n):e._events[t]=[n,e._events[t]]:e.on(t,n))}function d(t,n,r){A=A||e(\"./_stream_duplex\"),t=t||{},\"boolean\"!=typeof r&&(r=n instanceof A),this.objectMode=!!t.objectMode,r&&(this.objectMode=this.objectMode||!!t.readableObjectMode),this.highWaterMark=H(this,t,\"readableHighWaterMark\",r),this.buffer=new j,this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=null,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.resumeScheduled=!1,this.paused=!0,this.emitClose=!1!==t.emitClose,this.autoDestroy=!!t.autoDestroy,this.destroyed=!1,this.defaultEncoding=t.defaultEncoding||\"utf8\",this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,t.encoding&&(!F&&(F=e(\"string_decoder/\").StringDecoder),this.decoder=new F(t.encoding),this.encoding=t.encoding)}function s(t){if(A=A||e(\"./_stream_duplex\"),!(this instanceof s))return new s(t);var n=this instanceof A;this._readableState=new d(t,this,n),this.readable=!0,t&&(\"function\"==typeof t.read&&(this._read=t.read),\"function\"==typeof t.destroy&&(this._destroy=t.destroy)),I.call(this)}function l(e,t,n,r,o){x(\"readableAddChunk\",t);var i=e._readableState;if(null===t)i.reading=!1,g(e,i);else{var d;if(o||(d=u(i,t)),d)X(e,d);else if(!(i.objectMode||t&&0<t.length))r||(i.reading=!1,m(e,i));else if(\"string\"==typeof t||i.objectMode||Object.getPrototypeOf(t)===P.prototype||(t=a(t)),r)i.endEmitted?X(e,new K):c(e,i,t,!0);else if(i.ended)X(e,new z);else{if(i.destroyed)return!1;i.reading=!1,i.decoder&&!n?(t=i.decoder.write(t),i.objectMode||0!==t.length?c(e,i,t,!1):m(e,i)):c(e,i,t,!1)}}return!i.ended&&(i.length<i.highWaterMark||0===i.length)}function c(e,t,n,r){t.flowing&&0===t.length&&!t.sync?(t.awaitDrain=0,e.emit(\"data\",n)):(t.length+=t.objectMode?1:n.length,r?t.buffer.unshift(n):t.buffer.push(n),t.needReadable&&_(e)),m(e,t)}function u(e,t){var n;return o(t)||\"string\"==typeof t||void 0===t||e.objectMode||(n=new V(\"chunk\",[\"string\",\"Buffer\",\"Uint8Array\"],t)),n}function p(e){return 1073741824<=e?e=1073741824:(e--,e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,e|=e>>>16,e++),e}function f(e,t){return 0>=e||0===t.length&&t.ended?0:t.objectMode?1:e===e?(e>t.highWaterMark&&(t.highWaterMark=p(e)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0)):t.flowing&&t.length?t.buffer.head.data.length:t.length}function g(e,t){if(x(\"onEofChunk\"),!t.ended){if(t.decoder){var n=t.decoder.end();n&&n.length&&(t.buffer.push(n),t.length+=t.objectMode?1:n.length)}t.ended=!0,t.sync?_(e):(t.needReadable=!1,!t.emittedReadable&&(t.emittedReadable=!0,h(e)))}}function _(e){var t=e._readableState;x(\"emitReadable\",t.needReadable,t.emittedReadable),t.needReadable=!1,t.emittedReadable||(x(\"emitReadable\",t.flowing),t.emittedReadable=!0,n.nextTick(h,e))}function h(e){var t=e._readableState;x(\"emitReadable_\",t.destroyed,t.length,t.ended),!t.destroyed&&(t.length||t.ended)&&(e.emit(\"readable\"),t.emittedReadable=!1),t.needReadable=!t.flowing&&!t.ended&&t.length<=t.highWaterMark,S(e)}function m(e,t){t.readingMore||(t.readingMore=!0,n.nextTick(b,e,t))}function b(e,t){for(;!t.reading&&!t.ended&&(t.length<t.highWaterMark||t.flowing&&0===t.length);){var n=t.length;if(x(\"maybeReadMore read 0\"),e.read(0),n===t.length)break}t.readingMore=!1}function y(e){return function(){var t=e._readableState;x(\"pipeOnDrain\",t.awaitDrain),t.awaitDrain&&t.awaitDrain--,0===t.awaitDrain&&D(e,\"data\")&&(t.flowing=!0,S(e))}}function C(e){var t=e._readableState;t.readableListening=0<e.listenerCount(\"readable\"),t.resumeScheduled&&!t.paused?t.flowing=!0:0<e.listenerCount(\"data\")&&e.resume()}function R(e){x(\"readable nexttick read 0\"),e.read(0)}function E(e,t){t.resumeScheduled||(t.resumeScheduled=!0,n.nextTick(w,e,t))}function w(e,t){x(\"resume\",t.reading),t.reading||e.read(0),t.resumeScheduled=!1,e.emit(\"resume\"),S(e),t.flowing&&!t.reading&&e.read(0)}function S(e){var t=e._readableState;for(x(\"flow\",t.flowing);t.flowing&&null!==e.read(););}function T(e,t){if(0===t.length)return null;var n;return t.objectMode?n=t.buffer.shift():!e||e>=t.length?(n=t.decoder?t.buffer.join(\"\"):1===t.buffer.length?t.buffer.first():t.buffer.concat(t.length),t.buffer.clear()):n=t.buffer.consume(e,t.decoder),n}function v(e){var t=e._readableState;x(\"endReadable\",t.endEmitted),t.endEmitted||(t.ended=!0,n.nextTick(k,t,e))}function k(e,t){if(x(\"endReadableNT\",e.endEmitted,e.length),!e.endEmitted&&0===e.length&&(e.endEmitted=!0,t.readable=!1,t.emit(\"end\"),e.autoDestroy)){var n=t._writableState;(!n||n.autoDestroy&&n.finished)&&t.destroy()}}function L(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1}t.exports=s;var A;s.ReadableState=d;var x,N=e(\"events\").EventEmitter,D=function(e,t){return e.listeners(t).length},I=e(\"./internal/streams/stream\"),P=e(\"buffer\").Buffer,M=r.Uint8Array||function(){},O=e(\"util\");x=O&&O.debuglog?O.debuglog(\"stream\"):function(){};var F,B,U,j=e(\"./internal/streams/buffer_list\"),q=e(\"./internal/streams/destroy\"),W=e(\"./internal/streams/state\"),H=W.getHighWaterMark,Y=e(\"../errors\").codes,V=Y.ERR_INVALID_ARG_TYPE,z=Y.ERR_STREAM_PUSH_AFTER_EOF,G=Y.ERR_METHOD_NOT_IMPLEMENTED,K=Y.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;e(\"inherits\")(s,I);var X=q.errorOrDestroy,$=[\"error\",\"close\",\"destroy\",\"pause\",\"resume\"];Object.defineProperty(s.prototype,\"destroyed\",{enumerable:!1,get:function(){return void 0!==this._readableState&&this._readableState.destroyed},set:function(e){this._readableState&&(this._readableState.destroyed=e)}}),s.prototype.destroy=q.destroy,s.prototype._undestroy=q.undestroy,s.prototype._destroy=function(e,t){t(e)},s.prototype.push=function(e,t){var n,r=this._readableState;return r.objectMode?n=!0:\"string\"==typeof e&&(t=t||r.defaultEncoding,t!==r.encoding&&(e=P.from(e,t),t=\"\"),n=!0),l(this,e,t,!1,n)},s.prototype.unshift=function(e){return l(this,e,null,!0,!1)},s.prototype.isPaused=function(){return!1===this._readableState.flowing},s.prototype.setEncoding=function(t){F||(F=e(\"string_decoder/\").StringDecoder);var n=new F(t);this._readableState.decoder=n,this._readableState.encoding=this._readableState.decoder.encoding;for(var r=this._readableState.buffer.head,a=\"\";null!==r;)a+=n.write(r.data),r=r.next;return this._readableState.buffer.clear(),\"\"!==a&&this._readableState.buffer.push(a),this._readableState.length=a.length,this};s.prototype.read=function(e){x(\"read\",e),e=parseInt(e,10);var t=this._readableState,r=e;if(0!==e&&(t.emittedReadable=!1),0===e&&t.needReadable&&((0===t.highWaterMark?0<t.length:t.length>=t.highWaterMark)||t.ended))return x(\"read: emitReadable\",t.length,t.ended),0===t.length&&t.ended?v(this):_(this),null;if(e=f(e,t),0===e&&t.ended)return 0===t.length&&v(this),null;var a=t.needReadable;x(\"need readable\",a),(0===t.length||t.length-e<t.highWaterMark)&&(a=!0,x(\"length less than watermark\",a)),t.ended||t.reading?(a=!1,x(\"reading or ended\",a)):a&&(x(\"do read\"),t.reading=!0,t.sync=!0,0===t.length&&(t.needReadable=!0),this._read(t.highWaterMark),t.sync=!1,!t.reading&&(e=f(r,t)));var o;return o=0<e?T(e,t):null,null===o?(t.needReadable=t.length<=t.highWaterMark,e=0):(t.length-=e,t.awaitDrain=0),0===t.length&&(!t.ended&&(t.needReadable=!0),r!==e&&t.ended&&v(this)),null!==o&&this.emit(\"data\",o),o},s.prototype._read=function(){X(this,new G(\"_read()\"))},s.prototype.pipe=function(e,t){function r(e,t){x(\"onunpipe\"),e===p&&t&&!1===t.hasUnpiped&&(t.hasUnpiped=!0,o())}function a(){x(\"onend\"),e.end()}function o(){x(\"cleanup\"),e.removeListener(\"close\",l),e.removeListener(\"finish\",c),e.removeListener(\"drain\",h),e.removeListener(\"error\",s),e.removeListener(\"unpipe\",r),p.removeListener(\"end\",a),p.removeListener(\"end\",u),p.removeListener(\"data\",d),m=!0,f.awaitDrain&&(!e._writableState||e._writableState.needDrain)&&h()}function d(t){x(\"ondata\");var n=e.write(t);x(\"dest.write\",n),!1===n&&((1===f.pipesCount&&f.pipes===e||1<f.pipesCount&&-1!==L(f.pipes,e))&&!m&&(x(\"false write response, pause\",f.awaitDrain),f.awaitDrain++),p.pause())}function s(t){x(\"onerror\",t),u(),e.removeListener(\"error\",s),0===D(e,\"error\")&&X(e,t)}function l(){e.removeListener(\"finish\",c),u()}function c(){x(\"onfinish\"),e.removeListener(\"close\",l),u()}function u(){x(\"unpipe\"),p.unpipe(e)}var p=this,f=this._readableState;switch(f.pipesCount){case 0:f.pipes=e;break;case 1:f.pipes=[f.pipes,e];break;default:f.pipes.push(e);}f.pipesCount+=1,x(\"pipe count=%d opts=%j\",f.pipesCount,t);var g=(!t||!1!==t.end)&&e!==n.stdout&&e!==n.stderr,_=g?a:u;f.endEmitted?n.nextTick(_):p.once(\"end\",_),e.on(\"unpipe\",r);var h=y(p);e.on(\"drain\",h);var m=!1;return p.on(\"data\",d),i(e,\"error\",s),e.once(\"close\",l),e.once(\"finish\",c),e.emit(\"pipe\",p),f.flowing||(x(\"pipe resume\"),p.resume()),e},s.prototype.unpipe=function(e){var t=this._readableState,n={hasUnpiped:!1};if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,t.flowing=!1,e&&e.emit(\"unpipe\",this,n),this);if(!e){var r=t.pipes,a=t.pipesCount;t.pipes=null,t.pipesCount=0,t.flowing=!1;for(var o=0;o<a;o++)r[o].emit(\"unpipe\",this,{hasUnpiped:!1});return this}var d=L(t.pipes,e);return-1===d?this:(t.pipes.splice(d,1),t.pipesCount-=1,1===t.pipesCount&&(t.pipes=t.pipes[0]),e.emit(\"unpipe\",this,n),this)},s.prototype.on=function(e,t){var r=I.prototype.on.call(this,e,t),a=this._readableState;return\"data\"===e?(a.readableListening=0<this.listenerCount(\"readable\"),!1!==a.flowing&&this.resume()):\"readable\"==e&&!a.endEmitted&&!a.readableListening&&(a.readableListening=a.needReadable=!0,a.flowing=!1,a.emittedReadable=!1,x(\"on readable\",a.length,a.reading),a.length?_(this):!a.reading&&n.nextTick(R,this)),r},s.prototype.addListener=s.prototype.on,s.prototype.removeListener=function(e,t){var r=I.prototype.removeListener.call(this,e,t);return\"readable\"===e&&n.nextTick(C,this),r},s.prototype.removeAllListeners=function(e){var t=I.prototype.removeAllListeners.apply(this,arguments);return(\"readable\"===e||void 0===e)&&n.nextTick(C,this),t},s.prototype.resume=function(){var e=this._readableState;return e.flowing||(x(\"resume\"),e.flowing=!e.readableListening,E(this,e)),e.paused=!1,this},s.prototype.pause=function(){return x(\"call pause flowing=%j\",this._readableState.flowing),!1!==this._readableState.flowing&&(x(\"pause\"),this._readableState.flowing=!1,this.emit(\"pause\")),this._readableState.paused=!0,this},s.prototype.wrap=function(e){var t=this,r=this._readableState,a=!1;for(var o in e.on(\"end\",function(){if(x(\"wrapped end\"),r.decoder&&!r.ended){var e=r.decoder.end();e&&e.length&&t.push(e)}t.push(null)}),e.on(\"data\",function(n){if((x(\"wrapped data\"),r.decoder&&(n=r.decoder.write(n)),!(r.objectMode&&(null===n||void 0===n)))&&(r.objectMode||n&&n.length)){var o=t.push(n);o||(a=!0,e.pause())}}),e)void 0===this[o]&&\"function\"==typeof e[o]&&(this[o]=function(t){return function(){return e[t].apply(e,arguments)}}(o));for(var i=0;i<$.length;i++)e.on($[i],this.emit.bind(this,$[i]));return this._read=function(t){x(\"wrapped _read\",t),a&&(a=!1,e.resume())},this},\"function\"==typeof Symbol&&(s.prototype[Symbol.asyncIterator]=function(){return void 0===B&&(B=e(\"./internal/streams/async_iterator\")),B(this)}),Object.defineProperty(s.prototype,\"readableHighWaterMark\",{enumerable:!1,get:function(){return this._readableState.highWaterMark}}),Object.defineProperty(s.prototype,\"readableBuffer\",{enumerable:!1,get:function(){return this._readableState&&this._readableState.buffer}}),Object.defineProperty(s.prototype,\"readableFlowing\",{enumerable:!1,get:function(){return this._readableState.flowing},set:function(e){this._readableState&&(this._readableState.flowing=e)}}),s._fromList=T,Object.defineProperty(s.prototype,\"readableLength\",{enumerable:!1,get:function(){return this._readableState.length}}),\"function\"==typeof Symbol&&(s.from=function(t,n){return void 0===U&&(U=e(\"./internal/streams/from\")),U(s,t,n)})}).call(this)}).call(this,e(\"_process\"),\"undefined\"==typeof global?\"undefined\"==typeof self?\"undefined\"==typeof window?{}:window:self:global)},{\"../errors\":15,\"./_stream_duplex\":16,\"./internal/streams/async_iterator\":21,\"./internal/streams/buffer_list\":22,\"./internal/streams/destroy\":23,\"./internal/streams/from\":25,\"./internal/streams/state\":27,\"./internal/streams/stream\":28,_process:12,buffer:3,events:7,inherits:10,\"string_decoder/\":31,util:2}],19:[function(e,t){'use strict';function n(e,t){var n=this._transformState;n.transforming=!1;var r=n.writecb;if(null===r)return this.emit(\"error\",new s);n.writechunk=null,n.writecb=null,null!=t&&this.push(t),r(e);var a=this._readableState;a.reading=!1,(a.needReadable||a.length<a.highWaterMark)&&this._read(a.highWaterMark)}function r(e){return this instanceof r?void(u.call(this,e),this._transformState={afterTransform:n.bind(this),needTransform:!1,transforming:!1,writecb:null,writechunk:null,writeencoding:null},this._readableState.needReadable=!0,this._readableState.sync=!1,e&&(\"function\"==typeof e.transform&&(this._transform=e.transform),\"function\"==typeof e.flush&&(this._flush=e.flush)),this.on(\"prefinish\",a)):new r(e)}function a(){var e=this;\"function\"!=typeof this._flush||this._readableState.destroyed?o(this,null,null):this._flush(function(t,n){o(e,t,n)})}function o(e,t,n){if(t)return e.emit(\"error\",t);if(null!=n&&e.push(n),e._writableState.length)throw new c;if(e._transformState.transforming)throw new l;return e.push(null)}t.exports=r;var i=e(\"../errors\").codes,d=i.ERR_METHOD_NOT_IMPLEMENTED,s=i.ERR_MULTIPLE_CALLBACK,l=i.ERR_TRANSFORM_ALREADY_TRANSFORMING,c=i.ERR_TRANSFORM_WITH_LENGTH_0,u=e(\"./_stream_duplex\");e(\"inherits\")(r,u),r.prototype.push=function(e,t){return this._transformState.needTransform=!1,u.prototype.push.call(this,e,t)},r.prototype._transform=function(e,t,n){n(new d(\"_transform()\"))},r.prototype._write=function(e,t,n){var r=this._transformState;if(r.writecb=n,r.writechunk=e,r.writeencoding=t,!r.transforming){var a=this._readableState;(r.needTransform||a.needReadable||a.length<a.highWaterMark)&&this._read(a.highWaterMark)}},r.prototype._read=function(){var e=this._transformState;null===e.writechunk||e.transforming?e.needTransform=!0:(e.transforming=!0,this._transform(e.writechunk,e.writeencoding,e.afterTransform))},r.prototype._destroy=function(e,t){u.prototype._destroy.call(this,e,function(e){t(e)})}},{\"../errors\":15,\"./_stream_duplex\":16,inherits:10}],20:[function(e,t){(function(n,r){(function(){'use strict';function a(e){var t=this;this.next=null,this.entry=null,this.finish=function(){v(t,e)}}function o(e){return x.from(e)}function i(e){return x.isBuffer(e)||e instanceof N}function d(){}function s(t,n,r){k=k||e(\"./_stream_duplex\"),t=t||{},\"boolean\"!=typeof r&&(r=n instanceof k),this.objectMode=!!t.objectMode,r&&(this.objectMode=this.objectMode||!!t.writableObjectMode),this.highWaterMark=P(this,t,\"writableHighWaterMark\",r),this.finalCalled=!1,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1,this.destroyed=!1;var o=!1===t.decodeStrings;this.decodeStrings=!o,this.defaultEncoding=t.defaultEncoding||\"utf8\",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){m(n,e)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.emitClose=!1!==t.emitClose,this.autoDestroy=!!t.autoDestroy,this.bufferedRequestCount=0,this.corkedRequestsFree=new a(this)}function l(t){k=k||e(\"./_stream_duplex\");var n=this instanceof k;return n||V.call(l,this)?void(this._writableState=new s(t,this,n),this.writable=!0,t&&(\"function\"==typeof t.write&&(this._write=t.write),\"function\"==typeof t.writev&&(this._writev=t.writev),\"function\"==typeof t.destroy&&(this._destroy=t.destroy),\"function\"==typeof t.final&&(this._final=t.final)),A.call(this)):new l(t)}function c(e,t){var r=new W;Y(e,r),n.nextTick(t,r)}function u(e,t,r,a){var o;return null===r?o=new q:\"string\"!=typeof r&&!t.objectMode&&(o=new O(\"chunk\",[\"string\",\"Buffer\"],r)),!o||(Y(e,o),n.nextTick(a,o),!1)}function p(e,t,n){return e.objectMode||!1===e.decodeStrings||\"string\"!=typeof t||(t=x.from(t,n)),t}function f(e,t,n,r,a,o){if(!n){var i=p(t,r,a);r!==i&&(n=!0,a=\"buffer\",r=i)}var d=t.objectMode?1:r.length;t.length+=d;var s=t.length<t.highWaterMark;if(s||(t.needDrain=!0),t.writing||t.corked){var l=t.lastBufferedRequest;t.lastBufferedRequest={chunk:r,encoding:a,isBuf:n,callback:o,next:null},l?l.next=t.lastBufferedRequest:t.bufferedRequest=t.lastBufferedRequest,t.bufferedRequestCount+=1}else g(e,t,!1,d,r,a,o);return s}function g(e,t,n,r,a,o,i){t.writelen=r,t.writecb=i,t.writing=!0,t.sync=!0,t.destroyed?t.onwrite(new j(\"write\")):n?e._writev(a,t.onwrite):e._write(a,o,t.onwrite),t.sync=!1}function _(e,t,r,a,o){--t.pendingcb,r?(n.nextTick(o,a),n.nextTick(S,e,t),e._writableState.errorEmitted=!0,Y(e,a)):(o(a),e._writableState.errorEmitted=!0,Y(e,a),S(e,t))}function h(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}function m(e,t){var r=e._writableState,a=r.sync,o=r.writecb;if(\"function\"!=typeof o)throw new B;if(h(r),t)_(e,r,a,t,o);else{var i=R(r)||e.destroyed;i||r.corked||r.bufferProcessing||!r.bufferedRequest||C(e,r),a?n.nextTick(b,e,r,i,o):b(e,r,i,o)}}function b(e,t,n,r){n||y(e,t),t.pendingcb--,r(),S(e,t)}function y(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit(\"drain\"))}function C(e,t){t.bufferProcessing=!0;var n=t.bufferedRequest;if(e._writev&&n&&n.next){var r=t.bufferedRequestCount,o=Array(r),i=t.corkedRequestsFree;i.entry=n;for(var d=0,s=!0;n;)o[d]=n,n.isBuf||(s=!1),n=n.next,d+=1;o.allBuffers=s,g(e,t,!0,t.length,o,\"\",i.finish),t.pendingcb++,t.lastBufferedRequest=null,i.next?(t.corkedRequestsFree=i.next,i.next=null):t.corkedRequestsFree=new a(t),t.bufferedRequestCount=0}else{for(;n;){var l=n.chunk,c=n.encoding,u=n.callback,p=t.objectMode?1:l.length;if(g(e,t,!1,p,l,c,u),n=n.next,t.bufferedRequestCount--,t.writing)break}null===n&&(t.lastBufferedRequest=null)}t.bufferedRequest=n,t.bufferProcessing=!1}function R(e){return e.ending&&0===e.length&&null===e.bufferedRequest&&!e.finished&&!e.writing}function E(e,t){e._final(function(n){t.pendingcb--,n&&Y(e,n),t.prefinished=!0,e.emit(\"prefinish\"),S(e,t)})}function w(e,t){t.prefinished||t.finalCalled||(\"function\"!=typeof e._final||t.destroyed?(t.prefinished=!0,e.emit(\"prefinish\")):(t.pendingcb++,t.finalCalled=!0,n.nextTick(E,e,t)))}function S(e,t){var n=R(t);if(n&&(w(e,t),0===t.pendingcb&&(t.finished=!0,e.emit(\"finish\"),t.autoDestroy))){var r=e._readableState;(!r||r.autoDestroy&&r.endEmitted)&&e.destroy()}return n}function T(e,t,r){t.ending=!0,S(e,t),r&&(t.finished?n.nextTick(r):e.once(\"finish\",r)),t.ended=!0,e.writable=!1}function v(e,t,n){var r=e.entry;for(e.entry=null;r;){var a=r.callback;t.pendingcb--,a(n),r=r.next}t.corkedRequestsFree.next=e}t.exports=l;var k;l.WritableState=s;var L={deprecate:e(\"util-deprecate\")},A=e(\"./internal/streams/stream\"),x=e(\"buffer\").Buffer,N=r.Uint8Array||function(){},D=e(\"./internal/streams/destroy\"),I=e(\"./internal/streams/state\"),P=I.getHighWaterMark,M=e(\"../errors\").codes,O=M.ERR_INVALID_ARG_TYPE,F=M.ERR_METHOD_NOT_IMPLEMENTED,B=M.ERR_MULTIPLE_CALLBACK,U=M.ERR_STREAM_CANNOT_PIPE,j=M.ERR_STREAM_DESTROYED,q=M.ERR_STREAM_NULL_VALUES,W=M.ERR_STREAM_WRITE_AFTER_END,H=M.ERR_UNKNOWN_ENCODING,Y=D.errorOrDestroy;e(\"inherits\")(l,A),s.prototype.getBuffer=function(){for(var e=this.bufferedRequest,t=[];e;)t.push(e),e=e.next;return t},function(){try{Object.defineProperty(s.prototype,\"buffer\",{get:L.deprecate(function(){return this.getBuffer()},\"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.\",\"DEP0003\")})}catch(e){}}();var V;\"function\"==typeof Symbol&&Symbol.hasInstance&&\"function\"==typeof Function.prototype[Symbol.hasInstance]?(V=Function.prototype[Symbol.hasInstance],Object.defineProperty(l,Symbol.hasInstance,{value:function(e){return!!V.call(this,e)||!(this!==l)&&e&&e._writableState instanceof s}})):V=function(e){return e instanceof this},l.prototype.pipe=function(){Y(this,new U)},l.prototype.write=function(e,t,n){var r=this._writableState,a=!1,s=!r.objectMode&&i(e);return s&&!x.isBuffer(e)&&(e=o(e)),\"function\"==typeof t&&(n=t,t=null),s?t=\"buffer\":!t&&(t=r.defaultEncoding),\"function\"!=typeof n&&(n=d),r.ending?c(this,n):(s||u(this,r,e,n))&&(r.pendingcb++,a=f(this,r,s,e,t,n)),a},l.prototype.cork=function(){this._writableState.corked++},l.prototype.uncork=function(){var e=this._writableState;e.corked&&(e.corked--,!e.writing&&!e.corked&&!e.bufferProcessing&&e.bufferedRequest&&C(this,e))},l.prototype.setDefaultEncoding=function(e){if(\"string\"==typeof e&&(e=e.toLowerCase()),!(-1<[\"hex\",\"utf8\",\"utf-8\",\"ascii\",\"binary\",\"base64\",\"ucs2\",\"ucs-2\",\"utf16le\",\"utf-16le\",\"raw\"].indexOf((e+\"\").toLowerCase())))throw new H(e);return this._writableState.defaultEncoding=e,this},Object.defineProperty(l.prototype,\"writableBuffer\",{enumerable:!1,get:function(){return this._writableState&&this._writableState.getBuffer()}}),Object.defineProperty(l.prototype,\"writableHighWaterMark\",{enumerable:!1,get:function(){return this._writableState.highWaterMark}}),l.prototype._write=function(e,t,n){n(new F(\"_write()\"))},l.prototype._writev=null,l.prototype.end=function(e,t,n){var r=this._writableState;return\"function\"==typeof e?(n=e,e=null,t=null):\"function\"==typeof t&&(n=t,t=null),null!==e&&void 0!==e&&this.write(e,t),r.corked&&(r.corked=1,this.uncork()),r.ending||T(this,r,n),this},Object.defineProperty(l.prototype,\"writableLength\",{enumerable:!1,get:function(){return this._writableState.length}}),Object.defineProperty(l.prototype,\"destroyed\",{enumerable:!1,get:function(){return void 0!==this._writableState&&this._writableState.destroyed},set:function(e){this._writableState&&(this._writableState.destroyed=e)}}),l.prototype.destroy=D.destroy,l.prototype._undestroy=D.undestroy,l.prototype._destroy=function(e,t){t(e)}}).call(this)}).call(this,e(\"_process\"),\"undefined\"==typeof global?\"undefined\"==typeof self?\"undefined\"==typeof window?{}:window:self:global)},{\"../errors\":15,\"./_stream_duplex\":16,\"./internal/streams/destroy\":23,\"./internal/streams/state\":27,\"./internal/streams/stream\":28,_process:12,buffer:3,inherits:10,\"util-deprecate\":32}],21:[function(e,t){(function(n){(function(){'use strict';function r(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function a(e,t){return{value:e,done:t}}function o(e){var t=e[c];if(null!==t){var n=e[h].read();null!==n&&(e[g]=null,e[c]=null,e[u]=null,t(a(n,!1)))}}function i(e){n.nextTick(o,e)}function d(e,t){return function(n,r){e.then(function(){return t[f]?void n(a(void 0,!0)):void t[_](n,r)},r)}}var s,l=e(\"./end-of-stream\"),c=Symbol(\"lastResolve\"),u=Symbol(\"lastReject\"),p=Symbol(\"error\"),f=Symbol(\"ended\"),g=Symbol(\"lastPromise\"),_=Symbol(\"handlePromise\"),h=Symbol(\"stream\"),m=Object.getPrototypeOf(function(){}),b=Object.setPrototypeOf((s={get stream(){return this[h]},next:function(){var e=this,t=this[p];if(null!==t)return Promise.reject(t);if(this[f])return Promise.resolve(a(void 0,!0));if(this[h].destroyed)return new Promise(function(t,r){n.nextTick(function(){e[p]?r(e[p]):t(a(void 0,!0))})});var r,o=this[g];if(o)r=new Promise(d(o,this));else{var i=this[h].read();if(null!==i)return Promise.resolve(a(i,!1));r=new Promise(this[_])}return this[g]=r,r}},r(s,Symbol.asyncIterator,function(){return this}),r(s,\"return\",function(){var e=this;return new Promise(function(t,n){e[h].destroy(null,function(e){return e?void n(e):void t(a(void 0,!0))})})}),s),m);t.exports=function(e){var t,n=Object.create(b,(t={},r(t,h,{value:e,writable:!0}),r(t,c,{value:null,writable:!0}),r(t,u,{value:null,writable:!0}),r(t,p,{value:null,writable:!0}),r(t,f,{value:e._readableState.endEmitted,writable:!0}),r(t,_,{value:function(e,t){var r=n[h].read();r?(n[g]=null,n[c]=null,n[u]=null,e(a(r,!1))):(n[c]=e,n[u]=t)},writable:!0}),t));return n[g]=null,l(e,function(e){if(e&&\"ERR_STREAM_PREMATURE_CLOSE\"!==e.code){var t=n[u];return null!==t&&(n[g]=null,n[c]=null,n[u]=null,t(e)),void(n[p]=e)}var r=n[c];null!==r&&(n[g]=null,n[c]=null,n[u]=null,r(a(void 0,!0))),n[f]=!0}),e.on(\"readable\",i.bind(null,n)),n}}).call(this)}).call(this,e(\"_process\"))},{\"./end-of-stream\":24,_process:12}],22:[function(e,t){'use strict';function n(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),n.push.apply(n,r)}return n}function r(e){for(var t,r=1;r<arguments.length;r++)t=null==arguments[r]?{}:arguments[r],r%2?n(Object(t),!0).forEach(function(n){a(e,n,t[n])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(t)):n(Object(t)).forEach(function(n){Object.defineProperty(e,n,Object.getOwnPropertyDescriptor(t,n))});return e}function a(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function o(e,t){if(!(e instanceof t))throw new TypeError(\"Cannot call a class as a function\")}function i(e,t){for(var n,r=0;r<t.length;r++)n=t[r],n.enumerable=n.enumerable||!1,n.configurable=!0,\"value\"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}function d(e,t,n){return t&&i(e.prototype,t),n&&i(e,n),e}function s(e,t,n){u.prototype.copy.call(e,t,n)}var l=e(\"buffer\"),u=l.Buffer,p=e(\"util\"),f=p.inspect,g=f&&f.custom||\"inspect\";t.exports=function(){function e(){o(this,e),this.head=null,this.tail=null,this.length=0}return d(e,[{key:\"push\",value:function(e){var t={data:e,next:null};0<this.length?this.tail.next=t:this.head=t,this.tail=t,++this.length}},{key:\"unshift\",value:function(e){var t={data:e,next:this.head};0===this.length&&(this.tail=t),this.head=t,++this.length}},{key:\"shift\",value:function(){if(0!==this.length){var e=this.head.data;return this.head=1===this.length?this.tail=null:this.head.next,--this.length,e}}},{key:\"clear\",value:function(){this.head=this.tail=null,this.length=0}},{key:\"join\",value:function(e){if(0===this.length)return\"\";for(var t=this.head,n=\"\"+t.data;t=t.next;)n+=e+t.data;return n}},{key:\"concat\",value:function(e){if(0===this.length)return u.alloc(0);for(var t=u.allocUnsafe(e>>>0),n=this.head,r=0;n;)s(n.data,t,r),r+=n.data.length,n=n.next;return t}},{key:\"consume\",value:function(e,t){var n;return e<this.head.data.length?(n=this.head.data.slice(0,e),this.head.data=this.head.data.slice(e)):e===this.head.data.length?n=this.shift():n=t?this._getString(e):this._getBuffer(e),n}},{key:\"first\",value:function(){return this.head.data}},{key:\"_getString\",value:function(e){var t=this.head,r=1,a=t.data;for(e-=a.length;t=t.next;){var o=t.data,i=e>o.length?o.length:e;if(a+=i===o.length?o:o.slice(0,e),e-=i,0===e){i===o.length?(++r,this.head=t.next?t.next:this.tail=null):(this.head=t,t.data=o.slice(i));break}++r}return this.length-=r,a}},{key:\"_getBuffer\",value:function(e){var t=u.allocUnsafe(e),r=this.head,a=1;for(r.data.copy(t),e-=r.data.length;r=r.next;){var o=r.data,i=e>o.length?o.length:e;if(o.copy(t,t.length-e,0,i),e-=i,0===e){i===o.length?(++a,this.head=r.next?r.next:this.tail=null):(this.head=r,r.data=o.slice(i));break}++a}return this.length-=a,t}},{key:g,value:function(e,t){return f(this,r({},t,{depth:0,customInspect:!1}))}}]),e}()},{buffer:3,util:2}],23:[function(e,t){(function(e){(function(){'use strict';function n(e,t){a(e,t),r(e)}function r(e){e._writableState&&!e._writableState.emitClose||e._readableState&&!e._readableState.emitClose||e.emit(\"close\")}function a(e,t){e.emit(\"error\",t)}t.exports={destroy:function(t,o){var i=this,d=this._readableState&&this._readableState.destroyed,s=this._writableState&&this._writableState.destroyed;return d||s?(o?o(t):t&&(this._writableState?!this._writableState.errorEmitted&&(this._writableState.errorEmitted=!0,e.nextTick(a,this,t)):e.nextTick(a,this,t)),this):(this._readableState&&(this._readableState.destroyed=!0),this._writableState&&(this._writableState.destroyed=!0),this._destroy(t||null,function(t){!o&&t?i._writableState?i._writableState.errorEmitted?e.nextTick(r,i):(i._writableState.errorEmitted=!0,e.nextTick(n,i,t)):e.nextTick(n,i,t):o?(e.nextTick(r,i),o(t)):e.nextTick(r,i)}),this)},undestroy:function(){this._readableState&&(this._readableState.destroyed=!1,this._readableState.reading=!1,this._readableState.ended=!1,this._readableState.endEmitted=!1),this._writableState&&(this._writableState.destroyed=!1,this._writableState.ended=!1,this._writableState.ending=!1,this._writableState.finalCalled=!1,this._writableState.prefinished=!1,this._writableState.finished=!1,this._writableState.errorEmitted=!1)},errorOrDestroy:function(e,t){var n=e._readableState,r=e._writableState;n&&n.autoDestroy||r&&r.autoDestroy?e.destroy(t):e.emit(\"error\",t)}}}).call(this)}).call(this,e(\"_process\"))},{_process:12}],24:[function(e,t){'use strict';function n(e){var t=!1;return function(){if(!t){t=!0;for(var n=arguments.length,r=Array(n),a=0;a<n;a++)r[a]=arguments[a];e.apply(this,r)}}}function r(){}function a(e){return e.setHeader&&\"function\"==typeof e.abort}function o(e,t,d){if(\"function\"==typeof t)return o(e,null,t);t||(t={}),d=n(d||r);var s=t.readable||!1!==t.readable&&e.readable,l=t.writable||!1!==t.writable&&e.writable,c=function(){e.writable||p()},u=e._writableState&&e._writableState.finished,p=function(){l=!1,u=!0,s||d.call(e)},f=e._readableState&&e._readableState.endEmitted,g=function(){s=!1,f=!0,l||d.call(e)},_=function(t){d.call(e,t)},h=function(){var t;return s&&!f?(e._readableState&&e._readableState.ended||(t=new i),d.call(e,t)):l&&!u?(e._writableState&&e._writableState.ended||(t=new i),d.call(e,t)):void 0},m=function(){e.req.on(\"finish\",p)};return a(e)?(e.on(\"complete\",p),e.on(\"abort\",h),e.req?m():e.on(\"request\",m)):l&&!e._writableState&&(e.on(\"end\",c),e.on(\"close\",c)),e.on(\"end\",g),e.on(\"finish\",p),!1!==t.error&&e.on(\"error\",_),e.on(\"close\",h),function(){e.removeListener(\"complete\",p),e.removeListener(\"abort\",h),e.removeListener(\"request\",m),e.req&&e.req.removeListener(\"finish\",p),e.removeListener(\"end\",c),e.removeListener(\"close\",c),e.removeListener(\"finish\",p),e.removeListener(\"end\",g),e.removeListener(\"error\",_),e.removeListener(\"close\",h)}}var i=e(\"../../../errors\").codes.ERR_STREAM_PREMATURE_CLOSE;t.exports=o},{\"../../../errors\":15}],25:[function(e,t){t.exports=function(){throw new Error(\"Readable.from is not available in the browser\")}},{}],26:[function(e,t){'use strict';function n(e){var t=!1;return function(){t||(t=!0,e.apply(void 0,arguments))}}function r(e){if(e)throw e}function a(e){return e.setHeader&&\"function\"==typeof e.abort}function o(t,r,o,i){i=n(i);var d=!1;t.on(\"close\",function(){d=!0}),l===void 0&&(l=e(\"./end-of-stream\")),l(t,{readable:r,writable:o},function(e){return e?i(e):void(d=!0,i())});var s=!1;return function(e){if(!d)return s?void 0:(s=!0,a(t)?t.abort():\"function\"==typeof t.destroy?t.destroy():void i(e||new p(\"pipe\")))}}function i(e){e()}function d(e,t){return e.pipe(t)}function s(e){return e.length?\"function\"==typeof e[e.length-1]?e.pop():r:r}var l,c=e(\"../../../errors\").codes,u=c.ERR_MISSING_ARGS,p=c.ERR_STREAM_DESTROYED;t.exports=function(){for(var e=arguments.length,t=Array(e),n=0;n<e;n++)t[n]=arguments[n];var r=s(t);if(Array.isArray(t[0])&&(t=t[0]),2>t.length)throw new u(\"streams\");var a,l=t.map(function(e,n){var d=n<t.length-1;return o(e,d,0<n,function(e){a||(a=e),e&&l.forEach(i),d||(l.forEach(i),r(a))})});return t.reduce(d)}},{\"../../../errors\":15,\"./end-of-stream\":24}],27:[function(e,n){'use strict';function r(e,t,n){return null==e.highWaterMark?t?e[n]:null:e.highWaterMark}var a=e(\"../../../errors\").codes.ERR_INVALID_OPT_VALUE;n.exports={getHighWaterMark:function(e,n,o,i){var d=r(n,i,o);if(null!=d){if(!(isFinite(d)&&t(d)===d)||0>d){var s=i?o:\"highWaterMark\";throw new a(s,d)}return t(d)}return e.objectMode?16:16384}}},{\"../../../errors\":15}],28:[function(e,t){t.exports=e(\"events\").EventEmitter},{events:7}],29:[function(e,t,n){n=t.exports=e(\"./lib/_stream_readable.js\"),n.Stream=n,n.Readable=n,n.Writable=e(\"./lib/_stream_writable.js\"),n.Duplex=e(\"./lib/_stream_duplex.js\"),n.Transform=e(\"./lib/_stream_transform.js\"),n.PassThrough=e(\"./lib/_stream_passthrough.js\"),n.finished=e(\"./lib/internal/streams/end-of-stream.js\"),n.pipeline=e(\"./lib/internal/streams/pipeline.js\")},{\"./lib/_stream_duplex.js\":16,\"./lib/_stream_passthrough.js\":17,\"./lib/_stream_readable.js\":18,\"./lib/_stream_transform.js\":19,\"./lib/_stream_writable.js\":20,\"./lib/internal/streams/end-of-stream.js\":24,\"./lib/internal/streams/pipeline.js\":26}],30:[function(e,t,n){function r(e,t){for(var n in e)t[n]=e[n]}function a(e,t,n){return i(e,t,n)}/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */var o=e(\"buffer\"),i=o.Buffer;i.from&&i.alloc&&i.allocUnsafe&&i.allocUnsafeSlow?t.exports=o:(r(o,n),n.Buffer=a),a.prototype=Object.create(i.prototype),r(i,a),a.from=function(e,t,n){if(\"number\"==typeof e)throw new TypeError(\"Argument must not be a number\");return i(e,t,n)},a.alloc=function(e,t,n){if(\"number\"!=typeof e)throw new TypeError(\"Argument must be a number\");var r=i(e);return void 0===t?r.fill(0):\"string\"==typeof n?r.fill(t,n):r.fill(t),r},a.allocUnsafe=function(e){if(\"number\"!=typeof e)throw new TypeError(\"Argument must be a number\");return i(e)},a.allocUnsafeSlow=function(e){if(\"number\"!=typeof e)throw new TypeError(\"Argument must be a number\");return o.SlowBuffer(e)}},{buffer:3}],31:[function(e,t,n){'use strict';function r(e){if(!e)return\"utf8\";for(var t;;)switch(e){case\"utf8\":case\"utf-8\":return\"utf8\";case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return\"utf16le\";case\"latin1\":case\"binary\":return\"latin1\";case\"base64\":case\"ascii\":case\"hex\":return e;default:if(t)return;e=(\"\"+e).toLowerCase(),t=!0;}}function a(e){var t=r(e);if(\"string\"!=typeof t&&(m.isEncoding===b||!b(e)))throw new Error(\"Unknown encoding: \"+e);return t||e}function o(e){this.encoding=a(e);var t;switch(this.encoding){case\"utf16le\":this.text=u,this.end=p,t=4;break;case\"utf8\":this.fillLast=c,t=4;break;case\"base64\":this.text=f,this.end=g,t=3;break;default:return this.write=_,void(this.end=h);}this.lastNeed=0,this.lastTotal=0,this.lastChar=m.allocUnsafe(t)}function d(e){if(127>=e)return 0;return 6==e>>5?2:14==e>>4?3:30==e>>3?4:2==e>>6?-1:-2}function s(e,t,n){var r=t.length-1;if(r<n)return 0;var a=d(t[r]);return 0<=a?(0<a&&(e.lastNeed=a-1),a):--r<n||-2===a?0:(a=d(t[r]),0<=a)?(0<a&&(e.lastNeed=a-2),a):--r<n||-2===a?0:(a=d(t[r]),0<=a?(0<a&&(2===a?a=0:e.lastNeed=a-3),a):0)}function l(e,t){if(128!=(192&t[0]))return e.lastNeed=0,\"\\uFFFD\";if(1<e.lastNeed&&1<t.length){if(128!=(192&t[1]))return e.lastNeed=1,\"\\uFFFD\";if(2<e.lastNeed&&2<t.length&&128!=(192&t[2]))return e.lastNeed=2,\"\\uFFFD\"}}function c(e){var t=this.lastTotal-this.lastNeed,n=l(this,e,t);return void 0===n?this.lastNeed<=e.length?(e.copy(this.lastChar,t,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal)):void(e.copy(this.lastChar,t,0,e.length),this.lastNeed-=e.length):n}function u(e,t){if(0==(e.length-t)%2){var n=e.toString(\"utf16le\",t);if(n){var r=n.charCodeAt(n.length-1);if(55296<=r&&56319>=r)return this.lastNeed=2,this.lastTotal=4,this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1],n.slice(0,-1)}return n}return this.lastNeed=1,this.lastTotal=2,this.lastChar[0]=e[e.length-1],e.toString(\"utf16le\",t,e.length-1)}function p(e){var t=e&&e.length?this.write(e):\"\";if(this.lastNeed){var n=this.lastTotal-this.lastNeed;return t+this.lastChar.toString(\"utf16le\",0,n)}return t}function f(e,t){var r=(e.length-t)%3;return 0==r?e.toString(\"base64\",t):(this.lastNeed=3-r,this.lastTotal=3,1==r?this.lastChar[0]=e[e.length-1]:(this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1]),e.toString(\"base64\",t,e.length-r))}function g(e){var t=e&&e.length?this.write(e):\"\";return this.lastNeed?t+this.lastChar.toString(\"base64\",0,3-this.lastNeed):t}function _(e){return e.toString(this.encoding)}function h(e){return e&&e.length?this.write(e):\"\"}var m=e(\"safe-buffer\").Buffer,b=m.isEncoding||function(e){switch(e=\"\"+e,e&&e.toLowerCase()){case\"hex\":case\"utf8\":case\"utf-8\":case\"ascii\":case\"binary\":case\"base64\":case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":case\"raw\":return!0;default:return!1;}};n.StringDecoder=o,o.prototype.write=function(e){if(0===e.length)return\"\";var t,n;if(this.lastNeed){if(t=this.fillLast(e),void 0===t)return\"\";n=this.lastNeed,this.lastNeed=0}else n=0;return n<e.length?t?t+this.text(e,n):this.text(e,n):t||\"\"},o.prototype.end=function(e){var t=e&&e.length?this.write(e):\"\";return this.lastNeed?t+\"\\uFFFD\":t},o.prototype.text=function(e,t){var n=s(this,e,t);if(!this.lastNeed)return e.toString(\"utf8\",t);this.lastTotal=n;var r=e.length-(n-this.lastNeed);return e.copy(this.lastChar,0,r),e.toString(\"utf8\",t,r)},o.prototype.fillLast=function(e){return this.lastNeed<=e.length?(e.copy(this.lastChar,this.lastTotal-this.lastNeed,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal)):void(e.copy(this.lastChar,this.lastTotal-this.lastNeed,0,e.length),this.lastNeed-=e.length)}},{\"safe-buffer\":30}],32:[function(e,t){(function(e){(function(){function n(t){try{if(!e.localStorage)return!1}catch(e){return!1}var n=e.localStorage[t];return null!=n&&\"true\"===(n+\"\").toLowerCase()}t.exports=function(e,t){function r(){if(!a){if(n(\"throwDeprecation\"))throw new Error(t);else n(\"traceDeprecation\")?console.trace(t):console.warn(t);a=!0}return e.apply(this,arguments)}if(n(\"noDeprecation\"))return e;var a=!1;return r}}).call(this)}).call(this,\"undefined\"==typeof global?\"undefined\"==typeof self?\"undefined\"==typeof window?{}:window:self:global)},{}],\"/\":[function(e,t){function n(e){return e.replace(/a=ice-options:trickle\\s\\n/g,\"\")}function r(e){console.warn(e)}/*! simple-peer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */const a=e(\"debug\")(\"simple-peer\"),o=e(\"get-browser-rtc\"),i=e(\"randombytes\"),d=e(\"readable-stream\"),s=e(\"queue-microtask\"),l=e(\"err-code\"),{Buffer:c}=e(\"buffer\"),u=65536;class p extends d.Duplex{constructor(e){if(e=Object.assign({allowHalfOpen:!1},e),super(e),this._id=i(4).toString(\"hex\").slice(0,7),this._debug(\"new peer %o\",e),this.channelName=e.initiator?e.channelName||i(20).toString(\"hex\"):null,this.initiator=e.initiator||!1,this.channelConfig=e.channelConfig||p.channelConfig,this.channelNegotiated=this.channelConfig.negotiated,this.config=Object.assign({},p.config,e.config),this.offerOptions=e.offerOptions||{},this.answerOptions=e.answerOptions||{},this.sdpTransform=e.sdpTransform||(e=>e),this.streams=e.streams||(e.stream?[e.stream]:[]),this.trickle=void 0===e.trickle||e.trickle,this.allowHalfTrickle=void 0!==e.allowHalfTrickle&&e.allowHalfTrickle,this.iceCompleteTimeout=e.iceCompleteTimeout||5000,this.destroyed=!1,this.destroying=!1,this._connected=!1,this.remoteAddress=void 0,this.remoteFamily=void 0,this.remotePort=void 0,this.localAddress=void 0,this.localFamily=void 0,this.localPort=void 0,this._wrtc=e.wrtc&&\"object\"==typeof e.wrtc?e.wrtc:o(),!this._wrtc)if(\"undefined\"==typeof window)throw l(new Error(\"No WebRTC support: Specify `opts.wrtc` option in this environment\"),\"ERR_WEBRTC_SUPPORT\");else throw l(new Error(\"No WebRTC support: Not a supported browser\"),\"ERR_WEBRTC_SUPPORT\");this._pcReady=!1,this._channelReady=!1,this._iceComplete=!1,this._iceCompleteTimer=null,this._channel=null,this._pendingCandidates=[],this._isNegotiating=!1,this._firstNegotiation=!0,this._batchedNegotiation=!1,this._queuedNegotiation=!1,this._sendersAwaitingStable=[],this._senderMap=new Map,this._closingInterval=null,this._remoteTracks=[],this._remoteStreams=[],this._chunk=null,this._cb=null,this._interval=null;try{this._pc=new this._wrtc.RTCPeerConnection(this.config)}catch(e){return void this.destroy(l(e,\"ERR_PC_CONSTRUCTOR\"))}this._isReactNativeWebrtc=\"number\"==typeof this._pc._peerConnectionId,this._pc.oniceconnectionstatechange=()=>{this._onIceStateChange()},this._pc.onicegatheringstatechange=()=>{this._onIceStateChange()},this._pc.onconnectionstatechange=()=>{this._onConnectionStateChange()},this._pc.onsignalingstatechange=()=>{this._onSignalingStateChange()},this._pc.onicecandidate=e=>{this._onIceCandidate(e)},\"object\"==typeof this._pc.peerIdentity&&this._pc.peerIdentity.catch(e=>{this.destroy(l(e,\"ERR_PC_PEER_IDENTITY\"))}),this.initiator||this.channelNegotiated?this._setupData({channel:this._pc.createDataChannel(this.channelName,this.channelConfig)}):this._pc.ondatachannel=e=>{this._setupData(e)},this.streams&&this.streams.forEach(e=>{this.addStream(e)}),this._pc.ontrack=e=>{this._onTrack(e)},this._debug(\"initial negotiation\"),this._needsNegotiation(),this._onFinishBound=()=>{this._onFinish()},this.once(\"finish\",this._onFinishBound)}get bufferSize(){return this._channel&&this._channel.bufferedAmount||0}get connected(){return this._connected&&\"open\"===this._channel.readyState}address(){return{port:this.localPort,family:this.localFamily,address:this.localAddress}}signal(e){if(!this.destroying){if(this.destroyed)throw l(new Error(\"cannot signal after peer is destroyed\"),\"ERR_DESTROYED\");if(\"string\"==typeof e)try{e=JSON.parse(e)}catch(t){e={}}this._debug(\"signal()\"),e.renegotiate&&this.initiator&&(this._debug(\"got request to renegotiate\"),this._needsNegotiation()),e.transceiverRequest&&this.initiator&&(this._debug(\"got request for transceiver\"),this.addTransceiver(e.transceiverRequest.kind,e.transceiverRequest.init)),e.candidate&&(this._pc.remoteDescription&&this._pc.remoteDescription.type?this._addIceCandidate(e.candidate):this._pendingCandidates.push(e.candidate)),e.sdp&&this._pc.setRemoteDescription(new this._wrtc.RTCSessionDescription(e)).then(()=>{this.destroyed||(this._pendingCandidates.forEach(e=>{this._addIceCandidate(e)}),this._pendingCandidates=[],\"offer\"===this._pc.remoteDescription.type&&this._createAnswer())}).catch(e=>{this.destroy(l(e,\"ERR_SET_REMOTE_DESCRIPTION\"))}),e.sdp||e.candidate||e.renegotiate||e.transceiverRequest||this.destroy(l(new Error(\"signal() called with invalid signal data\"),\"ERR_SIGNALING\"))}}_addIceCandidate(e){const t=new this._wrtc.RTCIceCandidate(e);this._pc.addIceCandidate(t).catch(e=>{!t.address||t.address.endsWith(\".local\")?r(\"Ignoring unsupported ICE candidate.\"):this.destroy(l(e,\"ERR_ADD_ICE_CANDIDATE\"))})}send(e){if(!this.destroying){if(this.destroyed)throw l(new Error(\"cannot send after peer is destroyed\"),\"ERR_DESTROYED\");this._channel.send(e)}}addTransceiver(e,t){if(!this.destroying){if(this.destroyed)throw l(new Error(\"cannot addTransceiver after peer is destroyed\"),\"ERR_DESTROYED\");if(this._debug(\"addTransceiver()\"),this.initiator)try{this._pc.addTransceiver(e,t),this._needsNegotiation()}catch(e){this.destroy(l(e,\"ERR_ADD_TRANSCEIVER\"))}else this.emit(\"signal\",{type:\"transceiverRequest\",transceiverRequest:{kind:e,init:t}})}}addStream(e){if(!this.destroying){if(this.destroyed)throw l(new Error(\"cannot addStream after peer is destroyed\"),\"ERR_DESTROYED\");this._debug(\"addStream()\"),e.getTracks().forEach(t=>{this.addTrack(t,e)})}}addTrack(e,t){if(this.destroying)return;if(this.destroyed)throw l(new Error(\"cannot addTrack after peer is destroyed\"),\"ERR_DESTROYED\");this._debug(\"addTrack()\");const n=this._senderMap.get(e)||new Map;let r=n.get(t);if(!r)r=this._pc.addTrack(e,t),n.set(t,r),this._senderMap.set(e,n),this._needsNegotiation();else if(r.removed)throw l(new Error(\"Track has been removed. You should enable/disable tracks that you want to re-add.\"),\"ERR_SENDER_REMOVED\");else throw l(new Error(\"Track has already been added to that stream.\"),\"ERR_SENDER_ALREADY_ADDED\")}replaceTrack(e,t,n){if(this.destroying)return;if(this.destroyed)throw l(new Error(\"cannot replaceTrack after peer is destroyed\"),\"ERR_DESTROYED\");this._debug(\"replaceTrack()\");const r=this._senderMap.get(e),a=r?r.get(n):null;if(!a)throw l(new Error(\"Cannot replace track that was never added.\"),\"ERR_TRACK_NOT_ADDED\");t&&this._senderMap.set(t,r),null==a.replaceTrack?this.destroy(l(new Error(\"replaceTrack is not supported in this browser\"),\"ERR_UNSUPPORTED_REPLACETRACK\")):a.replaceTrack(t)}removeTrack(e,t){if(this.destroying)return;if(this.destroyed)throw l(new Error(\"cannot removeTrack after peer is destroyed\"),\"ERR_DESTROYED\");this._debug(\"removeSender()\");const n=this._senderMap.get(e),r=n?n.get(t):null;if(!r)throw l(new Error(\"Cannot remove track that was never added.\"),\"ERR_TRACK_NOT_ADDED\");try{r.removed=!0,this._pc.removeTrack(r)}catch(e){\"NS_ERROR_UNEXPECTED\"===e.name?this._sendersAwaitingStable.push(r):this.destroy(l(e,\"ERR_REMOVE_TRACK\"))}this._needsNegotiation()}removeStream(e){if(!this.destroying){if(this.destroyed)throw l(new Error(\"cannot removeStream after peer is destroyed\"),\"ERR_DESTROYED\");this._debug(\"removeSenders()\"),e.getTracks().forEach(t=>{this.removeTrack(t,e)})}}_needsNegotiation(){this._debug(\"_needsNegotiation\"),this._batchedNegotiation||(this._batchedNegotiation=!0,s(()=>{this._batchedNegotiation=!1,this.initiator||!this._firstNegotiation?(this._debug(\"starting batched negotiation\"),this.negotiate()):this._debug(\"non-initiator initial negotiation request discarded\"),this._firstNegotiation=!1}))}negotiate(){if(!this.destroying){if(this.destroyed)throw l(new Error(\"cannot negotiate after peer is destroyed\"),\"ERR_DESTROYED\");this.initiator?this._isNegotiating?(this._queuedNegotiation=!0,this._debug(\"already negotiating, queueing\")):(this._debug(\"start negotiation\"),setTimeout(()=>{this._createOffer()},0)):this._isNegotiating?(this._queuedNegotiation=!0,this._debug(\"already negotiating, queueing\")):(this._debug(\"requesting negotiation from initiator\"),this.emit(\"signal\",{type:\"renegotiate\",renegotiate:!0})),this._isNegotiating=!0}}destroy(e){this._destroy(e,()=>{})}_destroy(e,t){this.destroyed||this.destroying||(this.destroying=!0,this._debug(\"destroying (error: %s)\",e&&(e.message||e)),s(()=>{if(this.destroyed=!0,this.destroying=!1,this._debug(\"destroy (error: %s)\",e&&(e.message||e)),this.readable=this.writable=!1,this._readableState.ended||this.push(null),this._writableState.finished||this.end(),this._connected=!1,this._pcReady=!1,this._channelReady=!1,this._remoteTracks=null,this._remoteStreams=null,this._senderMap=null,clearInterval(this._closingInterval),this._closingInterval=null,clearInterval(this._interval),this._interval=null,this._chunk=null,this._cb=null,this._onFinishBound&&this.removeListener(\"finish\",this._onFinishBound),this._onFinishBound=null,this._channel){try{this._channel.close()}catch(e){}this._channel.onmessage=null,this._channel.onopen=null,this._channel.onclose=null,this._channel.onerror=null}if(this._pc){try{this._pc.close()}catch(e){}this._pc.oniceconnectionstatechange=null,this._pc.onicegatheringstatechange=null,this._pc.onsignalingstatechange=null,this._pc.onicecandidate=null,this._pc.ontrack=null,this._pc.ondatachannel=null}this._pc=null,this._channel=null,e&&this.emit(\"error\",e),this.emit(\"close\"),t()}))}_setupData(e){if(!e.channel)return this.destroy(l(new Error(\"Data channel event is missing `channel` property\"),\"ERR_DATA_CHANNEL\"));this._channel=e.channel,this._channel.binaryType=\"arraybuffer\",\"number\"==typeof this._channel.bufferedAmountLowThreshold&&(this._channel.bufferedAmountLowThreshold=u),this.channelName=this._channel.label,this._channel.onmessage=e=>{this._onChannelMessage(e)},this._channel.onbufferedamountlow=()=>{this._onChannelBufferedAmountLow()},this._channel.onopen=()=>{this._onChannelOpen()},this._channel.onclose=()=>{this._onChannelClose()},this._channel.onerror=e=>{const t=e.error instanceof Error?e.error:new Error(`Datachannel error: ${e.message} ${e.filename}:${e.lineno}:${e.colno}`);this.destroy(l(t,\"ERR_DATA_CHANNEL\"))};let t=!1;this._closingInterval=setInterval(()=>{this._channel&&\"closing\"===this._channel.readyState?(t&&this._onChannelClose(),t=!0):t=!1},5000)}_read(){}_write(e,t,n){if(this.destroyed)return n(l(new Error(\"cannot write after peer is destroyed\"),\"ERR_DATA_CHANNEL\"));if(this._connected){try{this.send(e)}catch(e){return this.destroy(l(e,\"ERR_DATA_CHANNEL\"))}this._channel.bufferedAmount>u?(this._debug(\"start backpressure: bufferedAmount %d\",this._channel.bufferedAmount),this._cb=n):n(null)}else this._debug(\"write before connect\"),this._chunk=e,this._cb=n}_onFinish(){if(!this.destroyed){const e=()=>{setTimeout(()=>this.destroy(),1e3)};this._connected?e():this.once(\"connect\",e)}}_startIceCompleteTimeout(){this.destroyed||this._iceCompleteTimer||(this._debug(\"started iceComplete timeout\"),this._iceCompleteTimer=setTimeout(()=>{this._iceComplete||(this._iceComplete=!0,this._debug(\"iceComplete timeout completed\"),this.emit(\"iceTimeout\"),this.emit(\"_iceComplete\"))},this.iceCompleteTimeout))}_createOffer(){this.destroyed||this._pc.createOffer(this.offerOptions).then(e=>{if(this.destroyed)return;this.trickle||this.allowHalfTrickle||(e.sdp=n(e.sdp)),e.sdp=this.sdpTransform(e.sdp);const t=()=>{if(!this.destroyed){const t=this._pc.localDescription||e;this._debug(\"signal\"),this.emit(\"signal\",{type:t.type,sdp:t.sdp})}};this._pc.setLocalDescription(e).then(()=>{this._debug(\"createOffer success\"),this.destroyed||(this.trickle||this._iceComplete?t():this.once(\"_iceComplete\",t))}).catch(e=>{this.destroy(l(e,\"ERR_SET_LOCAL_DESCRIPTION\"))})}).catch(e=>{this.destroy(l(e,\"ERR_CREATE_OFFER\"))})}_requestMissingTransceivers(){this._pc.getTransceivers&&this._pc.getTransceivers().forEach(e=>{e.mid||!e.sender.track||e.requested||(e.requested=!0,this.addTransceiver(e.sender.track.kind))})}_createAnswer(){this.destroyed||this._pc.createAnswer(this.answerOptions).then(e=>{if(this.destroyed)return;this.trickle||this.allowHalfTrickle||(e.sdp=n(e.sdp)),e.sdp=this.sdpTransform(e.sdp);const t=()=>{if(!this.destroyed){const t=this._pc.localDescription||e;this._debug(\"signal\"),this.emit(\"signal\",{type:t.type,sdp:t.sdp}),this.initiator||this._requestMissingTransceivers()}};this._pc.setLocalDescription(e).then(()=>{this.destroyed||(this.trickle||this._iceComplete?t():this.once(\"_iceComplete\",t))}).catch(e=>{this.destroy(l(e,\"ERR_SET_LOCAL_DESCRIPTION\"))})}).catch(e=>{this.destroy(l(e,\"ERR_CREATE_ANSWER\"))})}_onConnectionStateChange(){this.destroyed||\"failed\"===this._pc.connectionState&&this.destroy(l(new Error(\"Connection failed.\"),\"ERR_CONNECTION_FAILURE\"))}_onIceStateChange(){if(this.destroyed)return;const e=this._pc.iceConnectionState,t=this._pc.iceGatheringState;this._debug(\"iceStateChange (connection: %s) (gathering: %s)\",e,t),this.emit(\"iceStateChange\",e,t),(\"connected\"===e||\"completed\"===e)&&(this._pcReady=!0,this._maybeReady()),\"failed\"===e&&this.destroy(l(new Error(\"Ice connection failed.\"),\"ERR_ICE_CONNECTION_FAILURE\")),\"closed\"===e&&this.destroy(l(new Error(\"Ice connection closed.\"),\"ERR_ICE_CONNECTION_CLOSED\"))}getStats(e){const t=e=>(\"[object Array]\"===Object.prototype.toString.call(e.values)&&e.values.forEach(t=>{Object.assign(e,t)}),e);0===this._pc.getStats.length||this._isReactNativeWebrtc?this._pc.getStats().then(n=>{const r=[];n.forEach(e=>{r.push(t(e))}),e(null,r)},t=>e(t)):0<this._pc.getStats.length?this._pc.getStats(n=>{if(this.destroyed)return;const r=[];n.result().forEach(e=>{const n={};e.names().forEach(t=>{n[t]=e.stat(t)}),n.id=e.id,n.type=e.type,n.timestamp=e.timestamp,r.push(t(n))}),e(null,r)},t=>e(t)):e(null,[])}_maybeReady(){if(this._debug(\"maybeReady pc %s channel %s\",this._pcReady,this._channelReady),this._connected||this._connecting||!this._pcReady||!this._channelReady)return;this._connecting=!0;const e=()=>{this.destroyed||this.getStats((t,n)=>{if(this.destroyed)return;t&&(n=[]);const r={},a={},o={};let i=!1;n.forEach(e=>{(\"remotecandidate\"===e.type||\"remote-candidate\"===e.type)&&(r[e.id]=e),(\"localcandidate\"===e.type||\"local-candidate\"===e.type)&&(a[e.id]=e),(\"candidatepair\"===e.type||\"candidate-pair\"===e.type)&&(o[e.id]=e)});const d=e=>{i=!0;let t=a[e.localCandidateId];t&&(t.ip||t.address)?(this.localAddress=t.ip||t.address,this.localPort=+t.port):t&&t.ipAddress?(this.localAddress=t.ipAddress,this.localPort=+t.portNumber):\"string\"==typeof e.googLocalAddress&&(t=e.googLocalAddress.split(\":\"),this.localAddress=t[0],this.localPort=+t[1]),this.localAddress&&(this.localFamily=this.localAddress.includes(\":\")?\"IPv6\":\"IPv4\");let n=r[e.remoteCandidateId];n&&(n.ip||n.address)?(this.remoteAddress=n.ip||n.address,this.remotePort=+n.port):n&&n.ipAddress?(this.remoteAddress=n.ipAddress,this.remotePort=+n.portNumber):\"string\"==typeof e.googRemoteAddress&&(n=e.googRemoteAddress.split(\":\"),this.remoteAddress=n[0],this.remotePort=+n[1]),this.remoteAddress&&(this.remoteFamily=this.remoteAddress.includes(\":\")?\"IPv6\":\"IPv4\"),this._debug(\"connect local: %s:%s remote: %s:%s\",this.localAddress,this.localPort,this.remoteAddress,this.remotePort)};if(n.forEach(e=>{\"transport\"===e.type&&e.selectedCandidatePairId&&d(o[e.selectedCandidatePairId]),(\"googCandidatePair\"===e.type&&\"true\"===e.googActiveConnection||(\"candidatepair\"===e.type||\"candidate-pair\"===e.type)&&e.selected)&&d(e)}),!i&&(!Object.keys(o).length||Object.keys(a).length))return void setTimeout(e,100);if(this._connecting=!1,this._connected=!0,this._chunk){try{this.send(this._chunk)}catch(e){return this.destroy(l(e,\"ERR_DATA_CHANNEL\"))}this._chunk=null,this._debug(\"sent chunk from \\\"write before connect\\\"\");const e=this._cb;this._cb=null,e(null)}\"number\"!=typeof this._channel.bufferedAmountLowThreshold&&(this._interval=setInterval(()=>this._onInterval(),150),this._interval.unref&&this._interval.unref()),this._debug(\"connect\"),this.emit(\"connect\")})};e()}_onInterval(){this._cb&&this._channel&&!(this._channel.bufferedAmount>u)&&this._onChannelBufferedAmountLow()}_onSignalingStateChange(){this.destroyed||(\"stable\"===this._pc.signalingState&&(this._isNegotiating=!1,this._debug(\"flushing sender queue\",this._sendersAwaitingStable),this._sendersAwaitingStable.forEach(e=>{this._pc.removeTrack(e),this._queuedNegotiation=!0}),this._sendersAwaitingStable=[],this._queuedNegotiation?(this._debug(\"flushing negotiation queue\"),this._queuedNegotiation=!1,this._needsNegotiation()):(this._debug(\"negotiated\"),this.emit(\"negotiated\"))),this._debug(\"signalingStateChange %s\",this._pc.signalingState),this.emit(\"signalingStateChange\",this._pc.signalingState))}_onIceCandidate(e){this.destroyed||(e.candidate&&this.trickle?this.emit(\"signal\",{type:\"candidate\",candidate:{candidate:e.candidate.candidate,sdpMLineIndex:e.candidate.sdpMLineIndex,sdpMid:e.candidate.sdpMid}}):!e.candidate&&!this._iceComplete&&(this._iceComplete=!0,this.emit(\"_iceComplete\")),e.candidate&&this._startIceCompleteTimeout())}_onChannelMessage(e){if(this.destroyed)return;let t=e.data;t instanceof ArrayBuffer&&(t=c.from(t)),this.push(t)}_onChannelBufferedAmountLow(){if(!this.destroyed&&this._cb){this._debug(\"ending backpressure: bufferedAmount %d\",this._channel.bufferedAmount);const e=this._cb;this._cb=null,e(null)}}_onChannelOpen(){this._connected||this.destroyed||(this._debug(\"on channel open\"),this._channelReady=!0,this._maybeReady())}_onChannelClose(){this.destroyed||(this._debug(\"on channel close\"),this.destroy())}_onTrack(e){this.destroyed||e.streams.forEach(t=>{this._debug(\"on track\"),this.emit(\"track\",e.track,t),this._remoteTracks.push({track:e.track,stream:t}),this._remoteStreams.some(e=>e.id===t.id)||(this._remoteStreams.push(t),s(()=>{this._debug(\"on stream\"),this.emit(\"stream\",t)}))})}_debug(){const e=[].slice.call(arguments);e[0]=\"[\"+this._id+\"] \"+e[0],a.apply(null,e)}}p.WEBRTC_SUPPORT=!!o(),p.config={iceServers:[{urls:[\"stun:stun.l.google.com:19302\",\"stun:global.stun.twilio.com:3478\"]}],sdpSemantics:\"unified-plan\"},p.channelConfig={},t.exports=p},{buffer:3,debug:4,\"err-code\":6,\"get-browser-rtc\":8,\"queue-microtask\":13,randombytes:14,\"readable-stream\":29}]},{},[])(\"/\")});","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"data\"];","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"compose\"];","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"isShallowEqual\"];","/**\n * WordPress dependencies\n */\nimport isShallowEqual from '@wordpress/is-shallow-equal';\n\n/** @typedef {import('./types').HistoryRecord}  HistoryRecord */\n/** @typedef {import('./types').HistoryChange}  HistoryChange */\n/** @typedef {import('./types').HistoryChanges} HistoryChanges */\n/** @typedef {import('./types').UndoManager} UndoManager */\n\n/**\n * Merge changes for a single item into a record of changes.\n *\n * @param {Record< string, HistoryChange >} changes1 Previous changes\n * @param {Record< string, HistoryChange >} changes2 NextChanges\n *\n * @return {Record< string, HistoryChange >} Merged changes\n */\nfunction mergeHistoryChanges( changes1, changes2 ) {\n\t/**\n\t * @type {Record< string, HistoryChange >}\n\t */\n\tconst newChanges = { ...changes1 };\n\tObject.entries( changes2 ).forEach( ( [ key, value ] ) => {\n\t\tif ( newChanges[ key ] ) {\n\t\t\tnewChanges[ key ] = { ...newChanges[ key ], to: value.to };\n\t\t} else {\n\t\t\tnewChanges[ key ] = value;\n\t\t}\n\t} );\n\n\treturn newChanges;\n}\n\n/**\n * Adds history changes for a single item into a record of changes.\n *\n * @param {HistoryRecord}  record  The record to merge into.\n * @param {HistoryChanges} changes The changes to merge.\n */\nconst addHistoryChangesIntoRecord = ( record, changes ) => {\n\tconst existingChangesIndex = record?.findIndex(\n\t\t( { id: recordIdentifier } ) => {\n\t\t\treturn typeof recordIdentifier === 'string'\n\t\t\t\t? recordIdentifier === changes.id\n\t\t\t\t: isShallowEqual( recordIdentifier, changes.id );\n\t\t}\n\t);\n\tconst nextRecord = [ ...record ];\n\n\tif ( existingChangesIndex !== -1 ) {\n\t\t// If the edit is already in the stack leave the initial \"from\" value.\n\t\tnextRecord[ existingChangesIndex ] = {\n\t\t\tid: changes.id,\n\t\t\tchanges: mergeHistoryChanges(\n\t\t\t\tnextRecord[ existingChangesIndex ].changes,\n\t\t\t\tchanges.changes\n\t\t\t),\n\t\t};\n\t} else {\n\t\tnextRecord.push( changes );\n\t}\n\treturn nextRecord;\n};\n\n/**\n * Creates an undo manager.\n *\n * @return {UndoManager} Undo manager.\n */\nexport function createUndoManager() {\n\t/**\n\t * @type {HistoryRecord[]}\n\t */\n\tlet history = [];\n\t/**\n\t * @type {HistoryRecord}\n\t */\n\tlet stagedRecord = [];\n\t/**\n\t * @type {number}\n\t */\n\tlet offset = 0;\n\n\tconst dropPendingRedos = () => {\n\t\thistory = history.slice( 0, offset || undefined );\n\t\toffset = 0;\n\t};\n\n\tconst appendStagedRecordToLatestHistoryRecord = () => {\n\t\tconst index = history.length === 0 ? 0 : history.length - 1;\n\t\tlet latestRecord = history[ index ] ?? [];\n\t\tstagedRecord.forEach( ( changes ) => {\n\t\t\tlatestRecord = addHistoryChangesIntoRecord( latestRecord, changes );\n\t\t} );\n\t\tstagedRecord = [];\n\t\thistory[ index ] = latestRecord;\n\t};\n\n\t/**\n\t * Checks whether a record is empty.\n\t * A record is considered empty if it the changes keep the same values.\n\t * Also updates to function values are ignored.\n\t *\n\t * @param {HistoryRecord} record\n\t * @return {boolean} Whether the record is empty.\n\t */\n\tconst isRecordEmpty = ( record ) => {\n\t\tconst filteredRecord = record.filter( ( { changes } ) => {\n\t\t\treturn Object.values( changes ).some(\n\t\t\t\t( { from, to } ) =>\n\t\t\t\t\ttypeof from !== 'function' &&\n\t\t\t\t\ttypeof to !== 'function' &&\n\t\t\t\t\t! isShallowEqual( from, to )\n\t\t\t);\n\t\t} );\n\t\treturn ! filteredRecord.length;\n\t};\n\n\treturn {\n\t\t/**\n\t\t * Record changes into the history.\n\t\t *\n\t\t * @param {HistoryRecord=} record   A record of changes to record.\n\t\t * @param {boolean}        isStaged Whether to immediately create an undo point or not.\n\t\t */\n\t\taddRecord( record, isStaged = false ) {\n\t\t\tconst isEmpty = ! record || isRecordEmpty( record );\n\t\t\tif ( isStaged ) {\n\t\t\t\tif ( isEmpty ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\trecord.forEach( ( changes ) => {\n\t\t\t\t\tstagedRecord = addHistoryChangesIntoRecord(\n\t\t\t\t\t\tstagedRecord,\n\t\t\t\t\t\tchanges\n\t\t\t\t\t);\n\t\t\t\t} );\n\t\t\t} else {\n\t\t\t\tdropPendingRedos();\n\t\t\t\tif ( stagedRecord.length ) {\n\t\t\t\t\tappendStagedRecordToLatestHistoryRecord();\n\t\t\t\t}\n\t\t\t\tif ( isEmpty ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\thistory.push( record );\n\t\t\t}\n\t\t},\n\n\t\tundo() {\n\t\t\tif ( stagedRecord.length ) {\n\t\t\t\tdropPendingRedos();\n\t\t\t\tappendStagedRecordToLatestHistoryRecord();\n\t\t\t}\n\t\t\tconst undoRecord = history[ history.length - 1 + offset ];\n\t\t\tif ( ! undoRecord ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\toffset -= 1;\n\t\t\treturn undoRecord;\n\t\t},\n\n\t\tredo() {\n\t\t\tconst redoRecord = history[ history.length + offset ];\n\t\t\tif ( ! redoRecord ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\toffset += 1;\n\t\t\treturn redoRecord;\n\t\t},\n\n\t\thasUndo() {\n\t\t\treturn !! history[ history.length - 1 + offset ];\n\t\t},\n\n\t\thasRedo() {\n\t\t\treturn !! history[ history.length + offset ];\n\t\t},\n\t};\n}\n","/** @typedef {import('../types').AnyFunction} AnyFunction */\n\n/**\n * A higher-order reducer creator which invokes the original reducer only if\n * the dispatching action matches the given predicate, **OR** if state is\n * initializing (undefined).\n *\n * @param {AnyFunction} isMatch Function predicate for allowing reducer call.\n *\n * @return {AnyFunction} Higher-order reducer.\n */\nconst ifMatchingAction = ( isMatch ) => ( reducer ) => ( state, action ) => {\n\tif ( state === undefined || isMatch( action ) ) {\n\t\treturn reducer( state, action );\n\t}\n\n\treturn state;\n};\n\nexport default ifMatchingAction;\n","/** @typedef {import('../types').AnyFunction} AnyFunction */\n\n/**\n * Higher-order reducer creator which substitutes the action object before\n * passing to the original reducer.\n *\n * @param {AnyFunction} replacer Function mapping original action to replacement.\n *\n * @return {AnyFunction} Higher-order reducer.\n */\nconst replaceAction = ( replacer ) => ( reducer ) => ( state, action ) => {\n\treturn reducer( state, replacer( action ) );\n};\n\nexport default replaceAction;\n","/** @typedef {import('../types').AnyFunction} AnyFunction */\n\n/**\n * Higher-order reducer creator which creates a combined reducer object, keyed\n * by a property on the action object.\n *\n * @param {string} actionProperty Action property by which to key object.\n *\n * @return {AnyFunction} Higher-order reducer.\n */\nexport const onSubKey =\n\t( actionProperty ) =>\n\t( reducer ) =>\n\t( state = {}, action ) => {\n\t\t// Retrieve subkey from action. Do not track if undefined; useful for cases\n\t\t// where reducer is scoped by action shape.\n\t\tconst key = action[ actionProperty ];\n\t\tif ( key === undefined ) {\n\t\t\treturn state;\n\t\t}\n\n\t\t// Avoid updating state if unchanged. Note that this also accounts for a\n\t\t// reducer which returns undefined on a key which is not yet tracked.\n\t\tconst nextKeyState = reducer( state[ key ], action );\n\t\tif ( nextKeyState === state[ key ] ) {\n\t\t\treturn state;\n\t\t}\n\n\t\treturn {\n\t\t\t...state,\n\t\t\t[ key ]: nextKeyState,\n\t\t};\n\t};\n\nexport default onSubKey;\n","/******************************************************************************\nCopyright (c) Microsoft Corporation.\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\n\nvar extendStatics = function(d, b) {\n  extendStatics = Object.setPrototypeOf ||\n      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n  return extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  if (typeof b !== \"function\" && b !== null)\n      throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n  extendStatics(d, b);\n  function __() { this.constructor = d; }\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nexport var __assign = function() {\n  __assign = Object.assign || function __assign(t) {\n      for (var s, i = 1, n = arguments.length; i < n; i++) {\n          s = arguments[i];\n          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n      return t;\n  }\n  return __assign.apply(this, arguments);\n}\n\nexport function __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n      t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n              t[p[i]] = s[p[i]];\n      }\n  return t;\n}\n\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nexport function __param(paramIndex, decorator) {\n  return function (target, key) { decorator(target, key, paramIndex); }\n}\n\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n  function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\n  var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n  var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n  var _, done = false;\n  for (var i = decorators.length - 1; i >= 0; i--) {\n      var context = {};\n      for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n      for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n      context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\n      var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\n      if (kind === \"accessor\") {\n          if (result === void 0) continue;\n          if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n          if (_ = accept(result.get)) descriptor.get = _;\n          if (_ = accept(result.set)) descriptor.set = _;\n          if (_ = accept(result.init)) initializers.unshift(_);\n      }\n      else if (_ = accept(result)) {\n          if (kind === \"field\") initializers.unshift(_);\n          else descriptor[key] = _;\n      }\n  }\n  if (target) Object.defineProperty(target, contextIn.name, descriptor);\n  done = true;\n};\n\nexport function __runInitializers(thisArg, initializers, value) {\n  var useValue = arguments.length > 2;\n  for (var i = 0; i < initializers.length; i++) {\n      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n  }\n  return useValue ? value : void 0;\n};\n\nexport function __propKey(x) {\n  return typeof x === \"symbol\" ? x : \"\".concat(x);\n};\n\nexport function __setFunctionName(f, name, prefix) {\n  if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n  return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n};\n\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n  return new (P || (P = Promise))(function (resolve, reject) {\n      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n      function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n      step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\n\nexport function __generator(thisArg, body) {\n  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\n  return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n  function verb(n) { return function (v) { return step([n, v]); }; }\n  function step(op) {\n      if (f) throw new TypeError(\"Generator is already executing.\");\n      while (g && (g = 0, op[0] && (_ = 0)), _) try {\n          if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n          if (y = 0, t) op = [op[0] & 2, t.value];\n          switch (op[0]) {\n              case 0: case 1: t = op; break;\n              case 4: _.label++; return { value: op[1], done: false };\n              case 5: _.label++; y = op[1]; op = [0]; continue;\n              case 7: op = _.ops.pop(); _.trys.pop(); continue;\n              default:\n                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                  if (t[2]) _.ops.pop();\n                  _.trys.pop(); continue;\n          }\n          op = body.call(thisArg, _);\n      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n  }\n}\n\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n  }\n  Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\n\nexport function __exportStar(m, o) {\n  for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\n\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n      next: function () {\n          if (o && i >= o.length) o = void 0;\n          return { value: o && o[i++], done: !o };\n      }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\n\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o), r, ar = [], e;\n  try {\n      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  }\n  catch (error) { e = { error: error }; }\n  finally {\n      try {\n          if (r && !r.done && (m = i[\"return\"])) m.call(i);\n      }\n      finally { if (e) throw e.error; }\n  }\n  return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++)\n      ar = ar.concat(__read(arguments[i]));\n  return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n  for (var r = Array(s), k = 0, i = 0; i < il; i++)\n      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n          r[k] = a[j];\n  return r;\n}\n\nexport function __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n      if (ar || !(i in from)) {\n          if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n          ar[i] = from[i];\n      }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []), i, q = [];\n  return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\n  function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\n  function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\n  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n  function fulfill(value) { resume(\"next\", value); }\n  function reject(value) { resume(\"throw\", value); }\n  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n}\n\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\n}\n\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator], i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n}\n\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n  return cooked;\n};\n\nvar __setModuleDefault = Object.create ? (function(o, v) {\n  Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n  o[\"default\"] = v;\n};\n\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n}\n\nexport function __importDefault(mod) {\n  return (mod && mod.__esModule) ? mod : { default: mod };\n}\n\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\n\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n}\n\nexport function __classPrivateFieldIn(state, receiver) {\n  if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n  return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\n\nexport function __addDisposableResource(env, value, async) {\n  if (value !== null && value !== void 0) {\n    if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n    var dispose, inner;\n    if (async) {\n      if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n      dispose = value[Symbol.asyncDispose];\n    }\n    if (dispose === void 0) {\n      if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n      dispose = value[Symbol.dispose];\n      if (async) inner = dispose;\n    }\n    if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n    if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\n    env.stack.push({ value: value, dispose: dispose, async: async });\n  }\n  else if (async) {\n    env.stack.push({ async: true });\n  }\n  return value;\n}\n\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\nexport function __disposeResources(env) {\n  function fail(e) {\n    env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n    env.hasError = true;\n  }\n  var r, s = 0;\n  function next() {\n    while (r = env.stack.pop()) {\n      try {\n        if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\n        if (r.dispose) {\n          var result = r.dispose.call(r.value);\n          if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\n        }\n        else s |= 1;\n      }\n      catch (e) {\n        fail(e);\n      }\n    }\n    if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\n    if (env.hasError) throw env.error;\n  }\n  return next();\n}\n\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\n  if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\n      return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\n          return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\n      });\n  }\n  return path;\n}\n\nexport default {\n  __extends,\n  __assign,\n  __rest,\n  __decorate,\n  __param,\n  __esDecorate,\n  __runInitializers,\n  __propKey,\n  __setFunctionName,\n  __metadata,\n  __awaiter,\n  __generator,\n  __createBinding,\n  __exportStar,\n  __values,\n  __read,\n  __spread,\n  __spreadArrays,\n  __spreadArray,\n  __await,\n  __asyncGenerator,\n  __asyncDelegator,\n  __asyncValues,\n  __makeTemplateObject,\n  __importStar,\n  __importDefault,\n  __classPrivateFieldGet,\n  __classPrivateFieldSet,\n  __classPrivateFieldIn,\n  __addDisposableResource,\n  __disposeResources,\n  __rewriteRelativeImportExtension,\n};\n","/**\n * Locale character mapping rules.\n */\ninterface Locale {\n  regexp: RegExp;\n  map: Record<string, string>;\n}\n\n/**\n * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt\n */\nconst SUPPORTED_LOCALE: Record<string, Locale> = {\n  tr: {\n    regexp: /\\u0130|\\u0049|\\u0049\\u0307/g,\n    map: {\n      İ: \"\\u0069\",\n      I: \"\\u0131\",\n      İ: \"\\u0069\",\n    },\n  },\n  az: {\n    regexp: /\\u0130/g,\n    map: {\n      İ: \"\\u0069\",\n      I: \"\\u0131\",\n      İ: \"\\u0069\",\n    },\n  },\n  lt: {\n    regexp: /\\u0049|\\u004A|\\u012E|\\u00CC|\\u00CD|\\u0128/g,\n    map: {\n      I: \"\\u0069\\u0307\",\n      J: \"\\u006A\\u0307\",\n      Į: \"\\u012F\\u0307\",\n      Ì: \"\\u0069\\u0307\\u0300\",\n      Í: \"\\u0069\\u0307\\u0301\",\n      Ĩ: \"\\u0069\\u0307\\u0303\",\n    },\n  },\n};\n\n/**\n * Localized lower case.\n */\nexport function localeLowerCase(str: string, locale: string) {\n  const lang = SUPPORTED_LOCALE[locale.toLowerCase()];\n  if (lang) return lowerCase(str.replace(lang.regexp, (m) => lang.map[m]));\n  return lowerCase(str);\n}\n\n/**\n * Lower case as a function.\n */\nexport function lowerCase(str: string) {\n  return str.toLowerCase();\n}\n","import { lowerCase } from \"lower-case\";\n\nexport interface Options {\n  splitRegexp?: RegExp | RegExp[];\n  stripRegexp?: RegExp | RegExp[];\n  delimiter?: string;\n  transform?: (part: string, index: number, parts: string[]) => string;\n}\n\n// Support camel case (\"camelCase\" -> \"camel Case\" and \"CAMELCase\" -> \"CAMEL Case\").\nconst DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];\n\n// Remove all non-word characters.\nconst DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;\n\n/**\n * Normalize the string into something other libraries can manipulate easier.\n */\nexport function noCase(input: string, options: Options = {}) {\n  const {\n    splitRegexp = DEFAULT_SPLIT_REGEXP,\n    stripRegexp = DEFAULT_STRIP_REGEXP,\n    transform = lowerCase,\n    delimiter = \" \",\n  } = options;\n\n  let result = replace(\n    replace(input, splitRegexp, \"$1\\0$2\"),\n    stripRegexp,\n    \"\\0\"\n  );\n  let start = 0;\n  let end = result.length;\n\n  // Trim the delimiter from around the output string.\n  while (result.charAt(start) === \"\\0\") start++;\n  while (result.charAt(end - 1) === \"\\0\") end--;\n\n  // Transform each token independently.\n  return result.slice(start, end).split(\"\\0\").map(transform).join(delimiter);\n}\n\n/**\n * Replace `re` in the input string with the replacement value.\n */\nfunction replace(input: string, re: RegExp | RegExp[], value: string) {\n  if (re instanceof RegExp) return input.replace(re, value);\n  return re.reduce((input, re) => input.replace(re, value), input);\n}\n","import { noCase, Options } from \"no-case\";\nimport { upperCaseFirst } from \"upper-case-first\";\n\nexport { Options };\n\nexport function capitalCaseTransform(input: string) {\n  return upperCaseFirst(input.toLowerCase());\n}\n\nexport function capitalCase(input: string, options: Options = {}) {\n  return noCase(input, {\n    delimiter: \" \",\n    transform: capitalCaseTransform,\n    ...options,\n  });\n}\n","/**\n * Upper case the first character of an input string.\n */\nexport function upperCaseFirst(input: string) {\n  return input.charAt(0).toUpperCase() + input.substr(1);\n}\n","import { noCase, Options } from \"no-case\";\n\nexport { Options };\n\nexport function pascalCaseTransform(input: string, index: number) {\n  const firstChar = input.charAt(0);\n  const lowerChars = input.substr(1).toLowerCase();\n  if (index > 0 && firstChar >= \"0\" && firstChar <= \"9\") {\n    return `_${firstChar}${lowerChars}`;\n  }\n  return `${firstChar.toUpperCase()}${lowerChars}`;\n}\n\nexport function pascalCaseTransformMerge(input: string) {\n  return input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();\n}\n\nexport function pascalCase(input: string, options: Options = {}) {\n  return noCase(input, {\n    delimiter: \"\",\n    transform: pascalCaseTransform,\n    ...options,\n  });\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"apiFetch\"];","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"i18n\"];","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"richText\"];","/**\n * External dependencies\n */\nimport { capitalCase, pascalCase } from 'change-case';\n\n/**\n * WordPress dependencies\n */\nimport apiFetch from '@wordpress/api-fetch';\nimport { __ } from '@wordpress/i18n';\nimport { RichTextData } from '@wordpress/rich-text';\n\nexport const DEFAULT_ENTITY_KEY = 'id';\nconst POST_RAW_ATTRIBUTES = [ 'title', 'excerpt', 'content' ];\n\nexport const rootEntitiesConfig = [\n\t{\n\t\tlabel: __( 'Base' ),\n\t\tkind: 'root',\n\t\tname: '__unstableBase',\n\t\tbaseURL: '/',\n\t\tbaseURLParams: {\n\t\t\t// Please also change the preload path when changing this.\n\t\t\t// @see lib/compat/wordpress-6.8/preload.php\n\t\t\t_fields: [\n\t\t\t\t'description',\n\t\t\t\t'gmt_offset',\n\t\t\t\t'home',\n\t\t\t\t'name',\n\t\t\t\t'site_icon',\n\t\t\t\t'site_icon_url',\n\t\t\t\t'site_logo',\n\t\t\t\t'timezone_string',\n\t\t\t\t'url',\n\t\t\t\t'page_for_posts',\n\t\t\t\t'page_on_front',\n\t\t\t\t'show_on_front',\n\t\t\t].join( ',' ),\n\t\t},\n\t\t// The entity doesn't support selecting multiple records.\n\t\t// The property is maintained for backward compatibility.\n\t\tplural: '__unstableBases',\n\t\tsyncConfig: {\n\t\t\tfetch: async () => {\n\t\t\t\treturn apiFetch( { path: '/' } );\n\t\t\t},\n\t\t\tapplyChangesToDoc: ( doc, changes ) => {\n\t\t\t\tconst document = doc.getMap( 'document' );\n\t\t\t\tObject.entries( changes ).forEach( ( [ key, value ] ) => {\n\t\t\t\t\tif ( document.get( key ) !== value ) {\n\t\t\t\t\t\tdocument.set( key, value );\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t},\n\t\t\tfromCRDTDoc: ( doc ) => {\n\t\t\t\treturn doc.getMap( 'document' ).toJSON();\n\t\t\t},\n\t\t},\n\t\tsyncObjectType: 'root/base',\n\t\tgetSyncObjectId: () => 'index',\n\t},\n\t{\n\t\tlabel: __( 'Post Type' ),\n\t\tname: 'postType',\n\t\tkind: 'root',\n\t\tkey: 'slug',\n\t\tbaseURL: '/wp/v2/types',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'postTypes',\n\t\tsyncConfig: {\n\t\t\tfetch: async ( id ) => {\n\t\t\t\treturn apiFetch( {\n\t\t\t\t\tpath: `/wp/v2/types/${ id }?context=edit`,\n\t\t\t\t} );\n\t\t\t},\n\t\t\tapplyChangesToDoc: ( doc, changes ) => {\n\t\t\t\tconst document = doc.getMap( 'document' );\n\t\t\t\tObject.entries( changes ).forEach( ( [ key, value ] ) => {\n\t\t\t\t\tif ( document.get( key ) !== value ) {\n\t\t\t\t\t\tdocument.set( key, value );\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t},\n\t\t\tfromCRDTDoc: ( doc ) => {\n\t\t\t\treturn doc.getMap( 'document' ).toJSON();\n\t\t\t},\n\t\t},\n\t\tsyncObjectType: 'root/postType',\n\t\tgetSyncObjectId: ( id ) => id,\n\t},\n\t{\n\t\tname: 'media',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/media',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'mediaItems',\n\t\tlabel: __( 'Media' ),\n\t\trawAttributes: [ 'caption', 'title', 'description' ],\n\t\tsupportsPagination: true,\n\t},\n\t{\n\t\tname: 'taxonomy',\n\t\tkind: 'root',\n\t\tkey: 'slug',\n\t\tbaseURL: '/wp/v2/taxonomies',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'taxonomies',\n\t\tlabel: __( 'Taxonomy' ),\n\t},\n\t{\n\t\tname: 'sidebar',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/sidebars',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'sidebars',\n\t\ttransientEdits: { blocks: true },\n\t\tlabel: __( 'Widget areas' ),\n\t},\n\t{\n\t\tname: 'widget',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/widgets',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'widgets',\n\t\ttransientEdits: { blocks: true },\n\t\tlabel: __( 'Widgets' ),\n\t},\n\t{\n\t\tname: 'widgetType',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/widget-types',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'widgetTypes',\n\t\tlabel: __( 'Widget types' ),\n\t},\n\t{\n\t\tlabel: __( 'User' ),\n\t\tname: 'user',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/users',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'users',\n\t},\n\t{\n\t\tname: 'comment',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/comments',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'comments',\n\t\tlabel: __( 'Comment' ),\n\t},\n\t{\n\t\tname: 'menu',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/menus',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'menus',\n\t\tlabel: __( 'Menu' ),\n\t},\n\t{\n\t\tname: 'menuItem',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/menu-items',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'menuItems',\n\t\tlabel: __( 'Menu Item' ),\n\t\trawAttributes: [ 'title' ],\n\t},\n\t{\n\t\tname: 'menuLocation',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/menu-locations',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'menuLocations',\n\t\tlabel: __( 'Menu Location' ),\n\t\tkey: 'name',\n\t},\n\t{\n\t\tlabel: __( 'Global Styles' ),\n\t\tname: 'globalStyles',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/global-styles',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'globalStylesVariations', // Should be different from name.\n\t\tgetTitle: ( record ) => record?.title?.rendered || record?.title,\n\t\tgetRevisionsUrl: ( parentId, revisionId ) =>\n\t\t\t`/wp/v2/global-styles/${ parentId }/revisions${\n\t\t\t\trevisionId ? '/' + revisionId : ''\n\t\t\t}`,\n\t\tsupportsPagination: true,\n\t},\n\t{\n\t\tlabel: __( 'Themes' ),\n\t\tname: 'theme',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/themes',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'themes',\n\t\tkey: 'stylesheet',\n\t},\n\t{\n\t\tlabel: __( 'Plugins' ),\n\t\tname: 'plugin',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/plugins',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'plugins',\n\t\tkey: 'plugin',\n\t},\n\t{\n\t\tlabel: __( 'Status' ),\n\t\tname: 'status',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/statuses',\n\t\tbaseURLParams: { context: 'edit' },\n\t\tplural: 'statuses',\n\t\tkey: 'slug',\n\t},\n];\n\nexport const additionalEntityConfigLoaders = [\n\t{ kind: 'postType', loadEntities: loadPostTypeEntities },\n\t{ kind: 'taxonomy', loadEntities: loadTaxonomyEntities },\n\t{\n\t\tkind: 'root',\n\t\tname: 'site',\n\t\tplural: 'sites',\n\t\tloadEntities: loadSiteEntity,\n\t},\n];\n\n/**\n * Returns a function to be used to retrieve extra edits to apply before persisting a post type.\n *\n * @param {Object} persistedRecord Already persisted Post\n * @param {Object} edits           Edits.\n * @return {Object} Updated edits.\n */\nexport const prePersistPostType = ( persistedRecord, edits ) => {\n\tconst newEdits = {};\n\n\tif ( persistedRecord?.status === 'auto-draft' ) {\n\t\t// Saving an auto-draft should create a draft by default.\n\t\tif ( ! edits.status && ! newEdits.status ) {\n\t\t\tnewEdits.status = 'draft';\n\t\t}\n\n\t\t// Fix the auto-draft default title.\n\t\tif (\n\t\t\t( ! edits.title || edits.title === 'Auto Draft' ) &&\n\t\t\t! newEdits.title &&\n\t\t\t( ! persistedRecord?.title ||\n\t\t\t\tpersistedRecord?.title === 'Auto Draft' )\n\t\t) {\n\t\t\tnewEdits.title = '';\n\t\t}\n\t}\n\n\treturn newEdits;\n};\n\nconst serialisableBlocksCache = new WeakMap();\n\nfunction makeBlockAttributesSerializable( attributes ) {\n\tconst newAttributes = { ...attributes };\n\tfor ( const [ key, value ] of Object.entries( attributes ) ) {\n\t\tif ( value instanceof RichTextData ) {\n\t\t\tnewAttributes[ key ] = value.valueOf();\n\t\t}\n\t}\n\treturn newAttributes;\n}\n\nfunction makeBlocksSerializable( blocks ) {\n\treturn blocks.map( ( block ) => {\n\t\tconst { innerBlocks, attributes, ...rest } = block;\n\t\treturn {\n\t\t\t...rest,\n\t\t\tattributes: makeBlockAttributesSerializable( attributes ),\n\t\t\tinnerBlocks: makeBlocksSerializable( innerBlocks ),\n\t\t};\n\t} );\n}\n\n/**\n * Returns the list of post type entities.\n *\n * @return {Promise} Entities promise\n */\nasync function loadPostTypeEntities() {\n\tconst postTypes = await apiFetch( {\n\t\tpath: '/wp/v2/types?context=view',\n\t} );\n\treturn Object.entries( postTypes ?? {} ).map( ( [ name, postType ] ) => {\n\t\tconst isTemplate = [ 'wp_template', 'wp_template_part' ].includes(\n\t\t\tname\n\t\t);\n\t\tconst namespace = postType?.rest_namespace ?? 'wp/v2';\n\t\treturn {\n\t\t\tkind: 'postType',\n\t\t\tbaseURL: `/${ namespace }/${ postType.rest_base }`,\n\t\t\tbaseURLParams: { context: 'edit' },\n\t\t\tname,\n\t\t\tlabel: postType.name,\n\t\t\ttransientEdits: {\n\t\t\t\tblocks: true,\n\t\t\t\tselection: true,\n\t\t\t},\n\t\t\tmergedEdits: { meta: true },\n\t\t\trawAttributes: POST_RAW_ATTRIBUTES,\n\t\t\tgetTitle: ( record ) =>\n\t\t\t\trecord?.title?.rendered ||\n\t\t\t\trecord?.title ||\n\t\t\t\t( isTemplate\n\t\t\t\t\t? capitalCase( record.slug ?? '' )\n\t\t\t\t\t: String( record.id ) ),\n\t\t\t__unstablePrePersist: isTemplate ? undefined : prePersistPostType,\n\t\t\t__unstable_rest_base: postType.rest_base,\n\t\t\tsyncConfig: {\n\t\t\t\tfetch: async ( id ) => {\n\t\t\t\t\treturn apiFetch( {\n\t\t\t\t\t\tpath: `/${ namespace }/${ postType.rest_base }/${ id }?context=edit`,\n\t\t\t\t\t} );\n\t\t\t\t},\n\t\t\t\tapplyChangesToDoc: ( doc, changes ) => {\n\t\t\t\t\tconst document = doc.getMap( 'document' );\n\n\t\t\t\t\tObject.entries( changes ).forEach( ( [ key, value ] ) => {\n\t\t\t\t\t\tif ( typeof value !== 'function' ) {\n\t\t\t\t\t\t\tif ( key === 'blocks' ) {\n\t\t\t\t\t\t\t\tif ( ! serialisableBlocksCache.has( value ) ) {\n\t\t\t\t\t\t\t\t\tserialisableBlocksCache.set(\n\t\t\t\t\t\t\t\t\t\tvalue,\n\t\t\t\t\t\t\t\t\t\tmakeBlocksSerializable( value )\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\tvalue = serialisableBlocksCache.get( value );\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif ( document.get( key ) !== value ) {\n\t\t\t\t\t\t\t\tdocument.set( key, value );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\t\t\t\t},\n\t\t\t\tfromCRDTDoc: ( doc ) => {\n\t\t\t\t\treturn doc.getMap( 'document' ).toJSON();\n\t\t\t\t},\n\t\t\t},\n\t\t\tsyncObjectType: 'postType/' + postType.name,\n\t\t\tgetSyncObjectId: ( id ) => id,\n\t\t\tsupportsPagination: true,\n\t\t\tgetRevisionsUrl: ( parentId, revisionId ) =>\n\t\t\t\t`/${ namespace }/${\n\t\t\t\t\tpostType.rest_base\n\t\t\t\t}/${ parentId }/revisions${\n\t\t\t\t\trevisionId ? '/' + revisionId : ''\n\t\t\t\t}`,\n\t\t\trevisionKey: isTemplate ? 'wp_id' : DEFAULT_ENTITY_KEY,\n\t\t};\n\t} );\n}\n\n/**\n * Returns the list of the taxonomies entities.\n *\n * @return {Promise} Entities promise\n */\nasync function loadTaxonomyEntities() {\n\tconst taxonomies = await apiFetch( {\n\t\tpath: '/wp/v2/taxonomies?context=view',\n\t} );\n\treturn Object.entries( taxonomies ?? {} ).map( ( [ name, taxonomy ] ) => {\n\t\tconst namespace = taxonomy?.rest_namespace ?? 'wp/v2';\n\t\treturn {\n\t\t\tkind: 'taxonomy',\n\t\t\tbaseURL: `/${ namespace }/${ taxonomy.rest_base }`,\n\t\t\tbaseURLParams: { context: 'edit' },\n\t\t\tname,\n\t\t\tlabel: taxonomy.name,\n\t\t};\n\t} );\n}\n\n/**\n * Returns the Site entity.\n *\n * @return {Promise} Entity promise\n */\nasync function loadSiteEntity() {\n\tconst entity = {\n\t\tlabel: __( 'Site' ),\n\t\tname: 'site',\n\t\tkind: 'root',\n\t\tbaseURL: '/wp/v2/settings',\n\t\tsyncConfig: {\n\t\t\tfetch: async () => {\n\t\t\t\treturn apiFetch( { path: '/wp/v2/settings' } );\n\t\t\t},\n\t\t\tapplyChangesToDoc: ( doc, changes ) => {\n\t\t\t\tconst document = doc.getMap( 'document' );\n\t\t\t\tObject.entries( changes ).forEach( ( [ key, value ] ) => {\n\t\t\t\t\tif ( document.get( key ) !== value ) {\n\t\t\t\t\t\tdocument.set( key, value );\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t},\n\t\t\tfromCRDTDoc: ( doc ) => {\n\t\t\t\treturn doc.getMap( 'document' ).toJSON();\n\t\t\t},\n\t\t},\n\t\tsyncObjectType: 'root/site',\n\t\tgetSyncObjectId: () => 'index',\n\t\tmeta: {},\n\t};\n\n\tconst site = await apiFetch( {\n\t\tpath: entity.baseURL,\n\t\tmethod: 'OPTIONS',\n\t} );\n\n\tconst labels = {};\n\tObject.entries( site?.schema?.properties ?? {} ).forEach(\n\t\t( [ key, value ] ) => {\n\t\t\t// Ignore properties `title` and `type` keys.\n\t\t\tif ( typeof value === 'object' && value.title ) {\n\t\t\t\tlabels[ key ] = value.title;\n\t\t\t}\n\t\t}\n\t);\n\n\treturn [ { ...entity, meta: { labels } } ];\n}\n\n/**\n * Returns the entity's getter method name given its kind and name or plural name.\n *\n * @example\n * ```js\n * const nameSingular = getMethodName( 'root', 'theme', 'get' );\n * // nameSingular is getRootTheme\n *\n * const namePlural = getMethodName( 'root', 'themes', 'set' );\n * // namePlural is setRootThemes\n * ```\n *\n * @param {string} kind   Entity kind.\n * @param {string} name   Entity name or plural name.\n * @param {string} prefix Function prefix.\n *\n * @return {string} Method name\n */\nexport const getMethodName = ( kind, name, prefix = 'get' ) => {\n\tconst kindPrefix = kind === 'root' ? '' : pascalCase( kind );\n\tconst suffix = pascalCase( name );\n\treturn `${ prefix }${ kindPrefix }${ suffix }`;\n};\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"url\"];","/**\n * Given a value which can be specified as one or the other of a comma-separated\n * string or an array, returns a value normalized to an array of strings, or\n * null if the value cannot be interpreted as either.\n *\n * @param {string|string[]|*} value\n *\n * @return {?(string[])} Normalized field value.\n */\nfunction getNormalizedCommaSeparable( value ) {\n\tif ( typeof value === 'string' ) {\n\t\treturn value.split( ',' );\n\t} else if ( Array.isArray( value ) ) {\n\t\treturn value;\n\t}\n\n\treturn null;\n}\n\nexport default getNormalizedCommaSeparable;\n","/**\n * WordPress dependencies\n */\nimport { addQueryArgs } from '@wordpress/url';\n\n/**\n * Internal dependencies\n */\nimport { withWeakMapCache, getNormalizedCommaSeparable } from '../utils';\n\n/**\n * An object of properties describing a specific query.\n *\n * @typedef {Object} WPQueriedDataQueryParts\n *\n * @property {number}      page      The query page (1-based index, default 1).\n * @property {number}      perPage   Items per page for query (default 10).\n * @property {string}      stableKey An encoded stable string of all non-\n *                                   pagination, non-fields query parameters.\n * @property {?(string[])} fields    Target subset of fields to derive from\n *                                   item objects.\n * @property {?(number[])} include   Specific item IDs to include.\n * @property {string}      context   Scope under which the request is made;\n *                                   determines returned fields in response.\n */\n\n/**\n * Given a query object, returns an object of parts, including pagination\n * details (`page` and `perPage`, or default values). All other properties are\n * encoded into a stable (idempotent) `stableKey` value.\n *\n * @param {Object} query Optional query object.\n *\n * @return {WPQueriedDataQueryParts} Query parts.\n */\nexport function getQueryParts( query ) {\n\t/**\n\t * @type {WPQueriedDataQueryParts}\n\t */\n\tconst parts = {\n\t\tstableKey: '',\n\t\tpage: 1,\n\t\tperPage: 10,\n\t\tfields: null,\n\t\tinclude: null,\n\t\tcontext: 'default',\n\t};\n\n\t// Ensure stable key by sorting keys. Also more efficient for iterating.\n\tconst keys = Object.keys( query ).sort();\n\n\tfor ( let i = 0; i < keys.length; i++ ) {\n\t\tconst key = keys[ i ];\n\t\tlet value = query[ key ];\n\n\t\tswitch ( key ) {\n\t\t\tcase 'page':\n\t\t\t\tparts[ key ] = Number( value );\n\t\t\t\tbreak;\n\n\t\t\tcase 'per_page':\n\t\t\t\tparts.perPage = Number( value );\n\t\t\t\tbreak;\n\n\t\t\tcase 'context':\n\t\t\t\tparts.context = value;\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\t// While in theory, we could exclude \"_fields\" from the stableKey\n\t\t\t\t// because two request with different fields have the same results\n\t\t\t\t// We're not able to ensure that because the server can decide to omit\n\t\t\t\t// fields from the response even if we explicitly asked for it.\n\t\t\t\t// Example: Asking for titles in posts without title support.\n\t\t\t\tif ( key === '_fields' ) {\n\t\t\t\t\tparts.fields = getNormalizedCommaSeparable( value ) ?? [];\n\t\t\t\t\t// Make sure to normalize value for `stableKey`\n\t\t\t\t\tvalue = parts.fields.join();\n\t\t\t\t}\n\n\t\t\t\t// Two requests with different include values cannot have same results.\n\t\t\t\tif ( key === 'include' ) {\n\t\t\t\t\tif ( typeof value === 'number' ) {\n\t\t\t\t\t\tvalue = value.toString();\n\t\t\t\t\t}\n\t\t\t\t\tparts.include = (\n\t\t\t\t\t\tgetNormalizedCommaSeparable( value ) ?? []\n\t\t\t\t\t).map( Number );\n\t\t\t\t\t// Normalize value for `stableKey`.\n\t\t\t\t\tvalue = parts.include.join();\n\t\t\t\t}\n\n\t\t\t\t// While it could be any deterministic string, for simplicity's\n\t\t\t\t// sake mimic querystring encoding for stable key.\n\t\t\t\t//\n\t\t\t\t// TODO: For consistency with PHP implementation, addQueryArgs\n\t\t\t\t// should accept a key value pair, which may optimize its\n\t\t\t\t// implementation for our use here, vs. iterating an object\n\t\t\t\t// with only a single key.\n\t\t\t\tparts.stableKey +=\n\t\t\t\t\t( parts.stableKey ? '&' : '' ) +\n\t\t\t\t\taddQueryArgs( '', { [ key ]: value } ).slice( 1 );\n\t\t}\n\t}\n\n\treturn parts;\n}\n\nexport default withWeakMapCache( getQueryParts );\n","/**\n * Given a function, returns an enhanced function which caches the result and\n * tracks in WeakMap. The result is only cached if the original function is\n * passed a valid object-like argument (requirement for WeakMap key).\n *\n * @param {Function} fn Original function.\n *\n * @return {Function} Enhanced caching function.\n */\nfunction withWeakMapCache( fn ) {\n\tconst cache = new WeakMap();\n\n\treturn ( key ) => {\n\t\tlet value;\n\t\tif ( cache.has( key ) ) {\n\t\t\tvalue = cache.get( key );\n\t\t} else {\n\t\t\tvalue = fn( key );\n\n\t\t\t// Can reach here if key is not valid for WeakMap, since `has`\n\t\t\t// will return false for invalid key. Since `set` will throw,\n\t\t\t// ensure that key is valid before setting into cache.\n\t\t\tif ( key !== null && typeof key === 'object' ) {\n\t\t\t\tcache.set( key, value );\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t};\n}\n\nexport default withWeakMapCache;\n","/**\n * WordPress dependencies\n */\nimport { combineReducers } from '@wordpress/data';\nimport { compose } from '@wordpress/compose';\n\n/**\n * Internal dependencies\n */\nimport {\n\tconservativeMapItem,\n\tifMatchingAction,\n\treplaceAction,\n\tonSubKey,\n} from '../utils';\nimport { DEFAULT_ENTITY_KEY } from '../entities';\nimport getQueryParts from './get-query-parts';\n\nfunction getContextFromAction( action ) {\n\tconst { query } = action;\n\tif ( ! query ) {\n\t\treturn 'default';\n\t}\n\n\tconst queryParts = getQueryParts( query );\n\treturn queryParts.context;\n}\n\n/**\n * Returns a merged array of item IDs, given details of the received paginated\n * items. The array is sparse-like with `undefined` entries where holes exist.\n *\n * @param {?Array<number>} itemIds     Original item IDs (default empty array).\n * @param {number[]}       nextItemIds Item IDs to merge.\n * @param {number}         page        Page of items merged.\n * @param {number}         perPage     Number of items per page.\n *\n * @return {number[]} Merged array of item IDs.\n */\nexport function getMergedItemIds( itemIds, nextItemIds, page, perPage ) {\n\tconst receivedAllIds = page === 1 && perPage === -1;\n\tif ( receivedAllIds ) {\n\t\treturn nextItemIds;\n\t}\n\tconst nextItemIdsStartIndex = ( page - 1 ) * perPage;\n\n\t// If later page has already been received, default to the larger known\n\t// size of the existing array, else calculate as extending the existing.\n\tconst size = Math.max(\n\t\titemIds?.length ?? 0,\n\t\tnextItemIdsStartIndex + nextItemIds.length\n\t);\n\n\t// Preallocate array since size is known.\n\tconst mergedItemIds = new Array( size );\n\n\tfor ( let i = 0; i < size; i++ ) {\n\t\t// Preserve existing item ID except for subset of range of next items.\n\t\t// We need to check against the possible maximum upper boundary because\n\t\t// a page could receive fewer than what was previously stored.\n\t\tconst isInNextItemsRange =\n\t\t\ti >= nextItemIdsStartIndex && i < nextItemIdsStartIndex + perPage;\n\t\tmergedItemIds[ i ] = isInNextItemsRange\n\t\t\t? nextItemIds[ i - nextItemIdsStartIndex ]\n\t\t\t: itemIds?.[ i ];\n\t}\n\n\treturn mergedItemIds;\n}\n\n/**\n * Helper function to filter out entities with certain IDs.\n * Entities are keyed by their ID.\n *\n * @param {Object} entities Entity objects, keyed by entity ID.\n * @param {Array}  ids      Entity IDs to filter out.\n *\n * @return {Object} Filtered entities.\n */\nfunction removeEntitiesById( entities, ids ) {\n\treturn Object.fromEntries(\n\t\tObject.entries( entities ).filter(\n\t\t\t( [ id ] ) =>\n\t\t\t\t! ids.some( ( itemId ) => {\n\t\t\t\t\tif ( Number.isInteger( itemId ) ) {\n\t\t\t\t\t\treturn itemId === +id;\n\t\t\t\t\t}\n\t\t\t\t\treturn itemId === id;\n\t\t\t\t} )\n\t\t)\n\t);\n}\n\n/**\n * Reducer tracking items state, keyed by ID. Items are assumed to be normal,\n * where identifiers are common across all queries.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Next state.\n */\nexport function items( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_ITEMS': {\n\t\t\tconst context = getContextFromAction( action );\n\t\t\tconst key = action.key || DEFAULT_ENTITY_KEY;\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ context ]: {\n\t\t\t\t\t...state[ context ],\n\t\t\t\t\t...action.items.reduce( ( accumulator, value ) => {\n\t\t\t\t\t\tconst itemId = value?.[ key ];\n\n\t\t\t\t\t\taccumulator[ itemId ] = conservativeMapItem(\n\t\t\t\t\t\t\tstate?.[ context ]?.[ itemId ],\n\t\t\t\t\t\t\tvalue\n\t\t\t\t\t\t);\n\t\t\t\t\t\treturn accumulator;\n\t\t\t\t\t}, {} ),\n\t\t\t\t},\n\t\t\t};\n\t\t}\n\t\tcase 'REMOVE_ITEMS':\n\t\t\treturn Object.fromEntries(\n\t\t\t\tObject.entries( state ).map( ( [ itemId, contextState ] ) => [\n\t\t\t\t\titemId,\n\t\t\t\t\tremoveEntitiesById( contextState, action.itemIds ),\n\t\t\t\t] )\n\t\t\t);\n\t}\n\treturn state;\n}\n\n/**\n * Reducer tracking item completeness, keyed by ID. A complete item is one for\n * which all fields are known. This is used in supporting `_fields` queries,\n * where not all properties associated with an entity are necessarily returned.\n * In such cases, completeness is used as an indication of whether it would be\n * safe to use queried data for a non-`_fields`-limited request.\n *\n * @param {Object<string,Object<string,boolean>>} state  Current state.\n * @param {Object}                                action Dispatched action.\n *\n * @return {Object<string,Object<string,boolean>>} Next state.\n */\nexport function itemIsComplete( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_ITEMS': {\n\t\t\tconst context = getContextFromAction( action );\n\t\t\tconst { query, key = DEFAULT_ENTITY_KEY } = action;\n\n\t\t\t// An item is considered complete if it is received without an associated\n\t\t\t// fields query. Ideally, this would be implemented in such a way where the\n\t\t\t// complete aggregate of all fields would satisfy completeness. Since the\n\t\t\t// fields are not consistent across all entities, this would require\n\t\t\t// introspection on the REST schema for each entity to know which fields\n\t\t\t// compose a complete item for that entity.\n\t\t\tconst queryParts = query ? getQueryParts( query ) : {};\n\t\t\tconst isCompleteQuery =\n\t\t\t\t! query || ! Array.isArray( queryParts.fields );\n\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ context ]: {\n\t\t\t\t\t...state[ context ],\n\t\t\t\t\t...action.items.reduce( ( result, item ) => {\n\t\t\t\t\t\tconst itemId = item?.[ key ];\n\n\t\t\t\t\t\t// Defer to completeness if already assigned. Technically the\n\t\t\t\t\t\t// data may be outdated if receiving items for a field subset.\n\t\t\t\t\t\tresult[ itemId ] =\n\t\t\t\t\t\t\tstate?.[ context ]?.[ itemId ] || isCompleteQuery;\n\n\t\t\t\t\t\treturn result;\n\t\t\t\t\t}, {} ),\n\t\t\t\t},\n\t\t\t};\n\t\t}\n\t\tcase 'REMOVE_ITEMS':\n\t\t\treturn Object.fromEntries(\n\t\t\t\tObject.entries( state ).map( ( [ itemId, contextState ] ) => [\n\t\t\t\t\titemId,\n\t\t\t\t\tremoveEntitiesById( contextState, action.itemIds ),\n\t\t\t\t] )\n\t\t\t);\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer tracking queries state, keyed by stable query key. Each reducer\n * query object includes `itemIds` and `requestingPageByPerPage`.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Next state.\n */\nconst receiveQueries = compose( [\n\t// Limit to matching action type so we don't attempt to replace action on\n\t// an unhandled action.\n\tifMatchingAction( ( action ) => 'query' in action ),\n\n\t// Inject query parts into action for use both in `onSubKey` and reducer.\n\treplaceAction( ( action ) => {\n\t\t// `ifMatchingAction` still passes on initialization, where state is\n\t\t// undefined and a query is not assigned. Avoid attempting to parse\n\t\t// parts. `onSubKey` will omit by lack of `stableKey`.\n\t\tif ( action.query ) {\n\t\t\treturn {\n\t\t\t\t...action,\n\t\t\t\t...getQueryParts( action.query ),\n\t\t\t};\n\t\t}\n\n\t\treturn action;\n\t} ),\n\n\tonSubKey( 'context' ),\n\n\t// Queries shape is shared, but keyed by query `stableKey` part. Original\n\t// reducer tracks only a single query object.\n\tonSubKey( 'stableKey' ),\n] )( ( state = {}, action ) => {\n\tconst { type, page, perPage, key = DEFAULT_ENTITY_KEY } = action;\n\n\tif ( type !== 'RECEIVE_ITEMS' ) {\n\t\treturn state;\n\t}\n\n\treturn {\n\t\titemIds: getMergedItemIds(\n\t\t\tstate?.itemIds || [],\n\t\t\taction.items.map( ( item ) => item?.[ key ] ).filter( Boolean ),\n\t\t\tpage,\n\t\t\tperPage\n\t\t),\n\t\tmeta: action.meta,\n\t};\n} );\n\n/**\n * Reducer tracking queries state.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Next state.\n */\nconst queries = ( state = {}, action ) => {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_ITEMS':\n\t\t\treturn receiveQueries( state, action );\n\t\tcase 'REMOVE_ITEMS':\n\t\t\tconst removedItems = action.itemIds.reduce( ( result, itemId ) => {\n\t\t\t\tresult[ itemId ] = true;\n\t\t\t\treturn result;\n\t\t\t}, {} );\n\n\t\t\treturn Object.fromEntries(\n\t\t\t\tObject.entries( state ).map(\n\t\t\t\t\t( [ queryGroup, contextQueries ] ) => [\n\t\t\t\t\t\tqueryGroup,\n\t\t\t\t\t\tObject.fromEntries(\n\t\t\t\t\t\t\tObject.entries( contextQueries ).map(\n\t\t\t\t\t\t\t\t( [ query, queryItems ] ) => [\n\t\t\t\t\t\t\t\t\tquery,\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\t...queryItems,\n\t\t\t\t\t\t\t\t\t\titemIds: queryItems.itemIds.filter(\n\t\t\t\t\t\t\t\t\t\t\t( queryId ) =>\n\t\t\t\t\t\t\t\t\t\t\t\t! removedItems[ queryId ]\n\t\t\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t]\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t),\n\t\t\t\t\t]\n\t\t\t\t)\n\t\t\t);\n\t\tdefault:\n\t\t\treturn state;\n\t}\n};\n\nexport default combineReducers( {\n\titems,\n\titemIsComplete,\n\tqueries,\n} );\n","/**\n * External dependencies\n */\nimport fastDeepEqual from 'fast-deep-equal/es6';\n\n/**\n * Given the current and next item entity record, returns the minimally \"modified\"\n * result of the next item, preferring value references from the original item\n * if equal. If all values match, the original item is returned.\n *\n * @param {Object} item     Original item.\n * @param {Object} nextItem Next item.\n *\n * @return {Object} Minimally modified merged item.\n */\nexport default function conservativeMapItem( item, nextItem ) {\n\t// Return next item in its entirety if there is no original item.\n\tif ( ! item ) {\n\t\treturn nextItem;\n\t}\n\n\tlet hasChanges = false;\n\tconst result = {};\n\tfor ( const key in nextItem ) {\n\t\tif ( fastDeepEqual( item[ key ], nextItem[ key ] ) ) {\n\t\t\tresult[ key ] = item[ key ];\n\t\t} else {\n\t\t\thasChanges = true;\n\t\t\tresult[ key ] = nextItem[ key ];\n\t\t}\n\t}\n\n\tif ( ! hasChanges ) {\n\t\treturn item;\n\t}\n\n\t// Only at this point, backfill properties from the original item which\n\t// weren't explicitly set into the result above. This is an optimization\n\t// to allow `hasChanges` to return early.\n\tfor ( const key in item ) {\n\t\tif ( ! result.hasOwnProperty( key ) ) {\n\t\t\tresult[ key ] = item[ key ];\n\t\t}\n\t}\n\n\treturn result;\n}\n","/**\n * External dependencies\n */\nimport fastDeepEqual from 'fast-deep-equal/es6';\n\n/**\n * WordPress dependencies\n */\nimport { compose } from '@wordpress/compose';\nimport { combineReducers } from '@wordpress/data';\nimport { createUndoManager } from '@wordpress/undo-manager';\n\n/**\n * Internal dependencies\n */\nimport { ifMatchingAction, replaceAction } from './utils';\nimport { reducer as queriedDataReducer } from './queried-data';\nimport { rootEntitiesConfig, DEFAULT_ENTITY_KEY } from './entities';\n\n/** @typedef {import('./types').AnyFunction} AnyFunction */\n\n/**\n * Reducer managing terms state. Keyed by taxonomy slug, the value is either\n * undefined (if no request has been made for given taxonomy), null (if a\n * request is in-flight for given taxonomy), or the array of terms for the\n * taxonomy.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function terms( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_TERMS':\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ action.taxonomy ]: action.terms,\n\t\t\t};\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer managing authors state. Keyed by id.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function users( state = { byId: {}, queries: {} }, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_USER_QUERY':\n\t\t\treturn {\n\t\t\t\tbyId: {\n\t\t\t\t\t...state.byId,\n\t\t\t\t\t// Key users by their ID.\n\t\t\t\t\t...action.users.reduce(\n\t\t\t\t\t\t( newUsers, user ) => ( {\n\t\t\t\t\t\t\t...newUsers,\n\t\t\t\t\t\t\t[ user.id ]: user,\n\t\t\t\t\t\t} ),\n\t\t\t\t\t\t{}\n\t\t\t\t\t),\n\t\t\t\t},\n\t\t\t\tqueries: {\n\t\t\t\t\t...state.queries,\n\t\t\t\t\t[ action.queryID ]: action.users.map( ( user ) => user.id ),\n\t\t\t\t},\n\t\t\t};\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer managing current user state.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function currentUser( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_CURRENT_USER':\n\t\t\treturn action.currentUser;\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer managing taxonomies.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function taxonomies( state = [], action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_TAXONOMIES':\n\t\t\treturn action.taxonomies;\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer managing the current theme.\n *\n * @param {string|undefined} state  Current state.\n * @param {Object}           action Dispatched action.\n *\n * @return {string|undefined} Updated state.\n */\nexport function currentTheme( state = undefined, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_CURRENT_THEME':\n\t\t\treturn action.currentTheme.stylesheet;\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer managing the current global styles id.\n *\n * @param {string|undefined} state  Current state.\n * @param {Object}           action Dispatched action.\n *\n * @return {string|undefined} Updated state.\n */\nexport function currentGlobalStylesId( state = undefined, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_CURRENT_GLOBAL_STYLES_ID':\n\t\t\treturn action.id;\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer managing the theme base global styles.\n *\n * @param {Record<string, object>} state  Current state.\n * @param {Object}                 action Dispatched action.\n *\n * @return {Record<string, object>} Updated state.\n */\nexport function themeBaseGlobalStyles( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_THEME_GLOBAL_STYLES':\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ action.stylesheet ]: action.globalStyles,\n\t\t\t};\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer managing the theme global styles variations.\n *\n * @param {Record<string, object>} state  Current state.\n * @param {Object}                 action Dispatched action.\n *\n * @return {Record<string, object>} Updated state.\n */\nexport function themeGlobalStyleVariations( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_THEME_GLOBAL_STYLE_VARIATIONS':\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ action.stylesheet ]: action.variations,\n\t\t\t};\n\t}\n\n\treturn state;\n}\n\nconst withMultiEntityRecordEdits = ( reducer ) => ( state, action ) => {\n\tif ( action.type === 'UNDO' || action.type === 'REDO' ) {\n\t\tconst { record } = action;\n\n\t\tlet newState = state;\n\t\trecord.forEach( ( { id: { kind, name, recordId }, changes } ) => {\n\t\t\tnewState = reducer( newState, {\n\t\t\t\ttype: 'EDIT_ENTITY_RECORD',\n\t\t\t\tkind,\n\t\t\t\tname,\n\t\t\t\trecordId,\n\t\t\t\tedits: Object.entries( changes ).reduce(\n\t\t\t\t\t( acc, [ key, value ] ) => {\n\t\t\t\t\t\tacc[ key ] =\n\t\t\t\t\t\t\taction.type === 'UNDO' ? value.from : value.to;\n\t\t\t\t\t\treturn acc;\n\t\t\t\t\t},\n\t\t\t\t\t{}\n\t\t\t\t),\n\t\t\t} );\n\t\t} );\n\t\treturn newState;\n\t}\n\n\treturn reducer( state, action );\n};\n\n/**\n * Higher Order Reducer for a given entity config. It supports:\n *\n *  - Fetching\n *  - Editing\n *  - Saving\n *\n * @param {Object} entityConfig Entity config.\n *\n * @return {AnyFunction} Reducer.\n */\nfunction entity( entityConfig ) {\n\treturn compose( [\n\t\twithMultiEntityRecordEdits,\n\n\t\t// Limit to matching action type so we don't attempt to replace action on\n\t\t// an unhandled action.\n\t\tifMatchingAction(\n\t\t\t( action ) =>\n\t\t\t\taction.name &&\n\t\t\t\taction.kind &&\n\t\t\t\taction.name === entityConfig.name &&\n\t\t\t\taction.kind === entityConfig.kind\n\t\t),\n\n\t\t// Inject the entity config into the action.\n\t\treplaceAction( ( action ) => {\n\t\t\treturn {\n\t\t\t\tkey: entityConfig.key || DEFAULT_ENTITY_KEY,\n\t\t\t\t...action,\n\t\t\t};\n\t\t} ),\n\t] )(\n\t\tcombineReducers( {\n\t\t\tqueriedData: queriedDataReducer,\n\t\t\tedits: ( state = {}, action ) => {\n\t\t\t\tswitch ( action.type ) {\n\t\t\t\t\tcase 'RECEIVE_ITEMS':\n\t\t\t\t\t\tconst context = action?.query?.context ?? 'default';\n\t\t\t\t\t\tif ( context !== 'default' ) {\n\t\t\t\t\t\t\treturn state;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tconst nextState = { ...state };\n\n\t\t\t\t\t\tfor ( const record of action.items ) {\n\t\t\t\t\t\t\tconst recordId = record?.[ action.key ];\n\t\t\t\t\t\t\tconst edits = nextState[ recordId ];\n\t\t\t\t\t\t\tif ( ! edits ) {\n\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tconst nextEdits = Object.keys( edits ).reduce(\n\t\t\t\t\t\t\t\t( acc, key ) => {\n\t\t\t\t\t\t\t\t\t// If the edited value is still different to the persisted value,\n\t\t\t\t\t\t\t\t\t// keep the edited value in edits.\n\t\t\t\t\t\t\t\t\tif (\n\t\t\t\t\t\t\t\t\t\t// Edits are the \"raw\" attribute values, but records may have\n\t\t\t\t\t\t\t\t\t\t// objects with more properties, so we use `get` here for the\n\t\t\t\t\t\t\t\t\t\t// comparison.\n\t\t\t\t\t\t\t\t\t\t! fastDeepEqual(\n\t\t\t\t\t\t\t\t\t\t\tedits[ key ],\n\t\t\t\t\t\t\t\t\t\t\trecord[ key ]?.raw ?? record[ key ]\n\t\t\t\t\t\t\t\t\t\t) &&\n\t\t\t\t\t\t\t\t\t\t// Sometimes the server alters the sent value which means\n\t\t\t\t\t\t\t\t\t\t// we need to also remove the edits before the api request.\n\t\t\t\t\t\t\t\t\t\t( ! action.persistedEdits ||\n\t\t\t\t\t\t\t\t\t\t\t! fastDeepEqual(\n\t\t\t\t\t\t\t\t\t\t\t\tedits[ key ],\n\t\t\t\t\t\t\t\t\t\t\t\taction.persistedEdits[ key ]\n\t\t\t\t\t\t\t\t\t\t\t) )\n\t\t\t\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t\t\t\tacc[ key ] = edits[ key ];\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\treturn acc;\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t{}\n\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t\tif ( Object.keys( nextEdits ).length ) {\n\t\t\t\t\t\t\t\tnextState[ recordId ] = nextEdits;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tdelete nextState[ recordId ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\treturn nextState;\n\n\t\t\t\t\tcase 'EDIT_ENTITY_RECORD':\n\t\t\t\t\t\tconst nextEdits = {\n\t\t\t\t\t\t\t...state[ action.recordId ],\n\t\t\t\t\t\t\t...action.edits,\n\t\t\t\t\t\t};\n\t\t\t\t\t\tObject.keys( nextEdits ).forEach( ( key ) => {\n\t\t\t\t\t\t\t// Delete cleared edits so that the properties\n\t\t\t\t\t\t\t// are not considered dirty.\n\t\t\t\t\t\t\tif ( nextEdits[ key ] === undefined ) {\n\t\t\t\t\t\t\t\tdelete nextEdits[ key ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t...state,\n\t\t\t\t\t\t\t[ action.recordId ]: nextEdits,\n\t\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\treturn state;\n\t\t\t},\n\n\t\t\tsaving: ( state = {}, action ) => {\n\t\t\t\tswitch ( action.type ) {\n\t\t\t\t\tcase 'SAVE_ENTITY_RECORD_START':\n\t\t\t\t\tcase 'SAVE_ENTITY_RECORD_FINISH':\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t...state,\n\t\t\t\t\t\t\t[ action.recordId ]: {\n\t\t\t\t\t\t\t\tpending:\n\t\t\t\t\t\t\t\t\taction.type === 'SAVE_ENTITY_RECORD_START',\n\t\t\t\t\t\t\t\terror: action.error,\n\t\t\t\t\t\t\t\tisAutosave: action.isAutosave,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\treturn state;\n\t\t\t},\n\n\t\t\tdeleting: ( state = {}, action ) => {\n\t\t\t\tswitch ( action.type ) {\n\t\t\t\t\tcase 'DELETE_ENTITY_RECORD_START':\n\t\t\t\t\tcase 'DELETE_ENTITY_RECORD_FINISH':\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t...state,\n\t\t\t\t\t\t\t[ action.recordId ]: {\n\t\t\t\t\t\t\t\tpending:\n\t\t\t\t\t\t\t\t\taction.type ===\n\t\t\t\t\t\t\t\t\t'DELETE_ENTITY_RECORD_START',\n\t\t\t\t\t\t\t\terror: action.error,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\treturn state;\n\t\t\t},\n\n\t\t\trevisions: ( state = {}, action ) => {\n\t\t\t\t// Use the same queriedDataReducer shape for revisions.\n\t\t\t\tif ( action.type === 'RECEIVE_ITEM_REVISIONS' ) {\n\t\t\t\t\tconst recordKey = action.recordKey;\n\t\t\t\t\tdelete action.recordKey;\n\t\t\t\t\tconst newState = queriedDataReducer( state[ recordKey ], {\n\t\t\t\t\t\t...action,\n\t\t\t\t\t\ttype: 'RECEIVE_ITEMS',\n\t\t\t\t\t} );\n\t\t\t\t\treturn {\n\t\t\t\t\t\t...state,\n\t\t\t\t\t\t[ recordKey ]: newState,\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\tif ( action.type === 'REMOVE_ITEMS' ) {\n\t\t\t\t\treturn Object.fromEntries(\n\t\t\t\t\t\tObject.entries( state ).filter(\n\t\t\t\t\t\t\t( [ id ] ) =>\n\t\t\t\t\t\t\t\t! action.itemIds.some( ( itemId ) => {\n\t\t\t\t\t\t\t\t\tif ( Number.isInteger( itemId ) ) {\n\t\t\t\t\t\t\t\t\t\treturn itemId === +id;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\treturn itemId === id;\n\t\t\t\t\t\t\t\t} )\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\treturn state;\n\t\t\t},\n\t\t} )\n\t);\n}\n\n/**\n * Reducer keeping track of the registered entities.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function entitiesConfig( state = rootEntitiesConfig, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'ADD_ENTITIES':\n\t\t\treturn [ ...state, ...action.entities ];\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer keeping track of the registered entities config and data.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport const entities = ( state = {}, action ) => {\n\tconst newConfig = entitiesConfig( state.config, action );\n\n\t// Generates a dynamic reducer for the entities.\n\tlet entitiesDataReducer = state.reducer;\n\tif ( ! entitiesDataReducer || newConfig !== state.config ) {\n\t\tconst entitiesByKind = newConfig.reduce( ( acc, record ) => {\n\t\t\tconst { kind } = record;\n\t\t\tif ( ! acc[ kind ] ) {\n\t\t\t\tacc[ kind ] = [];\n\t\t\t}\n\t\t\tacc[ kind ].push( record );\n\t\t\treturn acc;\n\t\t}, {} );\n\n\t\tentitiesDataReducer = combineReducers(\n\t\t\tObject.entries( entitiesByKind ).reduce(\n\t\t\t\t( memo, [ kind, subEntities ] ) => {\n\t\t\t\t\tconst kindReducer = combineReducers(\n\t\t\t\t\t\tsubEntities.reduce(\n\t\t\t\t\t\t\t( kindMemo, entityConfig ) => ( {\n\t\t\t\t\t\t\t\t...kindMemo,\n\t\t\t\t\t\t\t\t[ entityConfig.name ]: entity( entityConfig ),\n\t\t\t\t\t\t\t} ),\n\t\t\t\t\t\t\t{}\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\n\t\t\t\t\tmemo[ kind ] = kindReducer;\n\t\t\t\t\treturn memo;\n\t\t\t\t},\n\t\t\t\t{}\n\t\t\t)\n\t\t);\n\t}\n\n\tconst newData = entitiesDataReducer( state.records, action );\n\n\tif (\n\t\tnewData === state.records &&\n\t\tnewConfig === state.config &&\n\t\tentitiesDataReducer === state.reducer\n\t) {\n\t\treturn state;\n\t}\n\n\treturn {\n\t\treducer: entitiesDataReducer,\n\t\trecords: newData,\n\t\tconfig: newConfig,\n\t};\n};\n\n/**\n * @type {UndoManager}\n */\nexport function undoManager( state = createUndoManager() ) {\n\treturn state;\n}\n\nexport function editsReference( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'EDIT_ENTITY_RECORD':\n\t\tcase 'UNDO':\n\t\tcase 'REDO':\n\t\t\treturn {};\n\t}\n\treturn state;\n}\n\n/**\n * Reducer managing embed preview data.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function embedPreviews( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_EMBED_PREVIEW':\n\t\t\tconst { url, preview } = action;\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ url ]: preview,\n\t\t\t};\n\t}\n\treturn state;\n}\n\n/**\n * State which tracks whether the user can perform an action on a REST\n * resource.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function userPermissions( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_USER_PERMISSION':\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ action.key ]: action.isAllowed,\n\t\t\t};\n\t\tcase 'RECEIVE_USER_PERMISSIONS':\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t...action.permissions,\n\t\t\t};\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer returning autosaves keyed by their parent's post id.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function autosaves( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_AUTOSAVES':\n\t\t\tconst { postId, autosaves: autosavesData } = action;\n\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ postId ]: autosavesData,\n\t\t\t};\n\t}\n\n\treturn state;\n}\n\nexport function blockPatterns( state = [], action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_BLOCK_PATTERNS':\n\t\t\treturn action.patterns;\n\t}\n\n\treturn state;\n}\n\nexport function blockPatternCategories( state = [], action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_BLOCK_PATTERN_CATEGORIES':\n\t\t\treturn action.categories;\n\t}\n\n\treturn state;\n}\n\nexport function userPatternCategories( state = [], action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_USER_PATTERN_CATEGORIES':\n\t\t\treturn action.patternCategories;\n\t}\n\treturn state;\n}\n\nexport function navigationFallbackId( state = null, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_NAVIGATION_FALLBACK_ID':\n\t\t\treturn action.fallbackId;\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer managing the theme global styles revisions.\n *\n * @param {Record<string, object>} state  Current state.\n * @param {Object}                 action Dispatched action.\n *\n * @return {Record<string, object>} Updated state.\n */\nexport function themeGlobalStyleRevisions( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_THEME_GLOBAL_STYLE_REVISIONS':\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ action.currentId ]: action.revisions,\n\t\t\t};\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer managing the template lookup per query.\n *\n * @param {Record<string, string>} state  Current state.\n * @param {Object}                 action Dispatched action.\n *\n * @return {Record<string, string>} Updated state.\n */\nexport function defaultTemplates( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_DEFAULT_TEMPLATE':\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ JSON.stringify( action.query ) ]: action.templateId,\n\t\t\t};\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer returning an object of registered post meta.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function registeredPostMeta( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_REGISTERED_POST_META':\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ action.postType ]: action.registeredPostMeta,\n\t\t\t};\n\t}\n\treturn state;\n}\n\nexport default combineReducers( {\n\tterms,\n\tusers,\n\tcurrentTheme,\n\tcurrentGlobalStylesId,\n\tcurrentUser,\n\tthemeGlobalStyleVariations,\n\tthemeBaseGlobalStyles,\n\tthemeGlobalStyleRevisions,\n\ttaxonomies,\n\tentities,\n\teditsReference,\n\tundoManager,\n\tembedPreviews,\n\tuserPermissions,\n\tautosaves,\n\tblockPatterns,\n\tblockPatternCategories,\n\tuserPatternCategories,\n\tnavigationFallbackId,\n\tdefaultTemplates,\n\tregisteredPostMeta,\n} );\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"deprecated\"];","/**\n * The reducer key used by core data in store registration.\n * This is defined in a separate file to avoid cycle-dependency\n *\n * @type {string}\n */\nexport const STORE_NAME = 'core';\n","/**\n * Sets the value at path of object.\n * If a portion of path doesn’t exist, it’s created.\n * Arrays are created for missing index properties while objects are created\n * for all other missing properties.\n *\n * Path is specified as either:\n * - a string of properties, separated by dots, for example: \"x.y\".\n * - an array of properties, for example `[ 'x', 'y' ]`.\n *\n * This function intentionally mutates the input object.\n *\n * Inspired by _.set().\n *\n * @see https://lodash.com/docs/4.17.15#set\n *\n * @todo Needs to be deduplicated with its copy in `@wordpress/edit-site`.\n *\n * @param {Object}       object Object to modify\n * @param {Array|string} path   Path of the property to set.\n * @param {*}            value  Value to set.\n */\nexport default function setNestedValue( object, path, value ) {\n\tif ( ! object || typeof object !== 'object' ) {\n\t\treturn object;\n\t}\n\n\tconst normalizedPath = Array.isArray( path ) ? path : path.split( '.' );\n\n\tnormalizedPath.reduce( ( acc, key, idx ) => {\n\t\tif ( acc[ key ] === undefined ) {\n\t\t\tif ( Number.isInteger( normalizedPath[ idx + 1 ] ) ) {\n\t\t\t\tacc[ key ] = [];\n\t\t\t} else {\n\t\t\t\tacc[ key ] = {};\n\t\t\t}\n\t\t}\n\t\tif ( idx === normalizedPath.length - 1 ) {\n\t\t\tacc[ key ] = value;\n\t\t}\n\t\treturn acc[ key ];\n\t}, object );\n\n\treturn object;\n}\n","/**\n * External dependencies\n */\nimport EquivalentKeyMap from 'equivalent-key-map';\n\n/**\n * WordPress dependencies\n */\nimport { createSelector } from '@wordpress/data';\n\n/**\n * Internal dependencies\n */\nimport getQueryParts from './get-query-parts';\nimport { setNestedValue } from '../utils';\n\n/**\n * Cache of state keys to EquivalentKeyMap where the inner map tracks queries\n * to their resulting items set. WeakMap allows garbage collection on expired\n * state references.\n *\n * @type {WeakMap<Object,EquivalentKeyMap>}\n */\nconst queriedItemsCacheByState = new WeakMap();\n\n/**\n * Returns items for a given query, or null if the items are not known.\n *\n * @param {Object}  state State object.\n * @param {?Object} query Optional query.\n *\n * @return {?Array} Query items.\n */\nfunction getQueriedItemsUncached( state, query ) {\n\tconst { stableKey, page, perPage, include, fields, context } =\n\t\tgetQueryParts( query );\n\tlet itemIds;\n\n\tif ( state.queries?.[ context ]?.[ stableKey ] ) {\n\t\titemIds = state.queries[ context ][ stableKey ].itemIds;\n\t}\n\n\tif ( ! itemIds ) {\n\t\treturn null;\n\t}\n\n\tconst startOffset = perPage === -1 ? 0 : ( page - 1 ) * perPage;\n\tconst endOffset =\n\t\tperPage === -1\n\t\t\t? itemIds.length\n\t\t\t: Math.min( startOffset + perPage, itemIds.length );\n\n\tconst items = [];\n\tfor ( let i = startOffset; i < endOffset; i++ ) {\n\t\tconst itemId = itemIds[ i ];\n\t\tif ( Array.isArray( include ) && ! include.includes( itemId ) ) {\n\t\t\tcontinue;\n\t\t}\n\t\tif ( itemId === undefined ) {\n\t\t\tcontinue;\n\t\t}\n\t\t// Having a target item ID doesn't guarantee that this object has been queried.\n\t\tif ( ! state.items[ context ]?.hasOwnProperty( itemId ) ) {\n\t\t\treturn null;\n\t\t}\n\n\t\tconst item = state.items[ context ][ itemId ];\n\n\t\tlet filteredItem;\n\t\tif ( Array.isArray( fields ) ) {\n\t\t\tfilteredItem = {};\n\n\t\t\tfor ( let f = 0; f < fields.length; f++ ) {\n\t\t\t\tconst field = fields[ f ].split( '.' );\n\t\t\t\tlet value = item;\n\t\t\t\tfield.forEach( ( fieldName ) => {\n\t\t\t\t\tvalue = value?.[ fieldName ];\n\t\t\t\t} );\n\n\t\t\t\tsetNestedValue( filteredItem, field, value );\n\t\t\t}\n\t\t} else {\n\t\t\t// If expecting a complete item, validate that completeness, or\n\t\t\t// otherwise abort.\n\t\t\tif ( ! state.itemIsComplete[ context ]?.[ itemId ] ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tfilteredItem = item;\n\t\t}\n\n\t\titems.push( filteredItem );\n\t}\n\n\treturn items;\n}\n\n/**\n * Returns items for a given query, or null if the items are not known. Caches\n * result both per state (by reference) and per query (by deep equality).\n * The caching approach is intended to be durable to query objects which are\n * deeply but not referentially equal, since otherwise:\n *\n * `getQueriedItems( state, {} ) !== getQueriedItems( state, {} )`\n *\n * @param {Object}  state State object.\n * @param {?Object} query Optional query.\n *\n * @return {?Array} Query items.\n */\nexport const getQueriedItems = createSelector( ( state, query = {} ) => {\n\tlet queriedItemsCache = queriedItemsCacheByState.get( state );\n\tif ( queriedItemsCache ) {\n\t\tconst queriedItems = queriedItemsCache.get( query );\n\t\tif ( queriedItems !== undefined ) {\n\t\t\treturn queriedItems;\n\t\t}\n\t} else {\n\t\tqueriedItemsCache = new EquivalentKeyMap();\n\t\tqueriedItemsCacheByState.set( state, queriedItemsCache );\n\t}\n\n\tconst items = getQueriedItemsUncached( state, query );\n\tqueriedItemsCache.set( query, items );\n\treturn items;\n} );\n\nexport function getQueriedTotalItems( state, query = {} ) {\n\tconst { stableKey, context } = getQueryParts( query );\n\n\treturn state.queries?.[ context ]?.[ stableKey ]?.meta?.totalItems ?? null;\n}\n\nexport function getQueriedTotalPages( state, query = {} ) {\n\tconst { stableKey, context } = getQueryParts( query );\n\n\treturn state.queries?.[ context ]?.[ stableKey ]?.meta?.totalPages ?? null;\n}\n","export const ALLOWED_RESOURCE_ACTIONS = [\n\t'create',\n\t'read',\n\t'update',\n\t'delete',\n];\n\nexport function getUserPermissionsFromAllowHeader( allowedMethods ) {\n\tconst permissions = {};\n\tif ( ! allowedMethods ) {\n\t\treturn permissions;\n\t}\n\n\tconst methods = {\n\t\tcreate: 'POST',\n\t\tread: 'GET',\n\t\tupdate: 'PUT',\n\t\tdelete: 'DELETE',\n\t};\n\tfor ( const [ actionName, methodName ] of Object.entries( methods ) ) {\n\t\tpermissions[ actionName ] = allowedMethods.includes( methodName );\n\t}\n\n\treturn permissions;\n}\n\nexport function getUserPermissionCacheKey( action, resource, id ) {\n\tconst key = (\n\t\ttypeof resource === 'object'\n\t\t\t? [ action, resource.kind, resource.name, resource.id ]\n\t\t\t: [ action, resource, id ]\n\t)\n\t\t.filter( Boolean )\n\t\t.join( '/' );\n\n\treturn key;\n}\n","/**\n * WordPress dependencies\n */\nimport { createSelector, createRegistrySelector } from '@wordpress/data';\nimport { addQueryArgs } from '@wordpress/url';\nimport deprecated from '@wordpress/deprecated';\n\n/**\n * Internal dependencies\n */\nimport { STORE_NAME } from './name';\nimport {\n\tgetQueriedItems,\n\tgetQueriedTotalItems,\n\tgetQueriedTotalPages,\n} from './queried-data';\nimport { DEFAULT_ENTITY_KEY } from './entities';\nimport {\n\tgetNormalizedCommaSeparable,\n\tisRawAttribute,\n\tsetNestedValue,\n\tisNumericID,\n\tgetUserPermissionCacheKey,\n} from './utils';\nimport type * as ET from './entity-types';\nimport type { UndoManager } from '@wordpress/undo-manager';\n\n// This is an incomplete, high-level approximation of the State type.\n// It makes the selectors slightly more safe, but is intended to evolve\n// into a more detailed representation over time.\n// See https://github.com/WordPress/gutenberg/pull/40025#discussion_r865410589 for more context.\nexport interface State {\n\tautosaves: Record< string | number, Array< unknown > >;\n\tblockPatterns: Array< unknown >;\n\tblockPatternCategories: Array< unknown >;\n\tcurrentGlobalStylesId: string;\n\tcurrentTheme: string;\n\tcurrentUser: ET.User< 'edit' >;\n\tembedPreviews: Record< string, { html: string } >;\n\tentities: EntitiesState;\n\tthemeBaseGlobalStyles: Record< string, Object >;\n\tthemeGlobalStyleVariations: Record< string, string >;\n\tthemeGlobalStyleRevisions: Record< number, Object >;\n\tundoManager: UndoManager;\n\tuserPermissions: Record< string, boolean >;\n\tusers: UserState;\n\tnavigationFallbackId: EntityRecordKey;\n\tuserPatternCategories: Array< UserPatternCategory >;\n\tdefaultTemplates: Record< string, string >;\n\tregisteredPostMeta: Record< string, Object >;\n}\n\ntype EntityRecordKey = string | number;\n\ninterface EntitiesState {\n\tconfig: EntityConfig[];\n\trecords: Record< string, Record< string, EntityState< ET.EntityRecord > > >;\n}\n\ninterface QueriedData {\n\titems: Record< ET.Context, Record< number, ET.EntityRecord > >;\n\titemIsComplete: Record< ET.Context, Record< number, boolean > >;\n\tqueries: Record< ET.Context, Record< string, Array< number > > >;\n}\n\ntype RevisionRecord =\n\t| Record< ET.Context, Record< number, ET.PostRevision > >\n\t| Record< ET.Context, Record< number, ET.GlobalStylesRevision > >;\n\ninterface RevisionsQueriedData {\n\titems: RevisionRecord;\n\titemIsComplete: Record< ET.Context, Record< number, boolean > >;\n\tqueries: Record< ET.Context, Record< string, Array< number > > >;\n}\n\ninterface EntityState< EntityRecord extends ET.EntityRecord > {\n\tedits: Record< string, Partial< EntityRecord > >;\n\tsaving: Record<\n\t\tstring,\n\t\tPartial< { pending: boolean; isAutosave: boolean; error: Error } >\n\t>;\n\tdeleting: Record< string, Partial< { pending: boolean; error: Error } > >;\n\tqueriedData: QueriedData;\n\trevisions?: RevisionsQueriedData;\n}\n\ninterface EntityConfig {\n\tname: string;\n\tkind: string;\n}\n\ninterface UserState {\n\tqueries: Record< string, EntityRecordKey[] >;\n\tbyId: Record< EntityRecordKey, ET.User< 'edit' > >;\n}\n\ntype TemplateQuery = {\n\tslug?: string;\n\tis_custom?: boolean;\n\tignore_empty?: boolean;\n};\n\nexport interface UserPatternCategory {\n\tid: number;\n\tname: string;\n\tlabel: string;\n\tslug: string;\n\tdescription: string;\n}\n\ntype Optional< T > = T | undefined;\n\n/**\n * HTTP Query parameters sent with the API request to fetch the entity records.\n */\nexport type GetRecordsHttpQuery = Record< string, any >;\n\n/**\n * Arguments for EntityRecord selectors.\n */\ntype EntityRecordArgs =\n\t| [ string, string, EntityRecordKey ]\n\t| [ string, string, EntityRecordKey, GetRecordsHttpQuery ];\n\ntype EntityResource = { kind: string; name: string; id?: EntityRecordKey };\n\n/**\n * Shared reference to an empty object for cases where it is important to avoid\n * returning a new object reference on every invocation, as in a connected or\n * other pure component which performs `shouldComponentUpdate` check on props.\n * This should be used as a last resort, since the normalized data should be\n * maintained by the reducer result in state.\n */\nconst EMPTY_OBJECT = {};\n\n/**\n * Returns true if a request is in progress for embed preview data, or false\n * otherwise.\n *\n * @param state Data state.\n * @param url   URL the preview would be for.\n *\n * @return Whether a request is in progress for an embed preview.\n */\nexport const isRequestingEmbedPreview = createRegistrySelector(\n\t( select: any ) =>\n\t\t( state: State, url: string ): boolean => {\n\t\t\treturn select( STORE_NAME ).isResolving( 'getEmbedPreview', [\n\t\t\t\turl,\n\t\t\t] );\n\t\t}\n);\n\n/**\n * Returns all available authors.\n *\n * @deprecated since 11.3. Callers should use `select( 'core' ).getUsers({ who: 'authors' })` instead.\n *\n * @param      state Data state.\n * @param      query Optional object of query parameters to\n *                   include with request. For valid query parameters see the [Users page](https://developer.wordpress.org/rest-api/reference/users/) in the REST API Handbook and see the arguments for [List Users](https://developer.wordpress.org/rest-api/reference/users/#list-users) and [Retrieve a User](https://developer.wordpress.org/rest-api/reference/users/#retrieve-a-user).\n * @return Authors list.\n */\nexport function getAuthors(\n\tstate: State,\n\tquery?: GetRecordsHttpQuery\n): ET.User[] {\n\tdeprecated( \"select( 'core' ).getAuthors()\", {\n\t\tsince: '5.9',\n\t\talternative: \"select( 'core' ).getUsers({ who: 'authors' })\",\n\t} );\n\n\tconst path = addQueryArgs(\n\t\t'/wp/v2/users/?who=authors&per_page=100',\n\t\tquery\n\t);\n\treturn getUserQueryResults( state, path );\n}\n\n/**\n * Returns the current user.\n *\n * @param state Data state.\n *\n * @return Current user object.\n */\nexport function getCurrentUser( state: State ): ET.User< 'edit' > {\n\treturn state.currentUser;\n}\n\n/**\n * Returns all the users returned by a query ID.\n *\n * @param state   Data state.\n * @param queryID Query ID.\n *\n * @return Users list.\n */\nexport const getUserQueryResults = createSelector(\n\t( state: State, queryID: string ): ET.User< 'edit' >[] => {\n\t\tconst queryResults = state.users.queries[ queryID ] ?? [];\n\n\t\treturn queryResults.map( ( id ) => state.users.byId[ id ] );\n\t},\n\t( state: State, queryID: string ) => [\n\t\tstate.users.queries[ queryID ],\n\t\tstate.users.byId,\n\t]\n);\n\n/**\n * Returns the loaded entities for the given kind.\n *\n * @deprecated since WordPress 6.0. Use getEntitiesConfig instead\n * @param      state Data state.\n * @param      kind  Entity kind.\n *\n * @return Array of entities with config matching kind.\n */\nexport function getEntitiesByKind( state: State, kind: string ): Array< any > {\n\tdeprecated( \"wp.data.select( 'core' ).getEntitiesByKind()\", {\n\t\tsince: '6.0',\n\t\talternative: \"wp.data.select( 'core' ).getEntitiesConfig()\",\n\t} );\n\treturn getEntitiesConfig( state, kind );\n}\n\n/**\n * Returns the loaded entities for the given kind.\n *\n * @param state Data state.\n * @param kind  Entity kind.\n *\n * @return Array of entities with config matching kind.\n */\nexport const getEntitiesConfig = createSelector(\n\t( state: State, kind: string ): Array< any > =>\n\t\tstate.entities.config.filter( ( entity ) => entity.kind === kind ),\n\t/* eslint-disable @typescript-eslint/no-unused-vars */\n\t( state: State, kind: string ) => state.entities.config\n\t/* eslint-enable @typescript-eslint/no-unused-vars */\n);\n/**\n * Returns the entity config given its kind and name.\n *\n * @deprecated since WordPress 6.0. Use getEntityConfig instead\n * @param      state Data state.\n * @param      kind  Entity kind.\n * @param      name  Entity name.\n *\n * @return Entity config\n */\nexport function getEntity( state: State, kind: string, name: string ): any {\n\tdeprecated( \"wp.data.select( 'core' ).getEntity()\", {\n\t\tsince: '6.0',\n\t\talternative: \"wp.data.select( 'core' ).getEntityConfig()\",\n\t} );\n\treturn getEntityConfig( state, kind, name );\n}\n\n/**\n * Returns the entity config given its kind and name.\n *\n * @param state Data state.\n * @param kind  Entity kind.\n * @param name  Entity name.\n *\n * @return Entity config\n */\nexport function getEntityConfig(\n\tstate: State,\n\tkind: string,\n\tname: string\n): any {\n\treturn state.entities.config?.find(\n\t\t( config ) => config.kind === kind && config.name === name\n\t);\n}\n\n/**\n * GetEntityRecord is declared as a *callable interface* with\n * two signatures to work around the fact that TypeScript doesn't\n * allow currying generic functions:\n *\n * ```ts\n * \t\ttype CurriedState = F extends ( state: any, ...args: infer P ) => infer R\n * \t\t\t? ( ...args: P ) => R\n * \t\t\t: F;\n * \t\ttype Selector = <K extends string | number>(\n *         state: any,\n *         kind: K,\n *         key: K extends string ? 'string value' : false\n *    ) => K;\n * \t\ttype BadlyInferredSignature = CurriedState< Selector >\n *    // BadlyInferredSignature evaluates to:\n *    // (kind: string number, key: false | \"string value\") => string number\n * ```\n *\n * The signature without the state parameter shipped as CurriedSignature\n * is used in the return value of `select( coreStore )`.\n *\n * See https://github.com/WordPress/gutenberg/pull/41578 for more details.\n */\nexport interface GetEntityRecord {\n\t<\n\t\tEntityRecord extends\n\t\t\t| ET.EntityRecord< any >\n\t\t\t| Partial< ET.EntityRecord< any > >,\n\t>(\n\t\tstate: State,\n\t\tkind: string,\n\t\tname: string,\n\t\tkey?: EntityRecordKey,\n\t\tquery?: GetRecordsHttpQuery\n\t): EntityRecord | undefined;\n\n\tCurriedSignature: <\n\t\tEntityRecord extends\n\t\t\t| ET.EntityRecord< any >\n\t\t\t| Partial< ET.EntityRecord< any > >,\n\t>(\n\t\tkind: string,\n\t\tname: string,\n\t\tkey?: EntityRecordKey,\n\t\tquery?: GetRecordsHttpQuery\n\t) => EntityRecord | undefined;\n\t__unstableNormalizeArgs?: ( args: EntityRecordArgs ) => EntityRecordArgs;\n}\n\n/**\n * Returns the Entity's record object by key. Returns `null` if the value is not\n * yet received, undefined if the value entity is known to not exist, or the\n * entity object if it exists and is received.\n *\n * @param state State tree\n * @param kind  Entity kind.\n * @param name  Entity name.\n * @param key   Optional record's key. If requesting a global record (e.g. site settings), the key can be omitted. If requesting a specific item, the key must always be included.\n * @param query Optional query. If requesting specific\n *              fields, fields must always include the ID. For valid query parameters see the [Reference](https://developer.wordpress.org/rest-api/reference/) in the REST API Handbook and select the entity kind. Then see the arguments available \"Retrieve a [Entity kind]\".\n *\n * @return Record.\n */\nexport const getEntityRecord = createSelector(\n\t( <\n\t\tEntityRecord extends\n\t\t\t| ET.EntityRecord< any >\n\t\t\t| Partial< ET.EntityRecord< any > >,\n\t>(\n\t\tstate: State,\n\t\tkind: string,\n\t\tname: string,\n\t\tkey?: EntityRecordKey,\n\t\tquery?: GetRecordsHttpQuery\n\t): EntityRecord | undefined => {\n\t\tconst queriedState =\n\t\t\tstate.entities.records?.[ kind ]?.[ name ]?.queriedData;\n\t\tif ( ! queriedState ) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst context = query?.context ?? 'default';\n\n\t\tif ( query === undefined ) {\n\t\t\t// If expecting a complete item, validate that completeness.\n\t\t\tif ( ! queriedState.itemIsComplete[ context ]?.[ key ] ) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\n\t\t\treturn queriedState.items[ context ][ key ];\n\t\t}\n\n\t\tconst item = queriedState.items[ context ]?.[ key ];\n\t\tif ( item && query._fields ) {\n\t\t\tconst filteredItem = {};\n\t\t\tconst fields = getNormalizedCommaSeparable( query._fields ) ?? [];\n\t\t\tfor ( let f = 0; f < fields.length; f++ ) {\n\t\t\t\tconst field = fields[ f ].split( '.' );\n\t\t\t\tlet value = item;\n\t\t\t\tfield.forEach( ( fieldName ) => {\n\t\t\t\t\tvalue = value?.[ fieldName ];\n\t\t\t\t} );\n\t\t\t\tsetNestedValue( filteredItem, field, value );\n\t\t\t}\n\t\t\treturn filteredItem as EntityRecord;\n\t\t}\n\n\t\treturn item;\n\t} ) as GetEntityRecord,\n\t( state: State, kind, name, recordId, query ) => {\n\t\tconst context = query?.context ?? 'default';\n\t\treturn [\n\t\t\tstate.entities.records?.[ kind ]?.[ name ]?.queriedData?.items[\n\t\t\t\tcontext\n\t\t\t]?.[ recordId ],\n\t\t\tstate.entities.records?.[ kind ]?.[ name ]?.queriedData\n\t\t\t\t?.itemIsComplete[ context ]?.[ recordId ],\n\t\t];\n\t}\n) as GetEntityRecord;\n\n/**\n * Normalizes `recordKey`s that look like numeric IDs to numbers.\n *\n * @param args EntityRecordArgs the selector arguments.\n * @return EntityRecordArgs the normalized arguments.\n */\ngetEntityRecord.__unstableNormalizeArgs = (\n\targs: EntityRecordArgs\n): EntityRecordArgs => {\n\tconst newArgs = [ ...args ] as EntityRecordArgs;\n\tconst recordKey = newArgs?.[ 2 ];\n\n\t// If recordKey looks to be a numeric ID then coerce to number.\n\tnewArgs[ 2 ] = isNumericID( recordKey ) ? Number( recordKey ) : recordKey;\n\n\treturn newArgs;\n};\n\n/**\n * Returns the Entity's record object by key. Doesn't trigger a resolver nor requests the entity records from the API if the entity record isn't available in the local state.\n *\n * @param state State tree\n * @param kind  Entity kind.\n * @param name  Entity name.\n * @param key   Record's key\n *\n * @return Record.\n */\nexport function __experimentalGetEntityRecordNoResolver<\n\tEntityRecord extends ET.EntityRecord< any >,\n>( state: State, kind: string, name: string, key: EntityRecordKey ) {\n\treturn getEntityRecord< EntityRecord >( state, kind, name, key );\n}\n\n/**\n * Returns the entity's record object by key,\n * with its attributes mapped to their raw values.\n *\n * @param state State tree.\n * @param kind  Entity kind.\n * @param name  Entity name.\n * @param key   Record's key.\n *\n * @return Object with the entity's raw attributes.\n */\nexport const getRawEntityRecord = createSelector(\n\t< EntityRecord extends ET.EntityRecord< any > >(\n\t\tstate: State,\n\t\tkind: string,\n\t\tname: string,\n\t\tkey: EntityRecordKey\n\t): EntityRecord | undefined => {\n\t\tconst record = getEntityRecord< EntityRecord >(\n\t\t\tstate,\n\t\t\tkind,\n\t\t\tname,\n\t\t\tkey\n\t\t);\n\t\treturn (\n\t\t\trecord &&\n\t\t\tObject.keys( record ).reduce( ( accumulator, _key ) => {\n\t\t\t\tif (\n\t\t\t\t\tisRawAttribute( getEntityConfig( state, kind, name ), _key )\n\t\t\t\t) {\n\t\t\t\t\t// Because edits are the \"raw\" attribute values,\n\t\t\t\t\t// we return those from record selectors to make rendering,\n\t\t\t\t\t// comparisons, and joins with edits easier.\n\t\t\t\t\taccumulator[ _key ] =\n\t\t\t\t\t\trecord[ _key ]?.raw !== undefined\n\t\t\t\t\t\t\t? record[ _key ]?.raw\n\t\t\t\t\t\t\t: record[ _key ];\n\t\t\t\t} else {\n\t\t\t\t\taccumulator[ _key ] = record[ _key ];\n\t\t\t\t}\n\t\t\t\treturn accumulator;\n\t\t\t}, {} as any )\n\t\t);\n\t},\n\t(\n\t\tstate: State,\n\t\tkind: string,\n\t\tname: string,\n\t\trecordId: EntityRecordKey,\n\t\tquery?: GetRecordsHttpQuery\n\t) => {\n\t\tconst context = query?.context ?? 'default';\n\t\treturn [\n\t\t\tstate.entities.config,\n\t\t\tstate.entities.records?.[ kind ]?.[ name ]?.queriedData?.items[\n\t\t\t\tcontext\n\t\t\t]?.[ recordId ],\n\t\t\tstate.entities.records?.[ kind ]?.[ name ]?.queriedData\n\t\t\t\t?.itemIsComplete[ context ]?.[ recordId ],\n\t\t];\n\t}\n);\n\n/**\n * Returns true if records have been received for the given set of parameters,\n * or false otherwise.\n *\n * @param state State tree\n * @param kind  Entity kind.\n * @param name  Entity name.\n * @param query Optional terms query. For valid query parameters see the [Reference](https://developer.wordpress.org/rest-api/reference/) in the REST API Handbook and select the entity kind. Then see the arguments available for \"List [Entity kind]s\".\n *\n * @return  Whether entity records have been received.\n */\nexport function hasEntityRecords(\n\tstate: State,\n\tkind: string,\n\tname: string,\n\tquery?: GetRecordsHttpQuery\n): boolean {\n\treturn Array.isArray( getEntityRecords( state, kind, name, query ) );\n}\n\n/**\n * GetEntityRecord is declared as a *callable interface* with\n * two signatures to work around the fact that TypeScript doesn't\n * allow currying generic functions.\n *\n * @see GetEntityRecord\n * @see https://github.com/WordPress/gutenberg/pull/41578\n */\nexport interface GetEntityRecords {\n\t<\n\t\tEntityRecord extends\n\t\t\t| ET.EntityRecord< any >\n\t\t\t| Partial< ET.EntityRecord< any > >,\n\t>(\n\t\tstate: State,\n\t\tkind: string,\n\t\tname: string,\n\t\tquery?: GetRecordsHttpQuery\n\t): EntityRecord[] | null;\n\n\tCurriedSignature: <\n\t\tEntityRecord extends\n\t\t\t| ET.EntityRecord< any >\n\t\t\t| Partial< ET.EntityRecord< any > >,\n\t>(\n\t\tkind: string,\n\t\tname: string,\n\t\tquery?: GetRecordsHttpQuery\n\t) => EntityRecord[] | null;\n}\n\n/**\n * Returns the Entity's records.\n *\n * @param state State tree\n * @param kind  Entity kind.\n * @param name  Entity name.\n * @param query Optional terms query. If requesting specific\n *              fields, fields must always include the ID. For valid query parameters see the [Reference](https://developer.wordpress.org/rest-api/reference/) in the REST API Handbook and select the entity kind. Then see the arguments available for \"List [Entity kind]s\".\n *\n * @return Records.\n */\nexport const getEntityRecords = ( <\n\tEntityRecord extends\n\t\t| ET.EntityRecord< any >\n\t\t| Partial< ET.EntityRecord< any > >,\n>(\n\tstate: State,\n\tkind: string,\n\tname: string,\n\tquery: GetRecordsHttpQuery\n): EntityRecord[] | null => {\n\t// Queried data state is prepopulated for all known entities. If this is not\n\t// assigned for the given parameters, then it is known to not exist.\n\tconst queriedState =\n\t\tstate.entities.records?.[ kind ]?.[ name ]?.queriedData;\n\tif ( ! queriedState ) {\n\t\treturn null;\n\t}\n\treturn getQueriedItems( queriedState, query );\n} ) as GetEntityRecords;\n\n/**\n * Returns the Entity's total available records for a given query (ignoring pagination).\n *\n * @param state State tree\n * @param kind  Entity kind.\n * @param name  Entity name.\n * @param query Optional terms query. If requesting specific\n *              fields, fields must always include the ID. For valid query parameters see the [Reference](https://developer.wordpress.org/rest-api/reference/) in the REST API Handbook and select the entity kind. Then see the arguments available for \"List [Entity kind]s\".\n *\n * @return number | null.\n */\nexport const getEntityRecordsTotalItems = (\n\tstate: State,\n\tkind: string,\n\tname: string,\n\tquery: GetRecordsHttpQuery\n): number | null => {\n\t// Queried data state is prepopulated for all known entities. If this is not\n\t// assigned for the given parameters, then it is known to not exist.\n\tconst queriedState =\n\t\tstate.entities.records?.[ kind ]?.[ name ]?.queriedData;\n\tif ( ! queriedState ) {\n\t\treturn null;\n\t}\n\treturn getQueriedTotalItems( queriedState, query );\n};\n\n/**\n * Returns the number of available pages for the given query.\n *\n * @param state State tree\n * @param kind  Entity kind.\n * @param name  Entity name.\n * @param query Optional terms query. If requesting specific\n *              fields, fields must always include the ID. For valid query parameters see the [Reference](https://developer.wordpress.org/rest-api/reference/) in the REST API Handbook and select the entity kind. Then see the arguments available for \"List [Entity kind]s\".\n *\n * @return number | null.\n */\nexport const getEntityRecordsTotalPages = (\n\tstate: State,\n\tkind: string,\n\tname: string,\n\tquery: GetRecordsHttpQuery\n): number | null => {\n\t// Queried data state is prepopulated for all known entities. If this is not\n\t// assigned for the given parameters, then it is known to not exist.\n\tconst queriedState =\n\t\tstate.entities.records?.[ kind ]?.[ name ]?.queriedData;\n\tif ( ! queriedState ) {\n\t\treturn null;\n\t}\n\tif ( query.per_page === -1 ) {\n\t\treturn 1;\n\t}\n\tconst totalItems = getQueriedTotalItems( queriedState, query );\n\tif ( ! totalItems ) {\n\t\treturn totalItems;\n\t}\n\t// If `per_page` is not set and the query relies on the defaults of the\n\t// REST endpoint, get the info from query's meta.\n\tif ( ! query.per_page ) {\n\t\treturn getQueriedTotalPages( queriedState, query );\n\t}\n\treturn Math.ceil( totalItems / query.per_page );\n};\n\ntype DirtyEntityRecord = {\n\ttitle: string;\n\tkey: EntityRecordKey;\n\tname: string;\n\tkind: string;\n};\n/**\n * Returns the list of dirty entity records.\n *\n * @param state State tree.\n *\n * @return The list of updated records\n */\nexport const __experimentalGetDirtyEntityRecords = createSelector(\n\t( state: State ): Array< DirtyEntityRecord > => {\n\t\tconst {\n\t\t\tentities: { records },\n\t\t} = state;\n\t\tconst dirtyRecords: DirtyEntityRecord[] = [];\n\t\tObject.keys( records ).forEach( ( kind ) => {\n\t\t\tObject.keys( records[ kind ] ).forEach( ( name ) => {\n\t\t\t\tconst primaryKeys = (\n\t\t\t\t\tObject.keys( records[ kind ][ name ].edits ) as string[]\n\t\t\t\t ).filter(\n\t\t\t\t\t( primaryKey ) =>\n\t\t\t\t\t\t// The entity record must exist (not be deleted),\n\t\t\t\t\t\t// and it must have edits.\n\t\t\t\t\t\tgetEntityRecord( state, kind, name, primaryKey ) &&\n\t\t\t\t\t\thasEditsForEntityRecord( state, kind, name, primaryKey )\n\t\t\t\t);\n\n\t\t\t\tif ( primaryKeys.length ) {\n\t\t\t\t\tconst entityConfig = getEntityConfig( state, kind, name );\n\t\t\t\t\tprimaryKeys.forEach( ( primaryKey ) => {\n\t\t\t\t\t\tconst entityRecord = getEditedEntityRecord(\n\t\t\t\t\t\t\tstate,\n\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\tprimaryKey\n\t\t\t\t\t\t);\n\t\t\t\t\t\tdirtyRecords.push( {\n\t\t\t\t\t\t\t// We avoid using primaryKey because it's transformed into a string\n\t\t\t\t\t\t\t// when it's used as an object key.\n\t\t\t\t\t\t\tkey: entityRecord\n\t\t\t\t\t\t\t\t? entityRecord[\n\t\t\t\t\t\t\t\t\t\tentityConfig.key || DEFAULT_ENTITY_KEY\n\t\t\t\t\t\t\t\t  ]\n\t\t\t\t\t\t\t\t: undefined,\n\t\t\t\t\t\t\ttitle:\n\t\t\t\t\t\t\t\tentityConfig?.getTitle?.( entityRecord ) || '',\n\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t} );\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\n\t\treturn dirtyRecords;\n\t},\n\t( state ) => [ state.entities.records ]\n);\n\n/**\n * Returns the list of entities currently being saved.\n *\n * @param state State tree.\n *\n * @return The list of records being saved.\n */\nexport const __experimentalGetEntitiesBeingSaved = createSelector(\n\t( state: State ): Array< DirtyEntityRecord > => {\n\t\tconst {\n\t\t\tentities: { records },\n\t\t} = state;\n\t\tconst recordsBeingSaved: DirtyEntityRecord[] = [];\n\t\tObject.keys( records ).forEach( ( kind ) => {\n\t\t\tObject.keys( records[ kind ] ).forEach( ( name ) => {\n\t\t\t\tconst primaryKeys = (\n\t\t\t\t\tObject.keys( records[ kind ][ name ].saving ) as string[]\n\t\t\t\t ).filter( ( primaryKey ) =>\n\t\t\t\t\tisSavingEntityRecord( state, kind, name, primaryKey )\n\t\t\t\t);\n\n\t\t\t\tif ( primaryKeys.length ) {\n\t\t\t\t\tconst entityConfig = getEntityConfig( state, kind, name );\n\t\t\t\t\tprimaryKeys.forEach( ( primaryKey ) => {\n\t\t\t\t\t\tconst entityRecord = getEditedEntityRecord(\n\t\t\t\t\t\t\tstate,\n\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\tprimaryKey\n\t\t\t\t\t\t);\n\t\t\t\t\t\trecordsBeingSaved.push( {\n\t\t\t\t\t\t\t// We avoid using primaryKey because it's transformed into a string\n\t\t\t\t\t\t\t// when it's used as an object key.\n\t\t\t\t\t\t\tkey: entityRecord\n\t\t\t\t\t\t\t\t? entityRecord[\n\t\t\t\t\t\t\t\t\t\tentityConfig.key || DEFAULT_ENTITY_KEY\n\t\t\t\t\t\t\t\t  ]\n\t\t\t\t\t\t\t\t: undefined,\n\t\t\t\t\t\t\ttitle:\n\t\t\t\t\t\t\t\tentityConfig?.getTitle?.( entityRecord ) || '',\n\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t} );\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\t\treturn recordsBeingSaved;\n\t},\n\t( state ) => [ state.entities.records ]\n);\n\n/**\n * Returns the specified entity record's edits.\n *\n * @param state    State tree.\n * @param kind     Entity kind.\n * @param name     Entity name.\n * @param recordId Record ID.\n *\n * @return The entity record's edits.\n */\nexport function getEntityRecordEdits(\n\tstate: State,\n\tkind: string,\n\tname: string,\n\trecordId: EntityRecordKey\n): Optional< any > {\n\treturn state.entities.records?.[ kind ]?.[ name ]?.edits?.[\n\t\trecordId as string | number\n\t];\n}\n\n/**\n * Returns the specified entity record's non transient edits.\n *\n * Transient edits don't create an undo level, and\n * are not considered for change detection.\n * They are defined in the entity's config.\n *\n * @param state    State tree.\n * @param kind     Entity kind.\n * @param name     Entity name.\n * @param recordId Record ID.\n *\n * @return The entity record's non transient edits.\n */\nexport const getEntityRecordNonTransientEdits = createSelector(\n\t(\n\t\tstate: State,\n\t\tkind: string,\n\t\tname: string,\n\t\trecordId: EntityRecordKey\n\t): Optional< any > => {\n\t\tconst { transientEdits } = getEntityConfig( state, kind, name ) || {};\n\t\tconst edits = getEntityRecordEdits( state, kind, name, recordId ) || {};\n\t\tif ( ! transientEdits ) {\n\t\t\treturn edits;\n\t\t}\n\t\treturn Object.keys( edits ).reduce( ( acc, key ) => {\n\t\t\tif ( ! transientEdits[ key ] ) {\n\t\t\t\tacc[ key ] = edits[ key ];\n\t\t\t}\n\t\t\treturn acc;\n\t\t}, {} );\n\t},\n\t( state: State, kind: string, name: string, recordId: EntityRecordKey ) => [\n\t\tstate.entities.config,\n\t\tstate.entities.records?.[ kind ]?.[ name ]?.edits?.[ recordId ],\n\t]\n);\n\n/**\n * Returns true if the specified entity record has edits,\n * and false otherwise.\n *\n * @param state    State tree.\n * @param kind     Entity kind.\n * @param name     Entity name.\n * @param recordId Record ID.\n *\n * @return Whether the entity record has edits or not.\n */\nexport function hasEditsForEntityRecord(\n\tstate: State,\n\tkind: string,\n\tname: string,\n\trecordId: EntityRecordKey\n): boolean {\n\treturn (\n\t\tisSavingEntityRecord( state, kind, name, recordId ) ||\n\t\tObject.keys(\n\t\t\tgetEntityRecordNonTransientEdits( state, kind, name, recordId )\n\t\t).length > 0\n\t);\n}\n\n/**\n * Returns the specified entity record, merged with its edits.\n *\n * @param state    State tree.\n * @param kind     Entity kind.\n * @param name     Entity name.\n * @param recordId Record ID.\n *\n * @return The entity record, merged with its edits.\n */\nexport const getEditedEntityRecord = createSelector(\n\t< EntityRecord extends ET.EntityRecord< any > >(\n\t\tstate: State,\n\t\tkind: string,\n\t\tname: string,\n\t\trecordId: EntityRecordKey\n\t): ET.Updatable< EntityRecord > | false => {\n\t\tconst raw = getRawEntityRecord( state, kind, name, recordId );\n\t\tconst edited = getEntityRecordEdits( state, kind, name, recordId );\n\t\t// Never return a non-falsy empty object. Unfortunately we can't return\n\t\t// undefined or null because we were previously returning an empty\n\t\t// object, so trying to read properties from the result would throw.\n\t\t// Using false here is a workaround to avoid breaking changes.\n\t\tif ( ! raw && ! edited ) {\n\t\t\treturn false;\n\t\t}\n\t\treturn {\n\t\t\t...raw,\n\t\t\t...edited,\n\t\t};\n\t},\n\t(\n\t\tstate: State,\n\t\tkind: string,\n\t\tname: string,\n\t\trecordId: EntityRecordKey,\n\t\tquery?: GetRecordsHttpQuery\n\t) => {\n\t\tconst context = query?.context ?? 'default';\n\t\treturn [\n\t\t\tstate.entities.config,\n\t\t\tstate.entities.records?.[ kind ]?.[ name ]?.queriedData.items[\n\t\t\t\tcontext\n\t\t\t]?.[ recordId ],\n\t\t\tstate.entities.records?.[ kind ]?.[ name ]?.queriedData\n\t\t\t\t.itemIsComplete[ context ]?.[ recordId ],\n\t\t\tstate.entities.records?.[ kind ]?.[ name ]?.edits?.[ recordId ],\n\t\t];\n\t}\n);\n\n/**\n * Returns true if the specified entity record is autosaving, and false otherwise.\n *\n * @param state    State tree.\n * @param kind     Entity kind.\n * @param name     Entity name.\n * @param recordId Record ID.\n *\n * @return Whether the entity record is autosaving or not.\n */\nexport function isAutosavingEntityRecord(\n\tstate: State,\n\tkind: string,\n\tname: string,\n\trecordId: EntityRecordKey\n): boolean {\n\tconst { pending, isAutosave } =\n\t\tstate.entities.records?.[ kind ]?.[ name ]?.saving?.[ recordId ] ?? {};\n\treturn Boolean( pending && isAutosave );\n}\n\n/**\n * Returns true if the specified entity record is saving, and false otherwise.\n *\n * @param state    State tree.\n * @param kind     Entity kind.\n * @param name     Entity name.\n * @param recordId Record ID.\n *\n * @return Whether the entity record is saving or not.\n */\nexport function isSavingEntityRecord(\n\tstate: State,\n\tkind: string,\n\tname: string,\n\trecordId: EntityRecordKey\n): boolean {\n\treturn (\n\t\tstate.entities.records?.[ kind ]?.[ name ]?.saving?.[\n\t\t\trecordId as EntityRecordKey\n\t\t]?.pending ?? false\n\t);\n}\n\n/**\n * Returns true if the specified entity record is deleting, and false otherwise.\n *\n * @param state    State tree.\n * @param kind     Entity kind.\n * @param name     Entity name.\n * @param recordId Record ID.\n *\n * @return Whether the entity record is deleting or not.\n */\nexport function isDeletingEntityRecord(\n\tstate: State,\n\tkind: string,\n\tname: string,\n\trecordId: EntityRecordKey\n): boolean {\n\treturn (\n\t\tstate.entities.records?.[ kind ]?.[ name ]?.deleting?.[\n\t\t\trecordId as EntityRecordKey\n\t\t]?.pending ?? false\n\t);\n}\n\n/**\n * Returns the specified entity record's last save error.\n *\n * @param state    State tree.\n * @param kind     Entity kind.\n * @param name     Entity name.\n * @param recordId Record ID.\n *\n * @return The entity record's save error.\n */\nexport function getLastEntitySaveError(\n\tstate: State,\n\tkind: string,\n\tname: string,\n\trecordId: EntityRecordKey\n): any {\n\treturn state.entities.records?.[ kind ]?.[ name ]?.saving?.[ recordId ]\n\t\t?.error;\n}\n\n/**\n * Returns the specified entity record's last delete error.\n *\n * @param state    State tree.\n * @param kind     Entity kind.\n * @param name     Entity name.\n * @param recordId Record ID.\n *\n * @return The entity record's save error.\n */\nexport function getLastEntityDeleteError(\n\tstate: State,\n\tkind: string,\n\tname: string,\n\trecordId: EntityRecordKey\n): any {\n\treturn state.entities.records?.[ kind ]?.[ name ]?.deleting?.[ recordId ]\n\t\t?.error;\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n/**\n * Returns the previous edit from the current undo offset\n * for the entity records edits history, if any.\n *\n * @deprecated since 6.3\n *\n * @param      state State tree.\n *\n * @return The edit.\n */\nexport function getUndoEdit( state: State ): Optional< any > {\n\tdeprecated( \"select( 'core' ).getUndoEdit()\", {\n\t\tsince: '6.3',\n\t} );\n\treturn undefined;\n}\n/* eslint-enable @typescript-eslint/no-unused-vars */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n/**\n * Returns the next edit from the current undo offset\n * for the entity records edits history, if any.\n *\n * @deprecated since 6.3\n *\n * @param      state State tree.\n *\n * @return The edit.\n */\nexport function getRedoEdit( state: State ): Optional< any > {\n\tdeprecated( \"select( 'core' ).getRedoEdit()\", {\n\t\tsince: '6.3',\n\t} );\n\treturn undefined;\n}\n/* eslint-enable @typescript-eslint/no-unused-vars */\n\n/**\n * Returns true if there is a previous edit from the current undo offset\n * for the entity records edits history, and false otherwise.\n *\n * @param state State tree.\n *\n * @return Whether there is a previous edit or not.\n */\nexport function hasUndo( state: State ): boolean {\n\treturn state.undoManager.hasUndo();\n}\n\n/**\n * Returns true if there is a next edit from the current undo offset\n * for the entity records edits history, and false otherwise.\n *\n * @param state State tree.\n *\n * @return Whether there is a next edit or not.\n */\nexport function hasRedo( state: State ): boolean {\n\treturn state.undoManager.hasRedo();\n}\n\n/**\n * Return the current theme.\n *\n * @param state Data state.\n *\n * @return The current theme.\n */\nexport function getCurrentTheme( state: State ): any {\n\tif ( ! state.currentTheme ) {\n\t\treturn null;\n\t}\n\treturn getEntityRecord( state, 'root', 'theme', state.currentTheme );\n}\n\n/**\n * Return the ID of the current global styles object.\n *\n * @param state Data state.\n *\n * @return The current global styles ID.\n */\nexport function __experimentalGetCurrentGlobalStylesId( state: State ): string {\n\treturn state.currentGlobalStylesId;\n}\n\n/**\n * Return theme supports data in the index.\n *\n * @param state Data state.\n *\n * @return Index data.\n */\nexport function getThemeSupports( state: State ): any {\n\treturn getCurrentTheme( state )?.theme_supports ?? EMPTY_OBJECT;\n}\n\n/**\n * Returns the embed preview for the given URL.\n *\n * @param state Data state.\n * @param url   Embedded URL.\n *\n * @return Undefined if the preview has not been fetched, otherwise, the preview fetched from the embed preview API.\n */\nexport function getEmbedPreview( state: State, url: string ): any {\n\treturn state.embedPreviews[ url ];\n}\n\n/**\n * Determines if the returned preview is an oEmbed link fallback.\n *\n * WordPress can be configured to return a simple link to a URL if it is not embeddable.\n * We need to be able to determine if a URL is embeddable or not, based on what we\n * get back from the oEmbed preview API.\n *\n * @param state Data state.\n * @param url   Embedded URL.\n *\n * @return Is the preview for the URL an oEmbed link fallback.\n */\nexport function isPreviewEmbedFallback( state: State, url: string ): boolean {\n\tconst preview = state.embedPreviews[ url ];\n\tconst oEmbedLinkCheck = '<a href=\"' + url + '\">' + url + '</a>';\n\tif ( ! preview ) {\n\t\treturn false;\n\t}\n\treturn preview.html === oEmbedLinkCheck;\n}\n\n/**\n * Returns whether the current user can perform the given action on the given\n * REST resource.\n *\n * Calling this may trigger an OPTIONS request to the REST API via the\n * `canUser()` resolver.\n *\n * https://developer.wordpress.org/rest-api/reference/\n *\n * @param state    Data state.\n * @param action   Action to check. One of: 'create', 'read', 'update', 'delete'.\n * @param resource Entity resource to check. Accepts entity object `{ kind: 'root', name: 'media', id: 1 }`\n *                 or REST base as a string - `media`.\n * @param id       Optional ID of the rest resource to check.\n *\n * @return Whether or not the user can perform the action,\n *                             or `undefined` if the OPTIONS request is still being made.\n */\nexport function canUser(\n\tstate: State,\n\taction: string,\n\tresource: string | EntityResource,\n\tid?: EntityRecordKey\n): boolean | undefined {\n\tconst isEntity = typeof resource === 'object';\n\tif ( isEntity && ( ! resource.kind || ! resource.name ) ) {\n\t\treturn false;\n\t}\n\n\tconst key = getUserPermissionCacheKey( action, resource, id );\n\n\treturn state.userPermissions[ key ];\n}\n\n/**\n * Returns whether the current user can edit the given entity.\n *\n * Calling this may trigger an OPTIONS request to the REST API via the\n * `canUser()` resolver.\n *\n * https://developer.wordpress.org/rest-api/reference/\n *\n * @param state    Data state.\n * @param kind     Entity kind.\n * @param name     Entity name.\n * @param recordId Record's id.\n * @return Whether or not the user can edit,\n * or `undefined` if the OPTIONS request is still being made.\n */\nexport function canUserEditEntityRecord(\n\tstate: State,\n\tkind: string,\n\tname: string,\n\trecordId: EntityRecordKey\n): boolean | undefined {\n\tdeprecated( `wp.data.select( 'core' ).canUserEditEntityRecord()`, {\n\t\tsince: '6.7',\n\t\talternative: `wp.data.select( 'core' ).canUser( 'update', { kind, name, id } )`,\n\t} );\n\n\treturn canUser( state, 'update', { kind, name, id: recordId } );\n}\n\n/**\n * Returns the latest autosaves for the post.\n *\n * May return multiple autosaves since the backend stores one autosave per\n * author for each post.\n *\n * @param state    State tree.\n * @param postType The type of the parent post.\n * @param postId   The id of the parent post.\n *\n * @return An array of autosaves for the post, or undefined if there is none.\n */\nexport function getAutosaves(\n\tstate: State,\n\tpostType: string,\n\tpostId: EntityRecordKey\n): Array< any > | undefined {\n\treturn state.autosaves[ postId ];\n}\n\n/**\n * Returns the autosave for the post and author.\n *\n * @param state    State tree.\n * @param postType The type of the parent post.\n * @param postId   The id of the parent post.\n * @param authorId The id of the author.\n *\n * @return The autosave for the post and author.\n */\nexport function getAutosave< EntityRecord extends ET.EntityRecord< any > >(\n\tstate: State,\n\tpostType: string,\n\tpostId: EntityRecordKey,\n\tauthorId: EntityRecordKey\n): EntityRecord | undefined {\n\tif ( authorId === undefined ) {\n\t\treturn;\n\t}\n\n\tconst autosaves = state.autosaves[ postId ];\n\n\treturn autosaves?.find(\n\t\t( autosave: any ) => autosave.author === authorId\n\t) as EntityRecord | undefined;\n}\n\n/**\n * Returns true if the REST request for autosaves has completed.\n *\n * @param state    State tree.\n * @param postType The type of the parent post.\n * @param postId   The id of the parent post.\n *\n * @return True if the REST request was completed. False otherwise.\n */\nexport const hasFetchedAutosaves = createRegistrySelector(\n\t( select ) =>\n\t\t(\n\t\t\tstate: State,\n\t\t\tpostType: string,\n\t\t\tpostId: EntityRecordKey\n\t\t): boolean => {\n\t\t\treturn select( STORE_NAME ).hasFinishedResolution( 'getAutosaves', [\n\t\t\t\tpostType,\n\t\t\t\tpostId,\n\t\t\t] );\n\t\t}\n);\n\n/**\n * Returns a new reference when edited values have changed. This is useful in\n * inferring where an edit has been made between states by comparison of the\n * return values using strict equality.\n *\n * @example\n *\n * ```\n * const hasEditOccurred = (\n *    getReferenceByDistinctEdits( beforeState ) !==\n *    getReferenceByDistinctEdits( afterState )\n * );\n * ```\n *\n * @param state Editor state.\n *\n * @return A value whose reference will change only when an edit occurs.\n */\nexport function getReferenceByDistinctEdits( state ) {\n\treturn state.editsReference;\n}\n\n/**\n * Retrieve the current theme's base global styles\n *\n * @param state Editor state.\n *\n * @return The Global Styles object.\n */\nexport function __experimentalGetCurrentThemeBaseGlobalStyles(\n\tstate: State\n): any {\n\tconst currentTheme = getCurrentTheme( state );\n\tif ( ! currentTheme ) {\n\t\treturn null;\n\t}\n\treturn state.themeBaseGlobalStyles[ currentTheme.stylesheet ];\n}\n\n/**\n * Return the ID of the current global styles object.\n *\n * @param state Data state.\n *\n * @return The current global styles ID.\n */\nexport function __experimentalGetCurrentThemeGlobalStylesVariations(\n\tstate: State\n): string | null {\n\tconst currentTheme = getCurrentTheme( state );\n\tif ( ! currentTheme ) {\n\t\treturn null;\n\t}\n\treturn state.themeGlobalStyleVariations[ currentTheme.stylesheet ];\n}\n\n/**\n * Retrieve the list of registered block patterns.\n *\n * @param state Data state.\n *\n * @return Block pattern list.\n */\nexport function getBlockPatterns( state: State ): Array< any > {\n\treturn state.blockPatterns;\n}\n\n/**\n * Retrieve the list of registered block pattern categories.\n *\n * @param state Data state.\n *\n * @return Block pattern category list.\n */\nexport function getBlockPatternCategories( state: State ): Array< any > {\n\treturn state.blockPatternCategories;\n}\n\n/**\n * Retrieve the registered user pattern categories.\n *\n * @param state Data state.\n *\n * @return User patterns category array.\n */\n\nexport function getUserPatternCategories(\n\tstate: State\n): Array< UserPatternCategory > {\n\treturn state.userPatternCategories;\n}\n\n/**\n * Returns the revisions of the current global styles theme.\n *\n * @deprecated since WordPress 6.5.0. Callers should use `select( 'core' ).getRevisions( 'root', 'globalStyles', ${ recordKey } )` instead, where `recordKey` is the id of the global styles parent post.\n *\n * @param      state Data state.\n *\n * @return The current global styles.\n */\nexport function getCurrentThemeGlobalStylesRevisions(\n\tstate: State\n): Array< object > | null {\n\tdeprecated( \"select( 'core' ).getCurrentThemeGlobalStylesRevisions()\", {\n\t\tsince: '6.5.0',\n\t\talternative:\n\t\t\t\"select( 'core' ).getRevisions( 'root', 'globalStyles', ${ recordKey } )\",\n\t} );\n\tconst currentGlobalStylesId =\n\t\t__experimentalGetCurrentGlobalStylesId( state );\n\n\tif ( ! currentGlobalStylesId ) {\n\t\treturn null;\n\t}\n\n\treturn state.themeGlobalStyleRevisions[ currentGlobalStylesId ];\n}\n\n/**\n * Returns the default template use to render a given query.\n *\n * @param state Data state.\n * @param query Query.\n *\n * @return The default template id for the given query.\n */\nexport function getDefaultTemplateId(\n\tstate: State,\n\tquery: TemplateQuery\n): string {\n\treturn state.defaultTemplates[ JSON.stringify( query ) ];\n}\n\n/**\n * Returns an entity's revisions.\n *\n * @param state     State tree\n * @param kind      Entity kind.\n * @param name      Entity name.\n * @param recordKey The key of the entity record whose revisions you want to fetch.\n * @param query     Optional query. If requesting specific\n *                  fields, fields must always include the ID. For valid query parameters see revisions schema in [the REST API Handbook](https://developer.wordpress.org/rest-api/reference/). Then see the arguments available \"Retrieve a [Entity kind]\".\n *\n * @return Record.\n */\nexport const getRevisions = (\n\tstate: State,\n\tkind: string,\n\tname: string,\n\trecordKey: EntityRecordKey,\n\tquery?: GetRecordsHttpQuery\n): RevisionRecord[] | null => {\n\tconst queriedStateRevisions =\n\t\tstate.entities.records?.[ kind ]?.[ name ]?.revisions?.[ recordKey ];\n\tif ( ! queriedStateRevisions ) {\n\t\treturn null;\n\t}\n\n\treturn getQueriedItems( queriedStateRevisions, query );\n};\n\n/**\n * Returns a single, specific revision of a parent entity.\n *\n * @param state       State tree\n * @param kind        Entity kind.\n * @param name        Entity name.\n * @param recordKey   The key of the entity record whose revisions you want to fetch.\n * @param revisionKey The revision's key.\n * @param query       Optional query. If requesting specific\n *                    fields, fields must always include the ID. For valid query parameters see revisions schema in [the REST API Handbook](https://developer.wordpress.org/rest-api/reference/). Then see the arguments available \"Retrieve a [entity kind]\".\n *\n * @return Record.\n */\nexport const getRevision = createSelector(\n\t(\n\t\tstate: State,\n\t\tkind: string,\n\t\tname: string,\n\t\trecordKey: EntityRecordKey,\n\t\trevisionKey: EntityRecordKey,\n\t\tquery?: GetRecordsHttpQuery\n\t): RevisionRecord | Record< PropertyKey, never > | undefined => {\n\t\tconst queriedState =\n\t\t\tstate.entities.records?.[ kind ]?.[ name ]?.revisions?.[\n\t\t\t\trecordKey\n\t\t\t];\n\n\t\tif ( ! queriedState ) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst context = query?.context ?? 'default';\n\n\t\tif ( query === undefined ) {\n\t\t\t// If expecting a complete item, validate that completeness.\n\t\t\tif ( ! queriedState.itemIsComplete[ context ]?.[ revisionKey ] ) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\n\t\t\treturn queriedState.items[ context ][ revisionKey ];\n\t\t}\n\n\t\tconst item = queriedState.items[ context ]?.[ revisionKey ];\n\t\tif ( item && query._fields ) {\n\t\t\tconst filteredItem = {};\n\t\t\tconst fields = getNormalizedCommaSeparable( query._fields ) ?? [];\n\n\t\t\tfor ( let f = 0; f < fields.length; f++ ) {\n\t\t\t\tconst field = fields[ f ].split( '.' );\n\t\t\t\tlet value = item;\n\t\t\t\tfield.forEach( ( fieldName ) => {\n\t\t\t\t\tvalue = value?.[ fieldName ];\n\t\t\t\t} );\n\t\t\t\tsetNestedValue( filteredItem, field, value );\n\t\t\t}\n\n\t\t\treturn filteredItem;\n\t\t}\n\n\t\treturn item;\n\t},\n\t( state: State, kind, name, recordKey, revisionKey, query ) => {\n\t\tconst context = query?.context ?? 'default';\n\t\treturn [\n\t\t\tstate.entities.records?.[ kind ]?.[ name ]?.revisions?.[ recordKey ]\n\t\t\t\t?.items?.[ context ]?.[ revisionKey ],\n\t\t\tstate.entities.records?.[ kind ]?.[ name ]?.revisions?.[ recordKey ]\n\t\t\t\t?.itemIsComplete?.[ context ]?.[ revisionKey ],\n\t\t];\n\t}\n);\n","/**\n * Checks argument to determine if it's a numeric ID.\n * For example, '123' is a numeric ID, but '123abc' is not.\n *\n * @param {any} id the argument to determine if it's a numeric ID.\n * @return {boolean} true if the string is a numeric ID, false otherwise.\n */\nexport default function isNumericID( id ) {\n\treturn /^\\s*\\d+\\s*$/.test( id );\n}\n","/**\n * Checks whether the attribute is a \"raw\" attribute or not.\n *\n * @param {Object} entity    Entity record.\n * @param {string} attribute Attribute name.\n *\n * @return {boolean} Is the attribute raw\n */\nexport default function isRawAttribute( entity, attribute ) {\n\treturn ( entity.rawAttributes || [] ).includes( attribute );\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"privateApis\"];","/**\n * WordPress dependencies\n */\nimport { __dangerousOptInToUnstableAPIsOnlyForCoreModules } from '@wordpress/private-apis';\n\nexport const { lock, unlock } =\n\t__dangerousOptInToUnstableAPIsOnlyForCoreModules(\n\t\t'I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.',\n\t\t'@wordpress/core-data'\n\t);\n","/**\n * WordPress dependencies\n */\nimport { createSelector, createRegistrySelector } from '@wordpress/data';\n\n/**\n * Internal dependencies\n */\nimport { getDefaultTemplateId, getEntityRecord, type State } from './selectors';\nimport { STORE_NAME } from './name';\nimport { unlock } from './lock-unlock';\n\ntype EntityRecordKey = string | number;\n\n/**\n * Returns the previous edit from the current undo offset\n * for the entity records edits history, if any.\n *\n * @param state State tree.\n *\n * @return The undo manager.\n */\nexport function getUndoManager( state: State ) {\n\treturn state.undoManager;\n}\n\n/**\n * Retrieve the fallback Navigation.\n *\n * @param state Data state.\n * @return The ID for the fallback Navigation post.\n */\nexport function getNavigationFallbackId(\n\tstate: State\n): EntityRecordKey | undefined {\n\treturn state.navigationFallbackId;\n}\n\nexport const getBlockPatternsForPostType = createRegistrySelector(\n\t( select: any ) =>\n\t\tcreateSelector(\n\t\t\t( state, postType ) =>\n\t\t\t\tselect( STORE_NAME )\n\t\t\t\t\t.getBlockPatterns()\n\t\t\t\t\t.filter(\n\t\t\t\t\t\t( { postTypes } ) =>\n\t\t\t\t\t\t\t! postTypes ||\n\t\t\t\t\t\t\t( Array.isArray( postTypes ) &&\n\t\t\t\t\t\t\t\tpostTypes.includes( postType ) )\n\t\t\t\t\t),\n\t\t\t() => [ select( STORE_NAME ).getBlockPatterns() ]\n\t\t)\n);\n\n/**\n * Returns the entity records permissions for the given entity record ids.\n */\nexport const getEntityRecordsPermissions = createRegistrySelector( ( select ) =>\n\tcreateSelector(\n\t\t(\n\t\t\tstate: State,\n\t\t\tkind: string,\n\t\t\tname: string,\n\t\t\tids: string | string[]\n\t\t) => {\n\t\t\tconst normalizedIds = Array.isArray( ids ) ? ids : [ ids ];\n\t\t\treturn normalizedIds.map( ( id ) => ( {\n\t\t\t\tdelete: select( STORE_NAME ).canUser( 'delete', {\n\t\t\t\t\tkind,\n\t\t\t\t\tname,\n\t\t\t\t\tid,\n\t\t\t\t} ),\n\t\t\t\tupdate: select( STORE_NAME ).canUser( 'update', {\n\t\t\t\t\tkind,\n\t\t\t\t\tname,\n\t\t\t\t\tid,\n\t\t\t\t} ),\n\t\t\t} ) );\n\t\t},\n\t\t( state ) => [ state.userPermissions ]\n\t)\n);\n\n/**\n * Returns the entity record permissions for the given entity record id.\n *\n * @param state Data state.\n * @param kind  Entity kind.\n * @param name  Entity name.\n * @param id    Entity record id.\n *\n * @return The entity record permissions.\n */\nexport function getEntityRecordPermissions(\n\tstate: State,\n\tkind: string,\n\tname: string,\n\tid: string\n) {\n\treturn getEntityRecordsPermissions( state, kind, name, id )[ 0 ];\n}\n\n/**\n * Returns the registered post meta fields for a given post type.\n *\n * @param state    Data state.\n * @param postType Post type.\n *\n * @return Registered post meta fields.\n */\nexport function getRegisteredPostMeta( state: State, postType: string ) {\n\treturn state.registeredPostMeta?.[ postType ] ?? {};\n}\n\nfunction normalizePageId( value: number | string | undefined ): string | null {\n\tif ( ! value || ! [ 'number', 'string' ].includes( typeof value ) ) {\n\t\treturn null;\n\t}\n\n\t// We also need to check if it's not zero (`'0'`).\n\tif ( Number( value ) === 0 ) {\n\t\treturn null;\n\t}\n\n\treturn value.toString();\n}\n\ninterface SiteData {\n\tshow_on_front?: string;\n\tpage_on_front?: string | number;\n\tpage_for_posts?: string | number;\n}\n\nexport const getHomePage = createRegistrySelector( ( select ) =>\n\tcreateSelector(\n\t\t() => {\n\t\t\tconst siteData = select( STORE_NAME ).getEntityRecord(\n\t\t\t\t'root',\n\t\t\t\t'__unstableBase'\n\t\t\t) as SiteData | undefined;\n\t\t\tif ( ! siteData ) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t\tconst homepageId =\n\t\t\t\tsiteData?.show_on_front === 'page'\n\t\t\t\t\t? normalizePageId( siteData.page_on_front )\n\t\t\t\t\t: null;\n\t\t\tif ( homepageId ) {\n\t\t\t\treturn { postType: 'page', postId: homepageId };\n\t\t\t}\n\t\t\tconst frontPageTemplateId = select(\n\t\t\t\tSTORE_NAME\n\t\t\t).getDefaultTemplateId( {\n\t\t\t\tslug: 'front-page',\n\t\t\t} );\n\t\t\treturn { postType: 'wp_template', postId: frontPageTemplateId };\n\t\t},\n\t\t( state ) => [\n\t\t\tgetEntityRecord( state, 'root', '__unstableBase' ),\n\t\t\tgetDefaultTemplateId( state, {\n\t\t\t\tslug: 'front-page',\n\t\t\t} ),\n\t\t]\n\t)\n);\n\nexport const getPostsPageId = createRegistrySelector( ( select ) => () => {\n\tconst siteData = select( STORE_NAME ).getEntityRecord(\n\t\t'root',\n\t\t'__unstableBase'\n\t) as SiteData | undefined;\n\treturn siteData?.show_on_front === 'page'\n\t\t? normalizePageId( siteData.page_for_posts )\n\t\t: null;\n} );\n\nexport const getTemplateId = createRegistrySelector(\n\t( select ) => ( state, postType, postId ) => {\n\t\tconst homepage = unlock( select( STORE_NAME ) ).getHomePage();\n\n\t\tif ( ! homepage ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// For the front page, we always use the front page template if existing.\n\t\tif (\n\t\t\tpostType === 'page' &&\n\t\t\tpostType === homepage?.postType &&\n\t\t\tpostId.toString() === homepage?.postId\n\t\t) {\n\t\t\t// The /lookup endpoint cannot currently handle a lookup\n\t\t\t// when a page is set as the front page, so specifically in\n\t\t\t// that case, we want to check if there is a front page\n\t\t\t// template, and instead of falling back to the home\n\t\t\t// template, we want to fall back to the page template.\n\t\t\tconst templates = select( STORE_NAME ).getEntityRecords(\n\t\t\t\t'postType',\n\t\t\t\t'wp_template',\n\t\t\t\t{\n\t\t\t\t\tper_page: -1,\n\t\t\t\t}\n\t\t\t);\n\t\t\tif ( ! templates ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst id = templates.find( ( { slug } ) => slug === 'front-page' )\n\t\t\t\t?.id;\n\t\t\tif ( id ) {\n\t\t\t\treturn id;\n\t\t\t}\n\t\t\t// If no front page template is found, continue with the\n\t\t\t// logic below (fetching the page template).\n\t\t}\n\n\t\tconst editedEntity = select( STORE_NAME ).getEditedEntityRecord(\n\t\t\t'postType',\n\t\t\tpostType,\n\t\t\tpostId\n\t\t);\n\t\tif ( ! editedEntity ) {\n\t\t\treturn;\n\t\t}\n\t\tconst postsPageId = unlock( select( STORE_NAME ) ).getPostsPageId();\n\t\t// Check if the current page is the posts page.\n\t\tif ( postType === 'page' && postsPageId === postId.toString() ) {\n\t\t\treturn select( STORE_NAME ).getDefaultTemplateId( {\n\t\t\t\tslug: 'home',\n\t\t\t} );\n\t\t}\n\t\t// First see if the post/page has an assigned template and fetch it.\n\t\tconst currentTemplateSlug = editedEntity.template;\n\t\tif ( currentTemplateSlug ) {\n\t\t\tconst currentTemplate = select( STORE_NAME )\n\t\t\t\t.getEntityRecords( 'postType', 'wp_template', {\n\t\t\t\t\tper_page: -1,\n\t\t\t\t} )\n\t\t\t\t?.find( ( { slug } ) => slug === currentTemplateSlug );\n\t\t\tif ( currentTemplate ) {\n\t\t\t\treturn currentTemplate.id;\n\t\t\t}\n\t\t}\n\t\t// If no template is assigned, use the default template.\n\t\tlet slugToCheck;\n\t\t// In `draft` status we might not have a slug available, so we use the `single`\n\t\t// post type templates slug(ex page, single-post, single-product etc..).\n\t\t// Pages do not need the `single` prefix in the slug to be prioritized\n\t\t// through template hierarchy.\n\t\tif ( editedEntity.slug ) {\n\t\t\tslugToCheck =\n\t\t\t\tpostType === 'page'\n\t\t\t\t\t? `${ postType }-${ editedEntity.slug }`\n\t\t\t\t\t: `single-${ postType }-${ editedEntity.slug }`;\n\t\t} else {\n\t\t\tslugToCheck = postType === 'page' ? 'page' : `single-${ postType }`;\n\t\t}\n\t\treturn select( STORE_NAME ).getDefaultTemplateId( {\n\t\t\tslug: slugToCheck,\n\t\t} );\n\t}\n);\n","// Unique ID creation requires a high quality random # generator. In the browser we therefore\n// require the crypto API and do not support built-in fallback to lower quality random number\n// generators (like Math.random()).\nvar getRandomValues;\nvar rnds8 = new Uint8Array(16);\nexport default function rng() {\n  // lazy load so that environments that need to polyfill have a chance to do so\n  if (!getRandomValues) {\n    // getRandomValues needs to be invoked in a context where \"this\" is a Crypto implementation. Also,\n    // find the complete implementation of crypto (msCrypto) on IE11.\n    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);\n\n    if (!getRandomValues) {\n      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n    }\n  }\n\n  return getRandomValues(rnds8);\n}","export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;","import validate from './validate.js';\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n\nvar byteToHex = [];\n\nfor (var i = 0; i < 256; ++i) {\n  byteToHex.push((i + 0x100).toString(16).substr(1));\n}\n\nfunction stringify(arr) {\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  // Note: Be careful editing this code!  It's been tuned for performance\n  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\n  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one\n  // of the following:\n  // - One or more input array values don't map to a hex octet (leading to\n  // \"undefined\" in the uuid)\n  // - Invalid input values for the RFC `version` or `variant` fields\n\n  if (!validate(uuid)) {\n    throw TypeError('Stringified UUID is invalid');\n  }\n\n  return uuid;\n}\n\nexport default stringify;","import REGEX from './regex.js';\n\nfunction validate(uuid) {\n  return typeof uuid === 'string' && REGEX.test(uuid);\n}\n\nexport default validate;","import rng from './rng.js';\nimport stringify from './stringify.js';\n\nfunction v4(options, buf, offset) {\n  options = options || {};\n  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n\n  rnds[6] = rnds[6] & 0x0f | 0x40;\n  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\n\n  if (buf) {\n    offset = offset || 0;\n\n    for (var i = 0; i < 16; ++i) {\n      buf[offset + i] = rnds[i];\n    }\n\n    return buf;\n  }\n\n  return stringify(rnds);\n}\n\nexport default v4;","/**\n * Helper util to return a value from a certain path of the object.\n * Path is specified as either:\n * - a string of properties, separated by dots, for example: \"x.y\".\n * - an array of properties, for example `[ 'x', 'y' ]`.\n * You can also specify a default value in case the result is nullish.\n *\n * @param {Object}       object       Input object.\n * @param {string|Array} path         Path to the object property.\n * @param {*}            defaultValue Default value if the value at the specified path is undefined.\n * @return {*} Value of the object property at the specified path.\n */\nexport default function getNestedValue( object, path, defaultValue ) {\n\tif (\n\t\t! object ||\n\t\ttypeof object !== 'object' ||\n\t\t( typeof path !== 'string' && ! Array.isArray( path ) )\n\t) {\n\t\treturn object;\n\t}\n\tconst normalizedPath = Array.isArray( path ) ? path : path.split( '.' );\n\tlet value = object;\n\tnormalizedPath.forEach( ( fieldName ) => {\n\t\tvalue = value?.[ fieldName ];\n\t} );\n\treturn value !== undefined ? value : defaultValue;\n}\n","/**\n * Returns an action object used in signalling that items have been received.\n *\n * @param {Array}   items Items received.\n * @param {?Object} edits Optional edits to reset.\n * @param {?Object} meta  Meta information about pagination.\n *\n * @return {Object} Action object.\n */\nexport function receiveItems( items, edits, meta ) {\n\treturn {\n\t\ttype: 'RECEIVE_ITEMS',\n\t\titems: Array.isArray( items ) ? items : [ items ],\n\t\tpersistedEdits: edits,\n\t\tmeta,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that entity records have been\n * deleted and they need to be removed from entities state.\n *\n * @param {string}              kind            Kind of the removed entities.\n * @param {string}              name            Name of the removed entities.\n * @param {Array|number|string} records         Record IDs of the removed entities.\n * @param {boolean}             invalidateCache Controls whether we want to invalidate the cache.\n * @return {Object} Action object.\n */\nexport function removeItems( kind, name, records, invalidateCache = false ) {\n\treturn {\n\t\ttype: 'REMOVE_ITEMS',\n\t\titemIds: Array.isArray( records ) ? records : [ records ],\n\t\tkind,\n\t\tname,\n\t\tinvalidateCache,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that queried data has been\n * received.\n *\n * @param {Array}   items Queried items received.\n * @param {?Object} query Optional query object.\n * @param {?Object} edits Optional edits to reset.\n * @param {?Object} meta  Meta information about pagination.\n *\n * @return {Object} Action object.\n */\nexport function receiveQueriedItems( items, query = {}, edits, meta ) {\n\treturn {\n\t\t...receiveItems( items, edits, meta ),\n\t\tquery,\n\t};\n}\n","/**\n * WordPress dependencies\n */\nimport apiFetch from '@wordpress/api-fetch';\n\n/**\n * Maximum number of requests to place in a single batch request. Obtained by\n * sending a preflight OPTIONS request to /batch/v1/.\n *\n * @type {number?}\n */\nlet maxItems = null;\n\nfunction chunk( arr, chunkSize ) {\n\tconst tmp = [ ...arr ];\n\tconst cache = [];\n\twhile ( tmp.length ) {\n\t\tcache.push( tmp.splice( 0, chunkSize ) );\n\t}\n\n\treturn cache;\n}\n\n/**\n * Default batch processor. Sends its input requests to /batch/v1.\n *\n * @param {Array} requests List of API requests to perform at once.\n *\n * @return {Promise} Promise that resolves to a list of objects containing\n *                   either `output` (if that request was successful) or `error`\n *                   (if not ).\n */\nexport default async function defaultProcessor( requests ) {\n\tif ( maxItems === null ) {\n\t\tconst preflightResponse = await apiFetch( {\n\t\t\tpath: '/batch/v1',\n\t\t\tmethod: 'OPTIONS',\n\t\t} );\n\t\tmaxItems = preflightResponse.endpoints[ 0 ].args.requests.maxItems;\n\t}\n\n\tconst results = [];\n\n\t// @ts-ignore We would have crashed or never gotten to this point if we hadn't received the maxItems count.\n\tfor ( const batchRequests of chunk( requests, maxItems ) ) {\n\t\tconst batchResponse = await apiFetch( {\n\t\t\tpath: '/batch/v1',\n\t\t\tmethod: 'POST',\n\t\t\tdata: {\n\t\t\t\tvalidation: 'require-all-validate',\n\t\t\t\trequests: batchRequests.map( ( request ) => ( {\n\t\t\t\t\tpath: request.path,\n\t\t\t\t\tbody: request.data, // Rename 'data' to 'body'.\n\t\t\t\t\tmethod: request.method,\n\t\t\t\t\theaders: request.headers,\n\t\t\t\t} ) ),\n\t\t\t},\n\t\t} );\n\n\t\tlet batchResults;\n\n\t\tif ( batchResponse.failed ) {\n\t\t\tbatchResults = batchResponse.responses.map( ( response ) => ( {\n\t\t\t\terror: response?.body,\n\t\t\t} ) );\n\t\t} else {\n\t\t\tbatchResults = batchResponse.responses.map( ( response ) => {\n\t\t\t\tconst result = {};\n\t\t\t\tif ( response.status >= 200 && response.status < 300 ) {\n\t\t\t\t\tresult.output = response.body;\n\t\t\t\t} else {\n\t\t\t\t\tresult.error = response.body;\n\t\t\t\t}\n\t\t\t\treturn result;\n\t\t\t} );\n\t\t}\n\n\t\tresults.push( ...batchResults );\n\t}\n\n\treturn results;\n}\n","/**\n * Internal dependencies\n */\nimport defaultProcessor from './default-processor';\n\n/**\n * Creates a batch, which can be used to combine multiple API requests into one\n * API request using the WordPress batch processing API (/v1/batch).\n *\n * ```\n * const batch = createBatch();\n * const dunePromise = batch.add( {\n *   path: '/v1/books',\n *   method: 'POST',\n *   data: { title: 'Dune' }\n * } );\n * const lotrPromise = batch.add( {\n *   path: '/v1/books',\n *   method: 'POST',\n *   data: { title: 'Lord of the Rings' }\n * } );\n * const isSuccess = await batch.run(); // Sends one POST to /v1/batch.\n * if ( isSuccess ) {\n *   console.log(\n *     'Saved two books:',\n *     await dunePromise,\n *     await lotrPromise\n *   );\n * }\n * ```\n *\n * @param {Function} [processor] Processor function. Can be used to replace the\n *                               default functionality which is to send an API\n *                               request to /v1/batch. Is given an array of\n *                               inputs and must return a promise that\n *                               resolves to an array of objects containing\n *                               either `output` or `error`.\n */\nexport default function createBatch( processor = defaultProcessor ) {\n\tlet lastId = 0;\n\t/** @type {Array<{ input: any; resolve: ( value: any ) => void; reject: ( error: any ) => void }>} */\n\tlet queue = [];\n\tconst pending = new ObservableSet();\n\n\treturn {\n\t\t/**\n\t\t * Adds an input to the batch and returns a promise that is resolved or\n\t\t * rejected when the input is processed by `batch.run()`.\n\t\t *\n\t\t * You may also pass a thunk which allows inputs to be added\n\t\t * asynchronously.\n\t\t *\n\t\t * ```\n\t\t * // Both are allowed:\n\t\t * batch.add( { path: '/v1/books', ... } );\n\t\t * batch.add( ( add ) => add( { path: '/v1/books', ... } ) );\n\t\t * ```\n\t\t *\n\t\t * If a thunk is passed, `batch.run()` will pause until either:\n\t\t *\n\t\t * - The thunk calls its `add` argument, or;\n\t\t * - The thunk returns a promise and that promise resolves, or;\n\t\t * - The thunk returns a non-promise.\n\t\t *\n\t\t * @param {any|Function} inputOrThunk Input to add or thunk to execute.\n\t\t *\n\t\t * @return {Promise|any} If given an input, returns a promise that\n\t\t *                       is resolved or rejected when the batch is\n\t\t *                       processed. If given a thunk, returns the return\n\t\t *                       value of that thunk.\n\t\t */\n\t\tadd( inputOrThunk ) {\n\t\t\tconst id = ++lastId;\n\t\t\tpending.add( id );\n\n\t\t\tconst add = ( input ) =>\n\t\t\t\tnew Promise( ( resolve, reject ) => {\n\t\t\t\t\tqueue.push( {\n\t\t\t\t\t\tinput,\n\t\t\t\t\t\tresolve,\n\t\t\t\t\t\treject,\n\t\t\t\t\t} );\n\t\t\t\t\tpending.delete( id );\n\t\t\t\t} );\n\n\t\t\tif ( typeof inputOrThunk === 'function' ) {\n\t\t\t\treturn Promise.resolve( inputOrThunk( add ) ).finally( () => {\n\t\t\t\t\tpending.delete( id );\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\treturn add( inputOrThunk );\n\t\t},\n\n\t\t/**\n\t\t * Runs the batch. This calls `batchProcessor` and resolves or rejects\n\t\t * all promises returned by `add()`.\n\t\t *\n\t\t * @return {Promise<boolean>} A promise that resolves to a boolean that is true\n\t\t *                   if the processor returned no errors.\n\t\t */\n\t\tasync run() {\n\t\t\tif ( pending.size ) {\n\t\t\t\tawait new Promise( ( resolve ) => {\n\t\t\t\t\tconst unsubscribe = pending.subscribe( () => {\n\t\t\t\t\t\tif ( ! pending.size ) {\n\t\t\t\t\t\t\tunsubscribe();\n\t\t\t\t\t\t\tresolve( undefined );\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\tlet results;\n\n\t\t\ttry {\n\t\t\t\tresults = await processor(\n\t\t\t\t\tqueue.map( ( { input } ) => input )\n\t\t\t\t);\n\n\t\t\t\tif ( results.length !== queue.length ) {\n\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t'run: Array returned by processor must be same size as input array.'\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t} catch ( error ) {\n\t\t\t\tfor ( const { reject } of queue ) {\n\t\t\t\t\treject( error );\n\t\t\t\t}\n\n\t\t\t\tthrow error;\n\t\t\t}\n\n\t\t\tlet isSuccess = true;\n\n\t\t\tresults.forEach( ( result, key ) => {\n\t\t\t\tconst queueItem = queue[ key ];\n\n\t\t\t\tif ( result?.error ) {\n\t\t\t\t\tqueueItem?.reject( result.error );\n\t\t\t\t\tisSuccess = false;\n\t\t\t\t} else {\n\t\t\t\t\tqueueItem?.resolve( result?.output ?? result );\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\tqueue = [];\n\n\t\t\treturn isSuccess;\n\t\t},\n\t};\n}\n\nclass ObservableSet {\n\tconstructor( ...args ) {\n\t\tthis.set = new Set( ...args );\n\t\tthis.subscribers = new Set();\n\t}\n\n\tget size() {\n\t\treturn this.set.size;\n\t}\n\n\tadd( value ) {\n\t\tthis.set.add( value );\n\t\tthis.subscribers.forEach( ( subscriber ) => subscriber() );\n\t\treturn this;\n\t}\n\n\tdelete( value ) {\n\t\tconst isSuccess = this.set.delete( value );\n\t\tthis.subscribers.forEach( ( subscriber ) => subscriber() );\n\t\treturn isSuccess;\n\t}\n\n\tsubscribe( subscriber ) {\n\t\tthis.subscribers.add( subscriber );\n\t\treturn () => {\n\t\t\tthis.subscribers.delete( subscriber );\n\t\t};\n\t}\n}\n","/**\n * Utility module to work with key-value stores.\n *\n * @module map\n */\n\n/**\n * Creates a new Map instance.\n *\n * @function\n * @return {Map<any, any>}\n *\n * @function\n */\nexport const create = () => new Map()\n\n/**\n * Copy a Map object into a fresh Map object.\n *\n * @function\n * @template X,Y\n * @param {Map<X,Y>} m\n * @return {Map<X,Y>}\n */\nexport const copy = m => {\n  const r = create()\n  m.forEach((v, k) => { r.set(k, v) })\n  return r\n}\n\n/**\n * Get map property. Create T if property is undefined and set T on map.\n *\n * ```js\n * const listeners = map.setIfUndefined(events, 'eventName', set.create)\n * listeners.add(listener)\n * ```\n *\n * @function\n * @template V,K\n * @template {Map<K,V>} MAP\n * @param {MAP} map\n * @param {K} key\n * @param {function():V} createT\n * @return {V}\n */\nexport const setIfUndefined = (map, key, createT) => {\n  let set = map.get(key)\n  if (set === undefined) {\n    map.set(key, set = createT())\n  }\n  return set\n}\n\n/**\n * Creates an Array and populates it with the content of all key-value pairs using the `f(value, key)` function.\n *\n * @function\n * @template K\n * @template V\n * @template R\n * @param {Map<K,V>} m\n * @param {function(V,K):R} f\n * @return {Array<R>}\n */\nexport const map = (m, f) => {\n  const res = []\n  for (const [key, value] of m) {\n    res.push(f(value, key))\n  }\n  return res\n}\n\n/**\n * Tests whether any key-value pairs pass the test implemented by `f(value, key)`.\n *\n * @todo should rename to some - similarly to Array.some\n *\n * @function\n * @template K\n * @template V\n * @param {Map<K,V>} m\n * @param {function(V,K):boolean} f\n * @return {boolean}\n */\nexport const any = (m, f) => {\n  for (const [key, value] of m) {\n    if (f(value, key)) {\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * Tests whether all key-value pairs pass the test implemented by `f(value, key)`.\n *\n * @function\n * @template K\n * @template V\n * @param {Map<K,V>} m\n * @param {function(V,K):boolean} f\n * @return {boolean}\n */\nexport const all = (m, f) => {\n  for (const [key, value] of m) {\n    if (!f(value, key)) {\n      return false\n    }\n  }\n  return true\n}\n","/**\n * Utility module to work with sets.\n *\n * @module set\n */\n\nexport const create = () => new Set()\n\n/**\n * @template T\n * @param {Set<T>} set\n * @return {Array<T>}\n */\nexport const toArray = set => Array.from(set)\n\n/**\n * @template T\n * @param {Set<T>} set\n * @return {T}\n */\nexport const first = set =>\n  set.values().next().value || undefined\n\n/**\n * @template T\n * @param {Iterable<T>} entries\n * @return {Set<T>}\n */\nexport const from = entries => new Set(entries)\n","/**\n * Utility module to work with Arrays.\n *\n * @module array\n */\n\nimport * as set from './set.js'\n\n/**\n * Return the last element of an array. The element must exist\n *\n * @template L\n * @param {ArrayLike<L>} arr\n * @return {L}\n */\nexport const last = arr => arr[arr.length - 1]\n\n/**\n * @template C\n * @return {Array<C>}\n */\nexport const create = () => /** @type {Array<C>} */ ([])\n\n/**\n * @template D\n * @param {Array<D>} a\n * @return {Array<D>}\n */\nexport const copy = a => /** @type {Array<D>} */ (a.slice())\n\n/**\n * Append elements from src to dest\n *\n * @template M\n * @param {Array<M>} dest\n * @param {Array<M>} src\n */\nexport const appendTo = (dest, src) => {\n  for (let i = 0; i < src.length; i++) {\n    dest.push(src[i])\n  }\n}\n\n/**\n * Transforms something array-like to an actual Array.\n *\n * @function\n * @template T\n * @param {ArrayLike<T>|Iterable<T>} arraylike\n * @return {T}\n */\nexport const from = Array.from\n\n/**\n * True iff condition holds on every element in the Array.\n *\n * @function\n * @template ITEM\n * @template {ArrayLike<ITEM>} ARR\n *\n * @param {ARR} arr\n * @param {function(ITEM, number, ARR):boolean} f\n * @return {boolean}\n */\nexport const every = (arr, f) => {\n  for (let i = 0; i < arr.length; i++) {\n    if (!f(arr[i], i, arr)) {\n      return false\n    }\n  }\n  return true\n}\n\n/**\n * True iff condition holds on some element in the Array.\n *\n * @function\n * @template S\n * @template {ArrayLike<S>} ARR\n * @param {ARR} arr\n * @param {function(S, number, ARR):boolean} f\n * @return {boolean}\n */\nexport const some = (arr, f) => {\n  for (let i = 0; i < arr.length; i++) {\n    if (f(arr[i], i, arr)) {\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * @template ELEM\n *\n * @param {ArrayLike<ELEM>} a\n * @param {ArrayLike<ELEM>} b\n * @return {boolean}\n */\nexport const equalFlat = (a, b) => a.length === b.length && every(a, (item, index) => item === b[index])\n\n/**\n * @template ELEM\n * @param {Array<Array<ELEM>>} arr\n * @return {Array<ELEM>}\n */\nexport const flatten = arr => fold(arr, /** @type {Array<ELEM>} */ ([]), (acc, val) => acc.concat(val))\n\n/**\n * @template T\n * @param {number} len\n * @param {function(number, Array<T>):T} f\n * @return {Array<T>}\n */\nexport const unfold = (len, f) => {\n  const array = new Array(len)\n  for (let i = 0; i < len; i++) {\n    array[i] = f(i, array)\n  }\n  return array\n}\n\n/**\n * @template T\n * @template RESULT\n * @param {Array<T>} arr\n * @param {RESULT} seed\n * @param {function(RESULT, T, number):RESULT} folder\n */\nexport const fold = (arr, seed, folder) => arr.reduce(folder, seed)\n\nexport const isArray = Array.isArray\n\n/**\n * @template T\n * @param {Array<T>} arr\n * @return {Array<T>}\n */\nexport const unique = arr => from(set.from(arr))\n\n/**\n * @template T\n * @template M\n * @param {ArrayLike<T>} arr\n * @param {function(T):M} mapper\n * @return {Array<T>}\n */\nexport const uniqueBy = (arr, mapper) => {\n  /**\n   * @type {Set<M>}\n   */\n  const happened = set.create()\n  /**\n   * @type {Array<T>}\n   */\n  const result = []\n  for (let i = 0; i < arr.length; i++) {\n    const el = arr[i]\n    const mapped = mapper(el)\n    if (!happened.has(mapped)) {\n      happened.add(mapped)\n      result.push(el)\n    }\n  }\n  return result\n}\n\n/**\n * @template {ArrayLike<any>} ARR\n * @template {function(ARR extends ArrayLike<infer T> ? T : never, number, ARR):any} MAPPER\n * @param {ARR} arr\n * @param {MAPPER} mapper\n * @return {Array<MAPPER extends function(...any): infer M ? M : never>}\n */\nexport const map = (arr, mapper) => {\n  /**\n   * @type {Array<any>}\n   */\n  const res = Array(arr.length)\n  for (let i = 0; i < arr.length; i++) {\n    res[i] = mapper(/** @type {any} */ (arr[i]), i, /** @type {any} */ (arr))\n  }\n  return /** @type {any} */ (res)\n}\n","/**\n * Observable class prototype.\n *\n * @module observable\n */\n\nimport * as map from './map.js'\nimport * as set from './set.js'\nimport * as array from './array.js'\n\n/**\n * Handles named events.\n *\n * @template N\n */\nexport class Observable {\n  constructor () {\n    /**\n     * Some desc.\n     * @type {Map<N, any>}\n     */\n    this._observers = map.create()\n  }\n\n  /**\n   * @param {N} name\n   * @param {function} f\n   */\n  on (name, f) {\n    map.setIfUndefined(this._observers, name, set.create).add(f)\n  }\n\n  /**\n   * @param {N} name\n   * @param {function} f\n   */\n  once (name, f) {\n    /**\n     * @param  {...any} args\n     */\n    const _f = (...args) => {\n      this.off(name, _f)\n      f(...args)\n    }\n    this.on(name, _f)\n  }\n\n  /**\n   * @param {N} name\n   * @param {function} f\n   */\n  off (name, f) {\n    const observers = this._observers.get(name)\n    if (observers !== undefined) {\n      observers.delete(f)\n      if (observers.size === 0) {\n        this._observers.delete(name)\n      }\n    }\n  }\n\n  /**\n   * Emit a named event. All registered event listeners that listen to the\n   * specified name will receive the event.\n   *\n   * @todo This should catch exceptions\n   *\n   * @param {N} name The event name.\n   * @param {Array<any>} args The arguments that are applied to the event listener.\n   */\n  emit (name, args) {\n    // copy all listeners to an array first to make sure that no event is emitted to listeners that are subscribed while the event handler is called.\n    return array.from((this._observers.get(name) || map.create()).values()).forEach(f => f(...args))\n  }\n\n  destroy () {\n    this._observers = map.create()\n  }\n}\n","/**\n * Common Math expressions.\n *\n * @module math\n */\n\nexport const floor = Math.floor\nexport const ceil = Math.ceil\nexport const abs = Math.abs\nexport const imul = Math.imul\nexport const round = Math.round\nexport const log10 = Math.log10\nexport const log2 = Math.log2\nexport const log = Math.log\nexport const sqrt = Math.sqrt\n\n/**\n * @function\n * @param {number} a\n * @param {number} b\n * @return {number} The sum of a and b\n */\nexport const add = (a, b) => a + b\n\n/**\n * @function\n * @param {number} a\n * @param {number} b\n * @return {number} The smaller element of a and b\n */\nexport const min = (a, b) => a < b ? a : b\n\n/**\n * @function\n * @param {number} a\n * @param {number} b\n * @return {number} The bigger element of a and b\n */\nexport const max = (a, b) => a > b ? a : b\n\nexport const isNaN = Number.isNaN\n\nexport const pow = Math.pow\n/**\n * Base 10 exponential function. Returns the value of 10 raised to the power of pow.\n *\n * @param {number} exp\n * @return {number}\n */\nexport const exp10 = exp => Math.pow(10, exp)\n\nexport const sign = Math.sign\n\n/**\n * @param {number} n\n * @return {boolean} Wether n is negative. This function also differentiates between -0 and +0\n */\nexport const isNegativeZero = n => n !== 0 ? n < 0 : 1 / n < 0\n","import * as array from './array.js'\n\n/**\n * Utility module to work with strings.\n *\n * @module string\n */\n\nexport const fromCharCode = String.fromCharCode\nexport const fromCodePoint = String.fromCodePoint\n\n/**\n * The largest utf16 character.\n * Corresponds to Uint8Array([255, 255]) or charcodeof(2x2^8)\n */\nexport const MAX_UTF16_CHARACTER = fromCharCode(65535)\n\n/**\n * @param {string} s\n * @return {string}\n */\nconst toLowerCase = s => s.toLowerCase()\n\nconst trimLeftRegex = /^\\s*/g\n\n/**\n * @param {string} s\n * @return {string}\n */\nexport const trimLeft = s => s.replace(trimLeftRegex, '')\n\nconst fromCamelCaseRegex = /([A-Z])/g\n\n/**\n * @param {string} s\n * @param {string} separator\n * @return {string}\n */\nexport const fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, match => `${separator}${toLowerCase(match)}`))\n\n/**\n * Compute the utf8ByteLength\n * @param {string} str\n * @return {number}\n */\nexport const utf8ByteLength = str => unescape(encodeURIComponent(str)).length\n\n/**\n * @param {string} str\n * @return {Uint8Array}\n */\nexport const _encodeUtf8Polyfill = str => {\n  const encodedString = unescape(encodeURIComponent(str))\n  const len = encodedString.length\n  const buf = new Uint8Array(len)\n  for (let i = 0; i < len; i++) {\n    buf[i] = /** @type {number} */ (encodedString.codePointAt(i))\n  }\n  return buf\n}\n\n/* c8 ignore next */\nexport const utf8TextEncoder = /** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null)\n\n/**\n * @param {string} str\n * @return {Uint8Array}\n */\nexport const _encodeUtf8Native = str => utf8TextEncoder.encode(str)\n\n/**\n * @param {string} str\n * @return {Uint8Array}\n */\n/* c8 ignore next */\nexport const encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill\n\n/**\n * @param {Uint8Array} buf\n * @return {string}\n */\nexport const _decodeUtf8Polyfill = buf => {\n  let remainingLen = buf.length\n  let encodedString = ''\n  let bufPos = 0\n  while (remainingLen > 0) {\n    const nextLen = remainingLen < 10000 ? remainingLen : 10000\n    const bytes = buf.subarray(bufPos, bufPos + nextLen)\n    bufPos += nextLen\n    // Starting with ES5.1 we can supply a generic array-like object as arguments\n    encodedString += String.fromCodePoint.apply(null, /** @type {any} */ (bytes))\n    remainingLen -= nextLen\n  }\n  return decodeURIComponent(escape(encodedString))\n}\n\n/* c8 ignore next */\nexport let utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true })\n\n/* c8 ignore start */\nif (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {\n  // Safari doesn't handle BOM correctly.\n  // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.\n  // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and\n  // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call\n  // Another issue is that from then on no BOM chars are recognized anymore\n  /* c8 ignore next */\n  utf8TextDecoder = null\n}\n/* c8 ignore stop */\n\n/**\n * @param {Uint8Array} buf\n * @return {string}\n */\nexport const _decodeUtf8Native = buf => /** @type {TextDecoder} */ (utf8TextDecoder).decode(buf)\n\n/**\n * @param {Uint8Array} buf\n * @return {string}\n */\n/* c8 ignore next */\nexport const decodeUtf8 = utf8TextDecoder ? _decodeUtf8Native : _decodeUtf8Polyfill\n\n/**\n * @param {string} str The initial string\n * @param {number} index Starting position\n * @param {number} remove Number of characters to remove\n * @param {string} insert New content to insert\n */\nexport const splice = (str, index, remove, insert = '') => str.slice(0, index) + insert + str.slice(index + remove)\n\n/**\n * @param {string} source\n * @param {number} n\n */\nexport const repeat = (source, n) => array.unfold(n, () => source).join('')\n","/* eslint-env browser */\n\n/**\n * Isomorphic variable storage.\n *\n * Uses LocalStorage in the browser and falls back to in-memory storage.\n *\n * @module storage\n */\n\n/* c8 ignore start */\nclass VarStoragePolyfill {\n  constructor () {\n    this.map = new Map()\n  }\n\n  /**\n   * @param {string} key\n   * @param {any} newValue\n   */\n  setItem (key, newValue) {\n    this.map.set(key, newValue)\n  }\n\n  /**\n   * @param {string} key\n   */\n  getItem (key) {\n    return this.map.get(key)\n  }\n}\n/* c8 ignore stop */\n\n/**\n * @type {any}\n */\nlet _localStorage = new VarStoragePolyfill()\nlet usePolyfill = true\n\n/* c8 ignore start */\ntry {\n  // if the same-origin rule is violated, accessing localStorage might thrown an error\n  if (typeof localStorage !== 'undefined') {\n    _localStorage = localStorage\n    usePolyfill = false\n  }\n} catch (e) { }\n/* c8 ignore stop */\n\n/**\n * This is basically localStorage in browser, or a polyfill in nodejs\n */\n/* c8 ignore next */\nexport const varStorage = _localStorage\n\n/**\n * A polyfill for `addEventListener('storage', event => {..})` that does nothing if the polyfill is being used.\n *\n * @param {function({ key: string, newValue: string, oldValue: string }): void} eventHandler\n * @function\n */\n/* c8 ignore next */\nexport const onChange = eventHandler => usePolyfill || addEventListener('storage', /** @type {any} */ (eventHandler))\n\n/**\n * A polyfill for `removeEventListener('storage', event => {..})` that does nothing if the polyfill is being used.\n *\n * @param {function({ key: string, newValue: string, oldValue: string }): void} eventHandler\n * @function\n */\n/* c8 ignore next */\nexport const offChange = eventHandler => usePolyfill || removeEventListener('storage', /** @type {any} */ (eventHandler))\n","/**\n * Utility functions for working with EcmaScript objects.\n *\n * @module object\n */\n\n/**\n * @return {Object<string,any>} obj\n */\nexport const create = () => Object.create(null)\n\n/**\n * Object.assign\n */\nexport const assign = Object.assign\n\n/**\n * @param {Object<string,any>} obj\n */\nexport const keys = Object.keys\n\n/**\n * @template V\n * @param {{[k:string]:V}} obj\n * @param {function(V,string):any} f\n */\nexport const forEach = (obj, f) => {\n  for (const key in obj) {\n    f(obj[key], key)\n  }\n}\n\n/**\n * @todo implement mapToArray & map\n *\n * @template R\n * @param {Object<string,any>} obj\n * @param {function(any,string):R} f\n * @return {Array<R>}\n */\nexport const map = (obj, f) => {\n  const results = []\n  for (const key in obj) {\n    results.push(f(obj[key], key))\n  }\n  return results\n}\n\n/**\n * @param {Object<string,any>} obj\n * @return {number}\n */\nexport const length = obj => keys(obj).length\n\n/**\n * @param {Object<string,any>} obj\n * @param {function(any,string):boolean} f\n * @return {boolean}\n */\nexport const some = (obj, f) => {\n  for (const key in obj) {\n    if (f(obj[key], key)) {\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * @param {Object|undefined} obj\n */\nexport const isEmpty = obj => {\n  // eslint-disable-next-line\n  for (const _k in obj) {\n    return false\n  }\n  return true\n}\n\n/**\n * @param {Object<string,any>} obj\n * @param {function(any,string):boolean} f\n * @return {boolean}\n */\nexport const every = (obj, f) => {\n  for (const key in obj) {\n    if (!f(obj[key], key)) {\n      return false\n    }\n  }\n  return true\n}\n\n/**\n * Calls `Object.prototype.hasOwnProperty`.\n *\n * @param {any} obj\n * @param {string|symbol} key\n * @return {boolean}\n */\nexport const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key)\n\n/**\n * @param {Object<string,any>} a\n * @param {Object<string,any>} b\n * @return {boolean}\n */\nexport const equalFlat = (a, b) => a === b || (length(a) === length(b) && every(a, (val, key) => (val !== undefined || hasProperty(b, key)) && b[key] === val))\n","/**\n * Common functions and function call helpers.\n *\n * @module function\n */\n\nimport * as array from './array.js'\nimport * as object from './object.js'\n\n/**\n * Calls all functions in `fs` with args. Only throws after all functions were called.\n *\n * @param {Array<function>} fs\n * @param {Array<any>} args\n */\nexport const callAll = (fs, args, i = 0) => {\n  try {\n    for (; i < fs.length; i++) {\n      fs[i](...args)\n    }\n  } finally {\n    if (i < fs.length) {\n      callAll(fs, args, i + 1)\n    }\n  }\n}\n\nexport const nop = () => {}\n\n/**\n * @template T\n * @param {function():T} f\n * @return {T}\n */\nexport const apply = f => f()\n\n/**\n * @template A\n *\n * @param {A} a\n * @return {A}\n */\nexport const id = a => a\n\n/**\n * @template T\n *\n * @param {T} a\n * @param {T} b\n * @return {boolean}\n */\nexport const equalityStrict = (a, b) => a === b\n\n/**\n * @template T\n *\n * @param {Array<T>|object} a\n * @param {Array<T>|object} b\n * @return {boolean}\n */\nexport const equalityFlat = (a, b) => a === b || (a != null && b != null && a.constructor === b.constructor && ((array.isArray(a) && array.equalFlat(a, /** @type {Array<T>} */ (b))) || (typeof a === 'object' && object.equalFlat(a, b))))\n\n/* c8 ignore start */\n\n/**\n * @param {any} a\n * @param {any} b\n * @return {boolean}\n */\nexport const equalityDeep = (a, b) => {\n  if (a == null || b == null) {\n    return equalityStrict(a, b)\n  }\n  if (a.constructor !== b.constructor) {\n    return false\n  }\n  if (a === b) {\n    return true\n  }\n  switch (a.constructor) {\n    case ArrayBuffer:\n      a = new Uint8Array(a)\n      b = new Uint8Array(b)\n    // eslint-disable-next-line no-fallthrough\n    case Uint8Array: {\n      if (a.byteLength !== b.byteLength) {\n        return false\n      }\n      for (let i = 0; i < a.length; i++) {\n        if (a[i] !== b[i]) {\n          return false\n        }\n      }\n      break\n    }\n    case Set: {\n      if (a.size !== b.size) {\n        return false\n      }\n      for (const value of a) {\n        if (!b.has(value)) {\n          return false\n        }\n      }\n      break\n    }\n    case Map: {\n      if (a.size !== b.size) {\n        return false\n      }\n      for (const key of a.keys()) {\n        if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {\n          return false\n        }\n      }\n      break\n    }\n    case Object:\n      if (object.length(a) !== object.length(b)) {\n        return false\n      }\n      for (const key in a) {\n        if (!object.hasProperty(a, key) || !equalityDeep(a[key], b[key])) {\n          return false\n        }\n      }\n      break\n    case Array:\n      if (a.length !== b.length) {\n        return false\n      }\n      for (let i = 0; i < a.length; i++) {\n        if (!equalityDeep(a[i], b[i])) {\n          return false\n        }\n      }\n      break\n    default:\n      return false\n  }\n  return true\n}\n\n/**\n * @template V\n * @template {V} OPTS\n *\n * @param {V} value\n * @param {Array<OPTS>} options\n */\n// @ts-ignore\nexport const isOneOf = (value, options) => options.includes(value)\n/* c8 ignore stop */\n\nexport const isArray = array.isArray\n\n/**\n * @param {any} s\n * @return {s is String}\n */\nexport const isString = (s) => s && s.constructor === String\n\n/**\n * @param {any} n\n * @return {n is Number}\n */\nexport const isNumber = n => n != null && n.constructor === Number\n\n/**\n * @template {abstract new (...args: any) => any} TYPE\n * @param {any} n\n * @param {TYPE} T\n * @return {n is InstanceType<TYPE>}\n */\nexport const is = (n, T) => n && n.constructor === T\n\n/**\n * @template {abstract new (...args: any) => any} TYPE\n * @param {TYPE} T\n */\nexport const isTemplate = (T) =>\n  /**\n   * @param {any} n\n   * @return {n is InstanceType<TYPE>}\n   **/\n  n => n && n.constructor === T\n","/**\n * Isomorphic module to work access the environment (query params, env variables).\n *\n * @module map\n */\n\nimport * as map from './map.js'\nimport * as string from './string.js'\nimport * as conditions from './conditions.js'\nimport * as storage from './storage.js'\nimport * as f from './function.js'\n\n/* c8 ignore next */\n// @ts-ignore\nexport const isNode = typeof process !== 'undefined' && process.release &&\n  /node|io\\.js/.test(process.release.name)\n/* c8 ignore next */\nexport const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && !isNode\n/* c8 ignore next 3 */\nexport const isMac = typeof navigator !== 'undefined'\n  ? /Mac/.test(navigator.platform)\n  : false\n\n/**\n * @type {Map<string,string>}\n */\nlet params\nconst args = []\n\n/* c8 ignore start */\nconst computeParams = () => {\n  if (params === undefined) {\n    if (isNode) {\n      params = map.create()\n      const pargs = process.argv\n      let currParamName = null\n      for (let i = 0; i < pargs.length; i++) {\n        const parg = pargs[i]\n        if (parg[0] === '-') {\n          if (currParamName !== null) {\n            params.set(currParamName, '')\n          }\n          currParamName = parg\n        } else {\n          if (currParamName !== null) {\n            params.set(currParamName, parg)\n            currParamName = null\n          } else {\n            args.push(parg)\n          }\n        }\n      }\n      if (currParamName !== null) {\n        params.set(currParamName, '')\n      }\n      // in ReactNative for example this would not be true (unless connected to the Remote Debugger)\n    } else if (typeof location === 'object') {\n      params = map.create(); // eslint-disable-next-line no-undef\n      (location.search || '?').slice(1).split('&').forEach((kv) => {\n        if (kv.length !== 0) {\n          const [key, value] = kv.split('=')\n          params.set(`--${string.fromCamelCase(key, '-')}`, value)\n          params.set(`-${string.fromCamelCase(key, '-')}`, value)\n        }\n      })\n    } else {\n      params = map.create()\n    }\n  }\n  return params\n}\n/* c8 ignore stop */\n\n/**\n * @param {string} name\n * @return {boolean}\n */\n/* c8 ignore next */\nexport const hasParam = (name) => computeParams().has(name)\n\n/**\n * @param {string} name\n * @param {string} defaultVal\n * @return {string}\n */\n/* c8 ignore next 2 */\nexport const getParam = (name, defaultVal) =>\n  computeParams().get(name) || defaultVal\n\n/**\n * @param {string} name\n * @return {string|null}\n */\n/* c8 ignore next 4 */\nexport const getVariable = (name) =>\n  isNode\n    ? conditions.undefinedToNull(process.env[name.toUpperCase()])\n    : conditions.undefinedToNull(storage.varStorage.getItem(name))\n\n/**\n * @param {string} name\n * @return {string|null}\n */\n/* c8 ignore next 2 */\nexport const getConf = (name) =>\n  computeParams().get('--' + name) || getVariable(name)\n\n/**\n * @param {string} name\n * @return {boolean}\n */\n/* c8 ignore next 2 */\nexport const hasConf = (name) =>\n  hasParam('--' + name) || getVariable(name) !== null\n\n/* c8 ignore next */\nexport const production = hasConf('production')\n\n/* c8 ignore next 2 */\nconst forceColor = isNode &&\n  f.isOneOf(process.env.FORCE_COLOR, ['true', '1', '2'])\n\n/* c8 ignore start */\nexport const supportsColor = !hasParam('no-colors') &&\n  (!isNode || process.stdout.isTTY || forceColor) && (\n  !isNode || hasParam('color') || forceColor ||\n    getVariable('COLORTERM') !== null ||\n    (getVariable('TERM') || '').includes('color')\n)\n/* c8 ignore stop */\n","/**\n * Often used conditions.\n *\n * @module conditions\n */\n\n/**\n * @template T\n * @param {T|null|undefined} v\n * @return {T|null}\n */\n/* c8 ignore next */\nexport const undefinedToNull = v => v === undefined ? null : v\n","/**\n * Utility functions to work with buffers (Uint8Array).\n *\n * @module buffer\n */\n\nimport * as string from './string.js'\nimport * as env from './environment.js'\nimport * as array from './array.js'\nimport * as math from './math.js'\nimport * as encoding from './encoding.js'\nimport * as decoding from './decoding.js'\n\n/**\n * @param {number} len\n */\nexport const createUint8ArrayFromLen = len => new Uint8Array(len)\n\n/**\n * Create Uint8Array with initial content from buffer\n *\n * @param {ArrayBuffer} buffer\n * @param {number} byteOffset\n * @param {number} length\n */\nexport const createUint8ArrayViewFromArrayBuffer = (buffer, byteOffset, length) => new Uint8Array(buffer, byteOffset, length)\n\n/**\n * Create Uint8Array with initial content from buffer\n *\n * @param {ArrayBuffer} buffer\n */\nexport const createUint8ArrayFromArrayBuffer = buffer => new Uint8Array(buffer)\n\n/* c8 ignore start */\n/**\n * @param {Uint8Array} bytes\n * @return {string}\n */\nconst toBase64Browser = bytes => {\n  let s = ''\n  for (let i = 0; i < bytes.byteLength; i++) {\n    s += string.fromCharCode(bytes[i])\n  }\n  // eslint-disable-next-line no-undef\n  return btoa(s)\n}\n/* c8 ignore stop */\n\n/**\n * @param {Uint8Array} bytes\n * @return {string}\n */\nconst toBase64Node = bytes => Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('base64')\n\n/* c8 ignore start */\n/**\n * @param {string} s\n * @return {Uint8Array}\n */\nconst fromBase64Browser = s => {\n  // eslint-disable-next-line no-undef\n  const a = atob(s)\n  const bytes = createUint8ArrayFromLen(a.length)\n  for (let i = 0; i < a.length; i++) {\n    bytes[i] = a.charCodeAt(i)\n  }\n  return bytes\n}\n/* c8 ignore stop */\n\n/**\n * @param {string} s\n */\nconst fromBase64Node = s => {\n  const buf = Buffer.from(s, 'base64')\n  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength)\n}\n\n/* c8 ignore next */\nexport const toBase64 = env.isBrowser ? toBase64Browser : toBase64Node\n\n/* c8 ignore next */\nexport const fromBase64 = env.isBrowser ? fromBase64Browser : fromBase64Node\n\n/**\n * Base64 is always a more efficient choice. This exists for utility purposes only.\n *\n * @param {Uint8Array} buf\n */\nexport const toHexString = buf => array.map(buf, b => b.toString(16).padStart(2, '0')).join('')\n\n/**\n * Note: This function expects that the hex doesn't start with 0x..\n *\n * @param {string} hex\n */\nexport const fromHexString = hex => {\n  const hlen = hex.length\n  const buf = new Uint8Array(math.ceil(hlen / 2))\n  for (let i = 0; i < hlen; i += 2) {\n    buf[buf.length - i / 2 - 1] = Number.parseInt(hex.slice(hlen - i - 2, hlen - i), 16)\n  }\n  return buf\n}\n\n/**\n * Copy the content of an Uint8Array view to a new ArrayBuffer.\n *\n * @param {Uint8Array} uint8Array\n * @return {Uint8Array}\n */\nexport const copyUint8Array = uint8Array => {\n  const newBuf = createUint8ArrayFromLen(uint8Array.byteLength)\n  newBuf.set(uint8Array)\n  return newBuf\n}\n\n/**\n * Encode anything as a UInt8Array. It's a pun on typescripts's `any` type.\n * See encoding.writeAny for more information.\n *\n * @param {any} data\n * @return {Uint8Array}\n */\nexport const encodeAny = data => {\n  const encoder = encoding.createEncoder()\n  encoding.writeAny(encoder, data)\n  return encoding.toUint8Array(encoder)\n}\n\n/**\n * Decode an any-encoded value.\n *\n * @param {Uint8Array} buf\n * @return {any}\n */\nexport const decodeAny = buf => decoding.readAny(decoding.createDecoder(buf))\n\n/**\n * Shift Byte Array {N} bits to the left. Does not expand byte array.\n *\n * @param {Uint8Array} bs\n * @param {number} N should be in the range of [0-7]\n */\nexport const shiftNBitsLeft = (bs, N) => {\n  if (N === 0) return bs\n  bs = new Uint8Array(bs)\n  bs[0] <<= N\n  for (let i = 1; i < bs.length; i++) {\n    bs[i - 1] |= bs[i] >>> (8 - N)\n    bs[i] <<= N\n  }\n  return bs\n}\n","/* eslint-env browser */\n\n/**\n * Binary data constants.\n *\n * @module binary\n */\n\n/**\n * n-th bit activated.\n *\n * @type {number}\n */\nexport const BIT1 = 1\nexport const BIT2 = 2\nexport const BIT3 = 4\nexport const BIT4 = 8\nexport const BIT5 = 16\nexport const BIT6 = 32\nexport const BIT7 = 64\nexport const BIT8 = 128\nexport const BIT9 = 256\nexport const BIT10 = 512\nexport const BIT11 = 1024\nexport const BIT12 = 2048\nexport const BIT13 = 4096\nexport const BIT14 = 8192\nexport const BIT15 = 16384\nexport const BIT16 = 32768\nexport const BIT17 = 65536\nexport const BIT18 = 1 << 17\nexport const BIT19 = 1 << 18\nexport const BIT20 = 1 << 19\nexport const BIT21 = 1 << 20\nexport const BIT22 = 1 << 21\nexport const BIT23 = 1 << 22\nexport const BIT24 = 1 << 23\nexport const BIT25 = 1 << 24\nexport const BIT26 = 1 << 25\nexport const BIT27 = 1 << 26\nexport const BIT28 = 1 << 27\nexport const BIT29 = 1 << 28\nexport const BIT30 = 1 << 29\nexport const BIT31 = 1 << 30\nexport const BIT32 = 1 << 31\n\n/**\n * First n bits activated.\n *\n * @type {number}\n */\nexport const BITS0 = 0\nexport const BITS1 = 1\nexport const BITS2 = 3\nexport const BITS3 = 7\nexport const BITS4 = 15\nexport const BITS5 = 31\nexport const BITS6 = 63\nexport const BITS7 = 127\nexport const BITS8 = 255\nexport const BITS9 = 511\nexport const BITS10 = 1023\nexport const BITS11 = 2047\nexport const BITS12 = 4095\nexport const BITS13 = 8191\nexport const BITS14 = 16383\nexport const BITS15 = 32767\nexport const BITS16 = 65535\nexport const BITS17 = BIT18 - 1\nexport const BITS18 = BIT19 - 1\nexport const BITS19 = BIT20 - 1\nexport const BITS20 = BIT21 - 1\nexport const BITS21 = BIT22 - 1\nexport const BITS22 = BIT23 - 1\nexport const BITS23 = BIT24 - 1\nexport const BITS24 = BIT25 - 1\nexport const BITS25 = BIT26 - 1\nexport const BITS26 = BIT27 - 1\nexport const BITS27 = BIT28 - 1\nexport const BITS28 = BIT29 - 1\nexport const BITS29 = BIT30 - 1\nexport const BITS30 = BIT31 - 1\n/**\n * @type {number}\n */\nexport const BITS31 = 0x7FFFFFFF\n/**\n * @type {number}\n */\nexport const BITS32 = 0xFFFFFFFF\n","/**\n * Utility helpers for working with numbers.\n *\n * @module number\n */\n\nimport * as math from './math.js'\nimport * as binary from './binary.js'\n\nexport const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER\nexport const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER\n\nexport const LOWEST_INT32 = 1 << 31\nexport const HIGHEST_INT32 = binary.BITS31\nexport const HIGHEST_UINT32 = binary.BITS32\n\n/* c8 ignore next */\nexport const isInteger = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && math.floor(num) === num)\nexport const isNaN = Number.isNaN\nexport const parseInt = Number.parseInt\n\n/**\n * Count the number of \"1\" bits in an unsigned 32bit number.\n *\n * Super fun bitcount algorithm by Brian Kernighan.\n *\n * @param {number} n\n */\nexport const countBits = n => {\n  n &= binary.BITS32\n  let count = 0\n  while (n) {\n    n &= (n - 1)\n    count++\n  }\n  return count\n}\n","/**\n * Efficient schema-less binary encoding with support for variable length encoding.\n *\n * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.\n *\n * Encodes numbers in little-endian order (least to most significant byte order)\n * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)\n * which is also used in Protocol Buffers.\n *\n * ```js\n * // encoding step\n * const encoder = encoding.createEncoder()\n * encoding.writeVarUint(encoder, 256)\n * encoding.writeVarString(encoder, 'Hello world!')\n * const buf = encoding.toUint8Array(encoder)\n * ```\n *\n * ```js\n * // decoding step\n * const decoder = decoding.createDecoder(buf)\n * decoding.readVarUint(decoder) // => 256\n * decoding.readVarString(decoder) // => 'Hello world!'\n * decoding.hasContent(decoder) // => false - all data is read\n * ```\n *\n * @module encoding\n */\n\nimport * as buffer from './buffer.js'\nimport * as math from './math.js'\nimport * as number from './number.js'\nimport * as binary from './binary.js'\nimport * as string from './string.js'\nimport * as array from './array.js'\n\n/**\n * A BinaryEncoder handles the encoding to an Uint8Array.\n */\nexport class Encoder {\n  constructor () {\n    this.cpos = 0\n    this.cbuf = new Uint8Array(100)\n    /**\n     * @type {Array<Uint8Array>}\n     */\n    this.bufs = []\n  }\n}\n\n/**\n * @function\n * @return {Encoder}\n */\nexport const createEncoder = () => new Encoder()\n\n/**\n * @param {function(Encoder):void} f\n */\nexport const encode = (f) => {\n  const encoder = createEncoder()\n  f(encoder)\n  return toUint8Array(encoder)\n}\n\n/**\n * The current length of the encoded data.\n *\n * @function\n * @param {Encoder} encoder\n * @return {number}\n */\nexport const length = encoder => {\n  let len = encoder.cpos\n  for (let i = 0; i < encoder.bufs.length; i++) {\n    len += encoder.bufs[i].length\n  }\n  return len\n}\n\n/**\n * Check whether encoder is empty.\n *\n * @function\n * @param {Encoder} encoder\n * @return {boolean}\n */\nexport const hasContent = encoder => encoder.cpos > 0 || encoder.bufs.length > 0\n\n/**\n * Transform to Uint8Array.\n *\n * @function\n * @param {Encoder} encoder\n * @return {Uint8Array} The created ArrayBuffer.\n */\nexport const toUint8Array = encoder => {\n  const uint8arr = new Uint8Array(length(encoder))\n  let curPos = 0\n  for (let i = 0; i < encoder.bufs.length; i++) {\n    const d = encoder.bufs[i]\n    uint8arr.set(d, curPos)\n    curPos += d.length\n  }\n  uint8arr.set(buffer.createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos), curPos)\n  return uint8arr\n}\n\n/**\n * Verify that it is possible to write `len` bytes wtihout checking. If\n * necessary, a new Buffer with the required length is attached.\n *\n * @param {Encoder} encoder\n * @param {number} len\n */\nexport const verifyLen = (encoder, len) => {\n  const bufferLen = encoder.cbuf.length\n  if (bufferLen - encoder.cpos < len) {\n    encoder.bufs.push(buffer.createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos))\n    encoder.cbuf = new Uint8Array(math.max(bufferLen, len) * 2)\n    encoder.cpos = 0\n  }\n}\n\n/**\n * Write one byte to the encoder.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The byte that is to be encoded.\n */\nexport const write = (encoder, num) => {\n  const bufferLen = encoder.cbuf.length\n  if (encoder.cpos === bufferLen) {\n    encoder.bufs.push(encoder.cbuf)\n    encoder.cbuf = new Uint8Array(bufferLen * 2)\n    encoder.cpos = 0\n  }\n  encoder.cbuf[encoder.cpos++] = num\n}\n\n/**\n * Write one byte at a specific position.\n * Position must already be written (i.e. encoder.length > pos)\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} pos Position to which to write data\n * @param {number} num Unsigned 8-bit integer\n */\nexport const set = (encoder, pos, num) => {\n  let buffer = null\n  // iterate all buffers and adjust position\n  for (let i = 0; i < encoder.bufs.length && buffer === null; i++) {\n    const b = encoder.bufs[i]\n    if (pos < b.length) {\n      buffer = b // found buffer\n    } else {\n      pos -= b.length\n    }\n  }\n  if (buffer === null) {\n    // use current buffer\n    buffer = encoder.cbuf\n  }\n  buffer[pos] = num\n}\n\n/**\n * Write one byte as an unsigned integer.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The number that is to be encoded.\n */\nexport const writeUint8 = write\n\n/**\n * Write one byte as an unsigned Integer at a specific location.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} pos The location where the data will be written.\n * @param {number} num The number that is to be encoded.\n */\nexport const setUint8 = set\n\n/**\n * Write two bytes as an unsigned integer.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The number that is to be encoded.\n */\nexport const writeUint16 = (encoder, num) => {\n  write(encoder, num & binary.BITS8)\n  write(encoder, (num >>> 8) & binary.BITS8)\n}\n/**\n * Write two bytes as an unsigned integer at a specific location.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} pos The location where the data will be written.\n * @param {number} num The number that is to be encoded.\n */\nexport const setUint16 = (encoder, pos, num) => {\n  set(encoder, pos, num & binary.BITS8)\n  set(encoder, pos + 1, (num >>> 8) & binary.BITS8)\n}\n\n/**\n * Write two bytes as an unsigned integer\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The number that is to be encoded.\n */\nexport const writeUint32 = (encoder, num) => {\n  for (let i = 0; i < 4; i++) {\n    write(encoder, num & binary.BITS8)\n    num >>>= 8\n  }\n}\n\n/**\n * Write two bytes as an unsigned integer in big endian order.\n * (most significant byte first)\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The number that is to be encoded.\n */\nexport const writeUint32BigEndian = (encoder, num) => {\n  for (let i = 3; i >= 0; i--) {\n    write(encoder, (num >>> (8 * i)) & binary.BITS8)\n  }\n}\n\n/**\n * Write two bytes as an unsigned integer at a specific location.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} pos The location where the data will be written.\n * @param {number} num The number that is to be encoded.\n */\nexport const setUint32 = (encoder, pos, num) => {\n  for (let i = 0; i < 4; i++) {\n    set(encoder, pos + i, num & binary.BITS8)\n    num >>>= 8\n  }\n}\n\n/**\n * Write a variable length unsigned integer. Max encodable integer is 2^53.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The number that is to be encoded.\n */\nexport const writeVarUint = (encoder, num) => {\n  while (num > binary.BITS7) {\n    write(encoder, binary.BIT8 | (binary.BITS7 & num))\n    num = math.floor(num / 128) // shift >>> 7\n  }\n  write(encoder, binary.BITS7 & num)\n}\n\n/**\n * Write a variable length integer.\n *\n * We use the 7th bit instead for signaling that this is a negative number.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The number that is to be encoded.\n */\nexport const writeVarInt = (encoder, num) => {\n  const isNegative = math.isNegativeZero(num)\n  if (isNegative) {\n    num = -num\n  }\n  //             |- whether to continue reading         |- whether is negative     |- number\n  write(encoder, (num > binary.BITS6 ? binary.BIT8 : 0) | (isNegative ? binary.BIT7 : 0) | (binary.BITS6 & num))\n  num = math.floor(num / 64) // shift >>> 6\n  // We don't need to consider the case of num === 0 so we can use a different\n  // pattern here than above.\n  while (num > 0) {\n    write(encoder, (num > binary.BITS7 ? binary.BIT8 : 0) | (binary.BITS7 & num))\n    num = math.floor(num / 128) // shift >>> 7\n  }\n}\n\n/**\n * A cache to store strings temporarily\n */\nconst _strBuffer = new Uint8Array(30000)\nconst _maxStrBSize = _strBuffer.length / 3\n\n/**\n * Write a variable length string.\n *\n * @function\n * @param {Encoder} encoder\n * @param {String} str The string that is to be encoded.\n */\nexport const _writeVarStringNative = (encoder, str) => {\n  if (str.length < _maxStrBSize) {\n    // We can encode the string into the existing buffer\n    /* c8 ignore next */\n    const written = string.utf8TextEncoder.encodeInto(str, _strBuffer).written || 0\n    writeVarUint(encoder, written)\n    for (let i = 0; i < written; i++) {\n      write(encoder, _strBuffer[i])\n    }\n  } else {\n    writeVarUint8Array(encoder, string.encodeUtf8(str))\n  }\n}\n\n/**\n * Write a variable length string.\n *\n * @function\n * @param {Encoder} encoder\n * @param {String} str The string that is to be encoded.\n */\nexport const _writeVarStringPolyfill = (encoder, str) => {\n  const encodedString = unescape(encodeURIComponent(str))\n  const len = encodedString.length\n  writeVarUint(encoder, len)\n  for (let i = 0; i < len; i++) {\n    write(encoder, /** @type {number} */ (encodedString.codePointAt(i)))\n  }\n}\n\n/**\n * Write a variable length string.\n *\n * @function\n * @param {Encoder} encoder\n * @param {String} str The string that is to be encoded.\n */\n/* c8 ignore next */\nexport const writeVarString = (string.utf8TextEncoder && /** @type {any} */ (string.utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill\n\n/**\n * Write a string terminated by a special byte sequence. This is not very performant and is\n * generally discouraged. However, the resulting byte arrays are lexiographically ordered which\n * makes this a nice feature for databases.\n *\n * The string will be encoded using utf8 and then terminated and escaped using writeTerminatingUint8Array.\n *\n * @function\n * @param {Encoder} encoder\n * @param {String} str The string that is to be encoded.\n */\nexport const writeTerminatedString = (encoder, str) =>\n  writeTerminatedUint8Array(encoder, string.encodeUtf8(str))\n\n/**\n * Write a terminating Uint8Array. Note that this is not performant and is generally\n * discouraged. There are few situations when this is needed.\n *\n * We use 0x0 as a terminating character. 0x1 serves as an escape character for 0x0 and 0x1.\n *\n * Example: [0,1,2] is encoded to [1,0,1,1,2,0]. 0x0, and 0x1 needed to be escaped using 0x1. Then\n * the result is terminated using the 0x0 character.\n *\n * This is basically how many systems implement null terminated strings. However, we use an escape\n * character 0x1 to avoid issues and potenial attacks on our database (if this is used as a key\n * encoder for NoSql databases).\n *\n * @function\n * @param {Encoder} encoder\n * @param {Uint8Array} buf The string that is to be encoded.\n */\nexport const writeTerminatedUint8Array = (encoder, buf) => {\n  for (let i = 0; i < buf.length; i++) {\n    const b = buf[i]\n    if (b === 0 || b === 1) {\n      write(encoder, 1)\n    }\n    write(encoder, buf[i])\n  }\n  write(encoder, 0)\n}\n\n/**\n * Write the content of another Encoder.\n *\n * @TODO: can be improved!\n *        - Note: Should consider that when appending a lot of small Encoders, we should rather clone than referencing the old structure.\n *                Encoders start with a rather big initial buffer.\n *\n * @function\n * @param {Encoder} encoder The enUint8Arr\n * @param {Encoder} append The BinaryEncoder to be written.\n */\nexport const writeBinaryEncoder = (encoder, append) => writeUint8Array(encoder, toUint8Array(append))\n\n/**\n * Append fixed-length Uint8Array to the encoder.\n *\n * @function\n * @param {Encoder} encoder\n * @param {Uint8Array} uint8Array\n */\nexport const writeUint8Array = (encoder, uint8Array) => {\n  const bufferLen = encoder.cbuf.length\n  const cpos = encoder.cpos\n  const leftCopyLen = math.min(bufferLen - cpos, uint8Array.length)\n  const rightCopyLen = uint8Array.length - leftCopyLen\n  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos)\n  encoder.cpos += leftCopyLen\n  if (rightCopyLen > 0) {\n    // Still something to write, write right half..\n    // Append new buffer\n    encoder.bufs.push(encoder.cbuf)\n    // must have at least size of remaining buffer\n    encoder.cbuf = new Uint8Array(math.max(bufferLen * 2, rightCopyLen))\n    // copy array\n    encoder.cbuf.set(uint8Array.subarray(leftCopyLen))\n    encoder.cpos = rightCopyLen\n  }\n}\n\n/**\n * Append an Uint8Array to Encoder.\n *\n * @function\n * @param {Encoder} encoder\n * @param {Uint8Array} uint8Array\n */\nexport const writeVarUint8Array = (encoder, uint8Array) => {\n  writeVarUint(encoder, uint8Array.byteLength)\n  writeUint8Array(encoder, uint8Array)\n}\n\n/**\n * Create an DataView of the next `len` bytes. Use it to write data after\n * calling this function.\n *\n * ```js\n * // write float32 using DataView\n * const dv = writeOnDataView(encoder, 4)\n * dv.setFloat32(0, 1.1)\n * // read float32 using DataView\n * const dv = readFromDataView(encoder, 4)\n * dv.getFloat32(0) // => 1.100000023841858 (leaving it to the reader to find out why this is the correct result)\n * ```\n *\n * @param {Encoder} encoder\n * @param {number} len\n * @return {DataView}\n */\nexport const writeOnDataView = (encoder, len) => {\n  verifyLen(encoder, len)\n  const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len)\n  encoder.cpos += len\n  return dview\n}\n\n/**\n * @param {Encoder} encoder\n * @param {number} num\n */\nexport const writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false)\n\n/**\n * @param {Encoder} encoder\n * @param {number} num\n */\nexport const writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false)\n\n/**\n * @param {Encoder} encoder\n * @param {bigint} num\n */\nexport const writeBigInt64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigInt64(0, num, false)\n\n/**\n * @param {Encoder} encoder\n * @param {bigint} num\n */\nexport const writeBigUint64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigUint64(0, num, false)\n\nconst floatTestBed = new DataView(new ArrayBuffer(4))\n/**\n * Check if a number can be encoded as a 32 bit float.\n *\n * @param {number} num\n * @return {boolean}\n */\nconst isFloat32 = num => {\n  floatTestBed.setFloat32(0, num)\n  return floatTestBed.getFloat32(0) === num\n}\n\n/**\n * Encode data with efficient binary format.\n *\n * Differences to JSON:\n * • Transforms data to a binary format (not to a string)\n * • Encodes undefined, NaN, and ArrayBuffer (these can't be represented in JSON)\n * • Numbers are efficiently encoded either as a variable length integer, as a\n *   32 bit float, as a 64 bit float, or as a 64 bit bigint.\n *\n * Encoding table:\n *\n * | Data Type           | Prefix   | Encoding Method    | Comment |\n * | ------------------- | -------- | ------------------ | ------- |\n * | undefined           | 127      |                    | Functions, symbol, and everything that cannot be identified is encoded as undefined |\n * | null                | 126      |                    | |\n * | integer             | 125      | writeVarInt        | Only encodes 32 bit signed integers |\n * | float32             | 124      | writeFloat32       | |\n * | float64             | 123      | writeFloat64       | |\n * | bigint              | 122      | writeBigInt64      | |\n * | boolean (false)     | 121      |                    | True and false are different data types so we save the following byte |\n * | boolean (true)      | 120      |                    | - 0b01111000 so the last bit determines whether true or false |\n * | string              | 119      | writeVarString     | |\n * | object<string,any>  | 118      | custom             | Writes {length} then {length} key-value pairs |\n * | array<any>          | 117      | custom             | Writes {length} then {length} json values |\n * | Uint8Array          | 116      | writeVarUint8Array | We use Uint8Array for any kind of binary data |\n *\n * Reasons for the decreasing prefix:\n * We need the first bit for extendability (later we may want to encode the\n * prefix with writeVarUint). The remaining 7 bits are divided as follows:\n * [0-30]   the beginning of the data range is used for custom purposes\n *          (defined by the function that uses this library)\n * [31-127] the end of the data range is used for data encoding by\n *          lib0/encoding.js\n *\n * @param {Encoder} encoder\n * @param {undefined|null|number|bigint|boolean|string|Object<string,any>|Array<any>|Uint8Array} data\n */\nexport const writeAny = (encoder, data) => {\n  switch (typeof data) {\n    case 'string':\n      // TYPE 119: STRING\n      write(encoder, 119)\n      writeVarString(encoder, data)\n      break\n    case 'number':\n      if (number.isInteger(data) && math.abs(data) <= binary.BITS31) {\n        // TYPE 125: INTEGER\n        write(encoder, 125)\n        writeVarInt(encoder, data)\n      } else if (isFloat32(data)) {\n        // TYPE 124: FLOAT32\n        write(encoder, 124)\n        writeFloat32(encoder, data)\n      } else {\n        // TYPE 123: FLOAT64\n        write(encoder, 123)\n        writeFloat64(encoder, data)\n      }\n      break\n    case 'bigint':\n      // TYPE 122: BigInt\n      write(encoder, 122)\n      writeBigInt64(encoder, data)\n      break\n    case 'object':\n      if (data === null) {\n        // TYPE 126: null\n        write(encoder, 126)\n      } else if (array.isArray(data)) {\n        // TYPE 117: Array\n        write(encoder, 117)\n        writeVarUint(encoder, data.length)\n        for (let i = 0; i < data.length; i++) {\n          writeAny(encoder, data[i])\n        }\n      } else if (data instanceof Uint8Array) {\n        // TYPE 116: ArrayBuffer\n        write(encoder, 116)\n        writeVarUint8Array(encoder, data)\n      } else {\n        // TYPE 118: Object\n        write(encoder, 118)\n        const keys = Object.keys(data)\n        writeVarUint(encoder, keys.length)\n        for (let i = 0; i < keys.length; i++) {\n          const key = keys[i]\n          writeVarString(encoder, key)\n          writeAny(encoder, data[key])\n        }\n      }\n      break\n    case 'boolean':\n      // TYPE 120/121: boolean (true/false)\n      write(encoder, data ? 120 : 121)\n      break\n    default:\n      // TYPE 127: undefined\n      write(encoder, 127)\n  }\n}\n\n/**\n * Now come a few stateful encoder that have their own classes.\n */\n\n/**\n * Basic Run Length Encoder - a basic compression implementation.\n *\n * Encodes [1,1,1,7] to [1,3,7,1] (3 times 1, 1 time 7). This encoder might do more harm than good if there are a lot of values that are not repeated.\n *\n * It was originally used for image compression. Cool .. article http://csbruce.com/cbm/transactor/pdfs/trans_v7_i06.pdf\n *\n * @note T must not be null!\n *\n * @template T\n */\nexport class RleEncoder extends Encoder {\n  /**\n   * @param {function(Encoder, T):void} writer\n   */\n  constructor (writer) {\n    super()\n    /**\n     * The writer\n     */\n    this.w = writer\n    /**\n     * Current state\n     * @type {T|null}\n     */\n    this.s = null\n    this.count = 0\n  }\n\n  /**\n   * @param {T} v\n   */\n  write (v) {\n    if (this.s === v) {\n      this.count++\n    } else {\n      if (this.count > 0) {\n        // flush counter, unless this is the first value (count = 0)\n        writeVarUint(this, this.count - 1) // since count is always > 0, we can decrement by one. non-standard encoding ftw\n      }\n      this.count = 1\n      // write first value\n      this.w(this, v)\n      this.s = v\n    }\n  }\n}\n\n/**\n * Basic diff decoder using variable length encoding.\n *\n * Encodes the values [3, 1100, 1101, 1050, 0] to [3, 1097, 1, -51, -1050] using writeVarInt.\n */\nexport class IntDiffEncoder extends Encoder {\n  /**\n   * @param {number} start\n   */\n  constructor (start) {\n    super()\n    /**\n     * Current state\n     * @type {number}\n     */\n    this.s = start\n  }\n\n  /**\n   * @param {number} v\n   */\n  write (v) {\n    writeVarInt(this, v - this.s)\n    this.s = v\n  }\n}\n\n/**\n * A combination of IntDiffEncoder and RleEncoder.\n *\n * Basically first writes the IntDiffEncoder and then counts duplicate diffs using RleEncoding.\n *\n * Encodes the values [1,1,1,2,3,4,5,6] as [1,1,0,2,1,5] (RLE([1,0,0,1,1,1,1,1]) ⇒ RleIntDiff[1,1,0,2,1,5])\n */\nexport class RleIntDiffEncoder extends Encoder {\n  /**\n   * @param {number} start\n   */\n  constructor (start) {\n    super()\n    /**\n     * Current state\n     * @type {number}\n     */\n    this.s = start\n    this.count = 0\n  }\n\n  /**\n   * @param {number} v\n   */\n  write (v) {\n    if (this.s === v && this.count > 0) {\n      this.count++\n    } else {\n      if (this.count > 0) {\n        // flush counter, unless this is the first value (count = 0)\n        writeVarUint(this, this.count - 1) // since count is always > 0, we can decrement by one. non-standard encoding ftw\n      }\n      this.count = 1\n      // write first value\n      writeVarInt(this, v - this.s)\n      this.s = v\n    }\n  }\n}\n\n/**\n * @param {UintOptRleEncoder} encoder\n */\nconst flushUintOptRleEncoder = encoder => {\n  if (encoder.count > 0) {\n    // flush counter, unless this is the first value (count = 0)\n    // case 1: just a single value. set sign to positive\n    // case 2: write several values. set sign to negative to indicate that there is a length coming\n    writeVarInt(encoder.encoder, encoder.count === 1 ? encoder.s : -encoder.s)\n    if (encoder.count > 1) {\n      writeVarUint(encoder.encoder, encoder.count - 2) // since count is always > 1, we can decrement by one. non-standard encoding ftw\n    }\n  }\n}\n\n/**\n * Optimized Rle encoder that does not suffer from the mentioned problem of the basic Rle encoder.\n *\n * Internally uses VarInt encoder to write unsigned integers. If the input occurs multiple times, we write\n * write it as a negative number. The UintOptRleDecoder then understands that it needs to read a count.\n *\n * Encodes [1,2,3,3,3] as [1,2,-3,3] (once 1, once 2, three times 3)\n */\nexport class UintOptRleEncoder {\n  constructor () {\n    this.encoder = new Encoder()\n    /**\n     * @type {number}\n     */\n    this.s = 0\n    this.count = 0\n  }\n\n  /**\n   * @param {number} v\n   */\n  write (v) {\n    if (this.s === v) {\n      this.count++\n    } else {\n      flushUintOptRleEncoder(this)\n      this.count = 1\n      this.s = v\n    }\n  }\n\n  toUint8Array () {\n    flushUintOptRleEncoder(this)\n    return toUint8Array(this.encoder)\n  }\n}\n\n/**\n * Increasing Uint Optimized RLE Encoder\n *\n * The RLE encoder counts the number of same occurences of the same value.\n * The IncUintOptRle encoder counts if the value increases.\n * I.e. 7, 8, 9, 10 will be encoded as [-7, 4]. 1, 3, 5 will be encoded\n * as [1, 3, 5].\n */\nexport class IncUintOptRleEncoder {\n  constructor () {\n    this.encoder = new Encoder()\n    /**\n     * @type {number}\n     */\n    this.s = 0\n    this.count = 0\n  }\n\n  /**\n   * @param {number} v\n   */\n  write (v) {\n    if (this.s + this.count === v) {\n      this.count++\n    } else {\n      flushUintOptRleEncoder(this)\n      this.count = 1\n      this.s = v\n    }\n  }\n\n  toUint8Array () {\n    flushUintOptRleEncoder(this)\n    return toUint8Array(this.encoder)\n  }\n}\n\n/**\n * @param {IntDiffOptRleEncoder} encoder\n */\nconst flushIntDiffOptRleEncoder = encoder => {\n  if (encoder.count > 0) {\n    //          31 bit making up the diff | wether to write the counter\n    // const encodedDiff = encoder.diff << 1 | (encoder.count === 1 ? 0 : 1)\n    const encodedDiff = encoder.diff * 2 + (encoder.count === 1 ? 0 : 1)\n    // flush counter, unless this is the first value (count = 0)\n    // case 1: just a single value. set first bit to positive\n    // case 2: write several values. set first bit to negative to indicate that there is a length coming\n    writeVarInt(encoder.encoder, encodedDiff)\n    if (encoder.count > 1) {\n      writeVarUint(encoder.encoder, encoder.count - 2) // since count is always > 1, we can decrement by one. non-standard encoding ftw\n    }\n  }\n}\n\n/**\n * A combination of the IntDiffEncoder and the UintOptRleEncoder.\n *\n * The count approach is similar to the UintDiffOptRleEncoder, but instead of using the negative bitflag, it encodes\n * in the LSB whether a count is to be read. Therefore this Encoder only supports 31 bit integers!\n *\n * Encodes [1, 2, 3, 2] as [3, 1, 6, -1] (more specifically [(1 << 1) | 1, (3 << 0) | 0, -1])\n *\n * Internally uses variable length encoding. Contrary to normal UintVar encoding, the first byte contains:\n * * 1 bit that denotes whether the next value is a count (LSB)\n * * 1 bit that denotes whether this value is negative (MSB - 1)\n * * 1 bit that denotes whether to continue reading the variable length integer (MSB)\n *\n * Therefore, only five bits remain to encode diff ranges.\n *\n * Use this Encoder only when appropriate. In most cases, this is probably a bad idea.\n */\nexport class IntDiffOptRleEncoder {\n  constructor () {\n    this.encoder = new Encoder()\n    /**\n     * @type {number}\n     */\n    this.s = 0\n    this.count = 0\n    this.diff = 0\n  }\n\n  /**\n   * @param {number} v\n   */\n  write (v) {\n    if (this.diff === v - this.s) {\n      this.s = v\n      this.count++\n    } else {\n      flushIntDiffOptRleEncoder(this)\n      this.count = 1\n      this.diff = v - this.s\n      this.s = v\n    }\n  }\n\n  toUint8Array () {\n    flushIntDiffOptRleEncoder(this)\n    return toUint8Array(this.encoder)\n  }\n}\n\n/**\n * Optimized String Encoder.\n *\n * Encoding many small strings in a simple Encoder is not very efficient. The function call to decode a string takes some time and creates references that must be eventually deleted.\n * In practice, when decoding several million small strings, the GC will kick in more and more often to collect orphaned string objects (or maybe there is another reason?).\n *\n * This string encoder solves the above problem. All strings are concatenated and written as a single string using a single encoding call.\n *\n * The lengths are encoded using a UintOptRleEncoder.\n */\nexport class StringEncoder {\n  constructor () {\n    /**\n     * @type {Array<string>}\n     */\n    this.sarr = []\n    this.s = ''\n    this.lensE = new UintOptRleEncoder()\n  }\n\n  /**\n   * @param {string} string\n   */\n  write (string) {\n    this.s += string\n    if (this.s.length > 19) {\n      this.sarr.push(this.s)\n      this.s = ''\n    }\n    this.lensE.write(string.length)\n  }\n\n  toUint8Array () {\n    const encoder = new Encoder()\n    this.sarr.push(this.s)\n    this.s = ''\n    writeVarString(encoder, this.sarr.join(''))\n    writeUint8Array(encoder, this.lensE.toUint8Array())\n    return toUint8Array(encoder)\n  }\n}\n","/**\n * Error helpers.\n *\n * @module error\n */\n\n/**\n * @param {string} s\n * @return {Error}\n */\n/* c8 ignore next */\nexport const create = s => new Error(s)\n\n/**\n * @throws {Error}\n * @return {never}\n */\n/* c8 ignore next 3 */\nexport const methodUnimplemented = () => {\n  throw create('Method unimplemented')\n}\n\n/**\n * @throws {Error}\n * @return {never}\n */\n/* c8 ignore next 3 */\nexport const unexpectedCase = () => {\n  throw create('Unexpected case')\n}\n","/**\n * Efficient schema-less binary decoding with support for variable length encoding.\n *\n * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.\n *\n * Encodes numbers in little-endian order (least to most significant byte order)\n * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)\n * which is also used in Protocol Buffers.\n *\n * ```js\n * // encoding step\n * const encoder = encoding.createEncoder()\n * encoding.writeVarUint(encoder, 256)\n * encoding.writeVarString(encoder, 'Hello world!')\n * const buf = encoding.toUint8Array(encoder)\n * ```\n *\n * ```js\n * // decoding step\n * const decoder = decoding.createDecoder(buf)\n * decoding.readVarUint(decoder) // => 256\n * decoding.readVarString(decoder) // => 'Hello world!'\n * decoding.hasContent(decoder) // => false - all data is read\n * ```\n *\n * @module decoding\n */\n\nimport * as buffer from './buffer.js'\nimport * as binary from './binary.js'\nimport * as math from './math.js'\nimport * as number from './number.js'\nimport * as string from './string.js'\nimport * as error from './error.js'\nimport * as encoding from './encoding.js'\n\nconst errorUnexpectedEndOfArray = error.create('Unexpected end of array')\nconst errorIntegerOutOfRange = error.create('Integer out of Range')\n\n/**\n * A Decoder handles the decoding of an Uint8Array.\n */\nexport class Decoder {\n  /**\n   * @param {Uint8Array} uint8Array Binary data to decode\n   */\n  constructor (uint8Array) {\n    /**\n     * Decoding target.\n     *\n     * @type {Uint8Array}\n     */\n    this.arr = uint8Array\n    /**\n     * Current decoding position.\n     *\n     * @type {number}\n     */\n    this.pos = 0\n  }\n}\n\n/**\n * @function\n * @param {Uint8Array} uint8Array\n * @return {Decoder}\n */\nexport const createDecoder = uint8Array => new Decoder(uint8Array)\n\n/**\n * @function\n * @param {Decoder} decoder\n * @return {boolean}\n */\nexport const hasContent = decoder => decoder.pos !== decoder.arr.length\n\n/**\n * Clone a decoder instance.\n * Optionally set a new position parameter.\n *\n * @function\n * @param {Decoder} decoder The decoder instance\n * @param {number} [newPos] Defaults to current position\n * @return {Decoder} A clone of `decoder`\n */\nexport const clone = (decoder, newPos = decoder.pos) => {\n  const _decoder = createDecoder(decoder.arr)\n  _decoder.pos = newPos\n  return _decoder\n}\n\n/**\n * Create an Uint8Array view of the next `len` bytes and advance the position by `len`.\n *\n * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.\n *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.\n *\n * @function\n * @param {Decoder} decoder The decoder instance\n * @param {number} len The length of bytes to read\n * @return {Uint8Array}\n */\nexport const readUint8Array = (decoder, len) => {\n  const view = buffer.createUint8ArrayViewFromArrayBuffer(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len)\n  decoder.pos += len\n  return view\n}\n\n/**\n * Read variable length Uint8Array.\n *\n * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.\n *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.\n *\n * @function\n * @param {Decoder} decoder\n * @return {Uint8Array}\n */\nexport const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder))\n\n/**\n * Read the rest of the content as an ArrayBuffer\n * @function\n * @param {Decoder} decoder\n * @return {Uint8Array}\n */\nexport const readTailAsUint8Array = decoder => readUint8Array(decoder, decoder.arr.length - decoder.pos)\n\n/**\n * Skip one byte, jump to the next position.\n * @function\n * @param {Decoder} decoder The decoder instance\n * @return {number} The next position\n */\nexport const skip8 = decoder => decoder.pos++\n\n/**\n * Read one byte as unsigned integer.\n * @function\n * @param {Decoder} decoder The decoder instance\n * @return {number} Unsigned 8-bit integer\n */\nexport const readUint8 = decoder => decoder.arr[decoder.pos++]\n\n/**\n * Read 2 bytes as unsigned integer.\n *\n * @function\n * @param {Decoder} decoder\n * @return {number} An unsigned integer.\n */\nexport const readUint16 = decoder => {\n  const uint =\n    decoder.arr[decoder.pos] +\n    (decoder.arr[decoder.pos + 1] << 8)\n  decoder.pos += 2\n  return uint\n}\n\n/**\n * Read 4 bytes as unsigned integer.\n *\n * @function\n * @param {Decoder} decoder\n * @return {number} An unsigned integer.\n */\nexport const readUint32 = decoder => {\n  const uint =\n    (decoder.arr[decoder.pos] +\n    (decoder.arr[decoder.pos + 1] << 8) +\n    (decoder.arr[decoder.pos + 2] << 16) +\n    (decoder.arr[decoder.pos + 3] << 24)) >>> 0\n  decoder.pos += 4\n  return uint\n}\n\n/**\n * Read 4 bytes as unsigned integer in big endian order.\n * (most significant byte first)\n *\n * @function\n * @param {Decoder} decoder\n * @return {number} An unsigned integer.\n */\nexport const readUint32BigEndian = decoder => {\n  const uint =\n    (decoder.arr[decoder.pos + 3] +\n    (decoder.arr[decoder.pos + 2] << 8) +\n    (decoder.arr[decoder.pos + 1] << 16) +\n    (decoder.arr[decoder.pos] << 24)) >>> 0\n  decoder.pos += 4\n  return uint\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n *\n * @function\n * @param {Decoder} decoder\n * @return {number} An unsigned integer.\n */\nexport const peekUint8 = decoder => decoder.arr[decoder.pos]\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n *\n * @function\n * @param {Decoder} decoder\n * @return {number} An unsigned integer.\n */\nexport const peekUint16 = decoder =>\n  decoder.arr[decoder.pos] +\n  (decoder.arr[decoder.pos + 1] << 8)\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n *\n * @function\n * @param {Decoder} decoder\n * @return {number} An unsigned integer.\n */\nexport const peekUint32 = decoder => (\n  decoder.arr[decoder.pos] +\n  (decoder.arr[decoder.pos + 1] << 8) +\n  (decoder.arr[decoder.pos + 2] << 16) +\n  (decoder.arr[decoder.pos + 3] << 24)\n) >>> 0\n\n/**\n * Read unsigned integer (32bit) with variable length.\n * 1/8th of the storage is used as encoding overhead.\n *  * numbers < 2^7 is stored in one bytlength\n *  * numbers < 2^14 is stored in two bylength\n *\n * @function\n * @param {Decoder} decoder\n * @return {number} An unsigned integer.length\n */\nexport const readVarUint = decoder => {\n  let num = 0\n  let mult = 1\n  const len = decoder.arr.length\n  while (decoder.pos < len) {\n    const r = decoder.arr[decoder.pos++]\n    // num = num | ((r & binary.BITS7) << len)\n    num = num + (r & binary.BITS7) * mult // shift $r << (7*#iterations) and add it to num\n    mult *= 128 // next iteration, shift 7 \"more\" to the left\n    if (r < binary.BIT8) {\n      return num\n    }\n    /* c8 ignore start */\n    if (num > number.MAX_SAFE_INTEGER) {\n      throw errorIntegerOutOfRange\n    }\n    /* c8 ignore stop */\n  }\n  throw errorUnexpectedEndOfArray\n}\n\n/**\n * Read signed integer (32bit) with variable length.\n * 1/8th of the storage is used as encoding overhead.\n *  * numbers < 2^7 is stored in one bytlength\n *  * numbers < 2^14 is stored in two bylength\n * @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.\n *\n * @function\n * @param {Decoder} decoder\n * @return {number} An unsigned integer.length\n */\nexport const readVarInt = decoder => {\n  let r = decoder.arr[decoder.pos++]\n  let num = r & binary.BITS6\n  let mult = 64\n  const sign = (r & binary.BIT7) > 0 ? -1 : 1\n  if ((r & binary.BIT8) === 0) {\n    // don't continue reading\n    return sign * num\n  }\n  const len = decoder.arr.length\n  while (decoder.pos < len) {\n    r = decoder.arr[decoder.pos++]\n    // num = num | ((r & binary.BITS7) << len)\n    num = num + (r & binary.BITS7) * mult\n    mult *= 128\n    if (r < binary.BIT8) {\n      return sign * num\n    }\n    /* c8 ignore start */\n    if (num > number.MAX_SAFE_INTEGER) {\n      throw errorIntegerOutOfRange\n    }\n    /* c8 ignore stop */\n  }\n  throw errorUnexpectedEndOfArray\n}\n\n/**\n * Look ahead and read varUint without incrementing position\n *\n * @function\n * @param {Decoder} decoder\n * @return {number}\n */\nexport const peekVarUint = decoder => {\n  const pos = decoder.pos\n  const s = readVarUint(decoder)\n  decoder.pos = pos\n  return s\n}\n\n/**\n * Look ahead and read varUint without incrementing position\n *\n * @function\n * @param {Decoder} decoder\n * @return {number}\n */\nexport const peekVarInt = decoder => {\n  const pos = decoder.pos\n  const s = readVarInt(decoder)\n  decoder.pos = pos\n  return s\n}\n\n/**\n * We don't test this function anymore as we use native decoding/encoding by default now.\n * Better not modify this anymore..\n *\n * Transforming utf8 to a string is pretty expensive. The code performs 10x better\n * when String.fromCodePoint is fed with all characters as arguments.\n * But most environments have a maximum number of arguments per functions.\n * For effiency reasons we apply a maximum of 10000 characters at once.\n *\n * @function\n * @param {Decoder} decoder\n * @return {String} The read String.\n */\n/* c8 ignore start */\nexport const _readVarStringPolyfill = decoder => {\n  let remainingLen = readVarUint(decoder)\n  if (remainingLen === 0) {\n    return ''\n  } else {\n    let encodedString = String.fromCodePoint(readUint8(decoder)) // remember to decrease remainingLen\n    if (--remainingLen < 100) { // do not create a Uint8Array for small strings\n      while (remainingLen--) {\n        encodedString += String.fromCodePoint(readUint8(decoder))\n      }\n    } else {\n      while (remainingLen > 0) {\n        const nextLen = remainingLen < 10000 ? remainingLen : 10000\n        // this is dangerous, we create a fresh array view from the existing buffer\n        const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen)\n        decoder.pos += nextLen\n        // Starting with ES5.1 we can supply a generic array-like object as arguments\n        encodedString += String.fromCodePoint.apply(null, /** @type {any} */ (bytes))\n        remainingLen -= nextLen\n      }\n    }\n    return decodeURIComponent(escape(encodedString))\n  }\n}\n/* c8 ignore stop */\n\n/**\n * @function\n * @param {Decoder} decoder\n * @return {String} The read String\n */\nexport const _readVarStringNative = decoder =>\n  /** @type any */ (string.utf8TextDecoder).decode(readVarUint8Array(decoder))\n\n/**\n * Read string of variable length\n * * varUint is used to store the length of the string\n *\n * @function\n * @param {Decoder} decoder\n * @return {String} The read String\n *\n */\n/* c8 ignore next */\nexport const readVarString = string.utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill\n\n/**\n * @param {Decoder} decoder\n * @return {Uint8Array}\n */\nexport const readTerminatedUint8Array = decoder => {\n  const encoder = encoding.createEncoder()\n  let b\n  while (true) {\n    b = readUint8(decoder)\n    if (b === 0) {\n      return encoding.toUint8Array(encoder)\n    }\n    if (b === 1) {\n      b = readUint8(decoder)\n    }\n    encoding.write(encoder, b)\n  }\n}\n\n/**\n * @param {Decoder} decoder\n * @return {string}\n */\nexport const readTerminatedString = decoder => string.decodeUtf8(readTerminatedUint8Array(decoder))\n\n/**\n * Look ahead and read varString without incrementing position\n *\n * @function\n * @param {Decoder} decoder\n * @return {string}\n */\nexport const peekVarString = decoder => {\n  const pos = decoder.pos\n  const s = readVarString(decoder)\n  decoder.pos = pos\n  return s\n}\n\n/**\n * @param {Decoder} decoder\n * @param {number} len\n * @return {DataView}\n */\nexport const readFromDataView = (decoder, len) => {\n  const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len)\n  decoder.pos += len\n  return dv\n}\n\n/**\n * @param {Decoder} decoder\n */\nexport const readFloat32 = decoder => readFromDataView(decoder, 4).getFloat32(0, false)\n\n/**\n * @param {Decoder} decoder\n */\nexport const readFloat64 = decoder => readFromDataView(decoder, 8).getFloat64(0, false)\n\n/**\n * @param {Decoder} decoder\n */\nexport const readBigInt64 = decoder => /** @type {any} */ (readFromDataView(decoder, 8)).getBigInt64(0, false)\n\n/**\n * @param {Decoder} decoder\n */\nexport const readBigUint64 = decoder => /** @type {any} */ (readFromDataView(decoder, 8)).getBigUint64(0, false)\n\n/**\n * @type {Array<function(Decoder):any>}\n */\nconst readAnyLookupTable = [\n  decoder => undefined, // CASE 127: undefined\n  decoder => null, // CASE 126: null\n  readVarInt, // CASE 125: integer\n  readFloat32, // CASE 124: float32\n  readFloat64, // CASE 123: float64\n  readBigInt64, // CASE 122: bigint\n  decoder => false, // CASE 121: boolean (false)\n  decoder => true, // CASE 120: boolean (true)\n  readVarString, // CASE 119: string\n  decoder => { // CASE 118: object<string,any>\n    const len = readVarUint(decoder)\n    /**\n     * @type {Object<string,any>}\n     */\n    const obj = {}\n    for (let i = 0; i < len; i++) {\n      const key = readVarString(decoder)\n      obj[key] = readAny(decoder)\n    }\n    return obj\n  },\n  decoder => { // CASE 117: array<any>\n    const len = readVarUint(decoder)\n    const arr = []\n    for (let i = 0; i < len; i++) {\n      arr.push(readAny(decoder))\n    }\n    return arr\n  },\n  readVarUint8Array // CASE 116: Uint8Array\n]\n\n/**\n * @param {Decoder} decoder\n */\nexport const readAny = decoder => readAnyLookupTable[127 - readUint8(decoder)](decoder)\n\n/**\n * T must not be null.\n *\n * @template T\n */\nexport class RleDecoder extends Decoder {\n  /**\n   * @param {Uint8Array} uint8Array\n   * @param {function(Decoder):T} reader\n   */\n  constructor (uint8Array, reader) {\n    super(uint8Array)\n    /**\n     * The reader\n     */\n    this.reader = reader\n    /**\n     * Current state\n     * @type {T|null}\n     */\n    this.s = null\n    this.count = 0\n  }\n\n  read () {\n    if (this.count === 0) {\n      this.s = this.reader(this)\n      if (hasContent(this)) {\n        this.count = readVarUint(this) + 1 // see encoder implementation for the reason why this is incremented\n      } else {\n        this.count = -1 // read the current value forever\n      }\n    }\n    this.count--\n    return /** @type {T} */ (this.s)\n  }\n}\n\nexport class IntDiffDecoder extends Decoder {\n  /**\n   * @param {Uint8Array} uint8Array\n   * @param {number} start\n   */\n  constructor (uint8Array, start) {\n    super(uint8Array)\n    /**\n     * Current state\n     * @type {number}\n     */\n    this.s = start\n  }\n\n  /**\n   * @return {number}\n   */\n  read () {\n    this.s += readVarInt(this)\n    return this.s\n  }\n}\n\nexport class RleIntDiffDecoder extends Decoder {\n  /**\n   * @param {Uint8Array} uint8Array\n   * @param {number} start\n   */\n  constructor (uint8Array, start) {\n    super(uint8Array)\n    /**\n     * Current state\n     * @type {number}\n     */\n    this.s = start\n    this.count = 0\n  }\n\n  /**\n   * @return {number}\n   */\n  read () {\n    if (this.count === 0) {\n      this.s += readVarInt(this)\n      if (hasContent(this)) {\n        this.count = readVarUint(this) + 1 // see encoder implementation for the reason why this is incremented\n      } else {\n        this.count = -1 // read the current value forever\n      }\n    }\n    this.count--\n    return /** @type {number} */ (this.s)\n  }\n}\n\nexport class UintOptRleDecoder extends Decoder {\n  /**\n   * @param {Uint8Array} uint8Array\n   */\n  constructor (uint8Array) {\n    super(uint8Array)\n    /**\n     * @type {number}\n     */\n    this.s = 0\n    this.count = 0\n  }\n\n  read () {\n    if (this.count === 0) {\n      this.s = readVarInt(this)\n      // if the sign is negative, we read the count too, otherwise count is 1\n      const isNegative = math.isNegativeZero(this.s)\n      this.count = 1\n      if (isNegative) {\n        this.s = -this.s\n        this.count = readVarUint(this) + 2\n      }\n    }\n    this.count--\n    return /** @type {number} */ (this.s)\n  }\n}\n\nexport class IncUintOptRleDecoder extends Decoder {\n  /**\n   * @param {Uint8Array} uint8Array\n   */\n  constructor (uint8Array) {\n    super(uint8Array)\n    /**\n     * @type {number}\n     */\n    this.s = 0\n    this.count = 0\n  }\n\n  read () {\n    if (this.count === 0) {\n      this.s = readVarInt(this)\n      // if the sign is negative, we read the count too, otherwise count is 1\n      const isNegative = math.isNegativeZero(this.s)\n      this.count = 1\n      if (isNegative) {\n        this.s = -this.s\n        this.count = readVarUint(this) + 2\n      }\n    }\n    this.count--\n    return /** @type {number} */ (this.s++)\n  }\n}\n\nexport class IntDiffOptRleDecoder extends Decoder {\n  /**\n   * @param {Uint8Array} uint8Array\n   */\n  constructor (uint8Array) {\n    super(uint8Array)\n    /**\n     * @type {number}\n     */\n    this.s = 0\n    this.count = 0\n    this.diff = 0\n  }\n\n  /**\n   * @return {number}\n   */\n  read () {\n    if (this.count === 0) {\n      const diff = readVarInt(this)\n      // if the first bit is set, we read more data\n      const hasCount = diff & 1\n      this.diff = math.floor(diff / 2) // shift >> 1\n      this.count = 1\n      if (hasCount) {\n        this.count = readVarUint(this) + 2\n      }\n    }\n    this.s += this.diff\n    this.count--\n    return this.s\n  }\n}\n\nexport class StringDecoder {\n  /**\n   * @param {Uint8Array} uint8Array\n   */\n  constructor (uint8Array) {\n    this.decoder = new UintOptRleDecoder(uint8Array)\n    this.str = readVarString(this.decoder)\n    /**\n     * @type {number}\n     */\n    this.spos = 0\n  }\n\n  /**\n   * @return {string}\n   */\n  read () {\n    const end = this.spos + this.decoder.read()\n    const res = this.str.slice(this.spos, end)\n    this.spos = end\n    return res\n  }\n}\n","/* eslint-env browser */\n\nexport const subtle = crypto.subtle\nexport const getRandomValues = crypto.getRandomValues.bind(crypto)\n","/**\n * Isomorphic module for true random numbers / buffers / uuids.\n *\n * Attention: falls back to Math.random if the browser does not support crypto.\n *\n * @module random\n */\n\nimport * as math from './math.js'\nimport * as binary from './binary.js'\nimport { getRandomValues } from 'lib0/webcrypto'\n\nexport const rand = Math.random\n\nexport const uint32 = () => getRandomValues(new Uint32Array(1))[0]\n\nexport const uint53 = () => {\n  const arr = getRandomValues(new Uint32Array(8))\n  return (arr[0] & binary.BITS21) * (binary.BITS32 + 1) + (arr[1] >>> 0)\n}\n\n/**\n * @template T\n * @param {Array<T>} arr\n * @return {T}\n */\nexport const oneOf = arr => arr[math.floor(rand() * arr.length)]\n\n// @ts-ignore\nconst uuidv4Template = [1e7] + -1e3 + -4e3 + -8e3 + -1e11\n\n/**\n * @return {string}\n */\nexport const uuidv4 = () => uuidv4Template.replace(/[018]/g, /** @param {number} c */ c =>\n  (c ^ uint32() & 15 >> c / 4).toString(16)\n)\n","/**\n * Utility helpers to work with promises.\n *\n * @module promise\n */\n\nimport * as time from './time.js'\n\n/**\n * @template T\n * @callback PromiseResolve\n * @param {T|PromiseLike<T>} [result]\n */\n\n/**\n * @template T\n * @param {function(PromiseResolve<T>,function(Error):void):any} f\n * @return {Promise<T>}\n */\nexport const create = f => /** @type {Promise<T>} */ (new Promise(f))\n\n/**\n * @param {function(function():void,function(Error):void):void} f\n * @return {Promise<void>}\n */\nexport const createEmpty = f => new Promise(f)\n\n/**\n * `Promise.all` wait for all promises in the array to resolve and return the result\n * @template {unknown[] | []} PS\n *\n * @param {PS} ps\n * @return {Promise<{ -readonly [P in keyof PS]: Awaited<PS[P]> }>}\n */\nexport const all = Promise.all.bind(Promise)\n\n/**\n * @param {Error} [reason]\n * @return {Promise<never>}\n */\nexport const reject = reason => Promise.reject(reason)\n\n/**\n * @template T\n * @param {T|void} res\n * @return {Promise<T|void>}\n */\nexport const resolve = res => Promise.resolve(res)\n\n/**\n * @template T\n * @param {T} res\n * @return {Promise<T>}\n */\nexport const resolveWith = res => Promise.resolve(res)\n\n/**\n * @todo Next version, reorder parameters: check, [timeout, [intervalResolution]]\n *\n * @param {number} timeout\n * @param {function():boolean} check\n * @param {number} [intervalResolution]\n * @return {Promise<void>}\n */\nexport const until = (timeout, check, intervalResolution = 10) => create((resolve, reject) => {\n  const startTime = time.getUnixTime()\n  const hasTimeout = timeout > 0\n  const untilInterval = () => {\n    if (check()) {\n      clearInterval(intervalHandle)\n      resolve()\n    } else if (hasTimeout) {\n      /* c8 ignore else */\n      if (time.getUnixTime() - startTime > timeout) {\n        clearInterval(intervalHandle)\n        reject(new Error('Timeout'))\n      }\n    }\n  }\n  const intervalHandle = setInterval(untilInterval, intervalResolution)\n})\n\n/**\n * @param {number} timeout\n * @return {Promise<undefined>}\n */\nexport const wait = timeout => create((resolve, reject) => setTimeout(resolve, timeout))\n\n/**\n * Checks if an object is a promise using ducktyping.\n *\n * Promises are often polyfilled, so it makes sense to add some additional guarantees if the user of this\n * library has some insane environment where global Promise objects are overwritten.\n *\n * @param {any} p\n * @return {boolean}\n */\nexport const isPromise = p => p instanceof Promise || (p && p.then && p.catch && p.finally)\n","/**\n * Working with value pairs.\n *\n * @module pair\n */\n\n/**\n * @template L,R\n */\nexport class Pair {\n  /**\n   * @param {L} left\n   * @param {R} right\n   */\n  constructor (left, right) {\n    this.left = left\n    this.right = right\n  }\n}\n\n/**\n * @template L,R\n * @param {L} left\n * @param {R} right\n * @return {Pair<L,R>}\n */\nexport const create = (left, right) => new Pair(left, right)\n\n/**\n * @template L,R\n * @param {R} right\n * @param {L} left\n * @return {Pair<L,R>}\n */\nexport const createReversed = (right, left) => new Pair(left, right)\n\n/**\n * @template L,R\n * @param {Array<Pair<L,R>>} arr\n * @param {function(L, R):any} f\n */\nexport const forEach = (arr, f) => arr.forEach(p => f(p.left, p.right))\n\n/**\n * @template L,R,X\n * @param {Array<Pair<L,R>>} arr\n * @param {function(L, R):X} f\n * @return {Array<X>}\n */\nexport const map = (arr, f) => arr.map(p => f(p.left, p.right))\n","/* eslint-env browser */\n\n/**\n * Utility module to work with the DOM.\n *\n * @module dom\n */\n\nimport * as pair from './pair.js'\nimport * as map from './map.js'\n\n/* c8 ignore start */\n/**\n * @type {Document}\n */\nexport const doc = /** @type {Document} */ (typeof document !== 'undefined' ? document : {})\n\n/**\n * @param {string} name\n * @return {HTMLElement}\n */\nexport const createElement = name => doc.createElement(name)\n\n/**\n * @return {DocumentFragment}\n */\nexport const createDocumentFragment = () => doc.createDocumentFragment()\n\n/**\n * @param {string} text\n * @return {Text}\n */\nexport const createTextNode = text => doc.createTextNode(text)\n\nexport const domParser = /** @type {DOMParser} */ (typeof DOMParser !== 'undefined' ? new DOMParser() : null)\n\n/**\n * @param {HTMLElement} el\n * @param {string} name\n * @param {Object} opts\n */\nexport const emitCustomEvent = (el, name, opts) => el.dispatchEvent(new CustomEvent(name, opts))\n\n/**\n * @param {Element} el\n * @param {Array<pair.Pair<string,string|boolean>>} attrs Array of key-value pairs\n * @return {Element}\n */\nexport const setAttributes = (el, attrs) => {\n  pair.forEach(attrs, (key, value) => {\n    if (value === false) {\n      el.removeAttribute(key)\n    } else if (value === true) {\n      el.setAttribute(key, '')\n    } else {\n      // @ts-ignore\n      el.setAttribute(key, value)\n    }\n  })\n  return el\n}\n\n/**\n * @param {Element} el\n * @param {Map<string, string>} attrs Array of key-value pairs\n * @return {Element}\n */\nexport const setAttributesMap = (el, attrs) => {\n  attrs.forEach((value, key) => { el.setAttribute(key, value) })\n  return el\n}\n\n/**\n * @param {Array<Node>|HTMLCollection} children\n * @return {DocumentFragment}\n */\nexport const fragment = children => {\n  const fragment = createDocumentFragment()\n  for (let i = 0; i < children.length; i++) {\n    appendChild(fragment, children[i])\n  }\n  return fragment\n}\n\n/**\n * @param {Element} parent\n * @param {Array<Node>} nodes\n * @return {Element}\n */\nexport const append = (parent, nodes) => {\n  appendChild(parent, fragment(nodes))\n  return parent\n}\n\n/**\n * @param {HTMLElement} el\n */\nexport const remove = el => el.remove()\n\n/**\n * @param {EventTarget} el\n * @param {string} name\n * @param {EventListener} f\n */\nexport const addEventListener = (el, name, f) => el.addEventListener(name, f)\n\n/**\n * @param {EventTarget} el\n * @param {string} name\n * @param {EventListener} f\n */\nexport const removeEventListener = (el, name, f) => el.removeEventListener(name, f)\n\n/**\n * @param {Node} node\n * @param {Array<pair.Pair<string,EventListener>>} listeners\n * @return {Node}\n */\nexport const addEventListeners = (node, listeners) => {\n  pair.forEach(listeners, (name, f) => addEventListener(node, name, f))\n  return node\n}\n\n/**\n * @param {Node} node\n * @param {Array<pair.Pair<string,EventListener>>} listeners\n * @return {Node}\n */\nexport const removeEventListeners = (node, listeners) => {\n  pair.forEach(listeners, (name, f) => removeEventListener(node, name, f))\n  return node\n}\n\n/**\n * @param {string} name\n * @param {Array<pair.Pair<string,string>|pair.Pair<string,boolean>>} attrs Array of key-value pairs\n * @param {Array<Node>} children\n * @return {Element}\n */\nexport const element = (name, attrs = [], children = []) =>\n  append(setAttributes(createElement(name), attrs), children)\n\n/**\n * @param {number} width\n * @param {number} height\n */\nexport const canvas = (width, height) => {\n  const c = /** @type {HTMLCanvasElement} */ (createElement('canvas'))\n  c.height = height\n  c.width = width\n  return c\n}\n\n/**\n * @param {string} t\n * @return {Text}\n */\nexport const text = createTextNode\n\n/**\n * @param {pair.Pair<string,string>} pair\n */\nexport const pairToStyleString = pair => `${pair.left}:${pair.right};`\n\n/**\n * @param {Array<pair.Pair<string,string>>} pairs\n * @return {string}\n */\nexport const pairsToStyleString = pairs => pairs.map(pairToStyleString).join('')\n\n/**\n * @param {Map<string,string>} m\n * @return {string}\n */\nexport const mapToStyleString = m => map.map(m, (value, key) => `${key}:${value};`).join('')\n\n/**\n * @todo should always query on a dom element\n *\n * @param {HTMLElement|ShadowRoot} el\n * @param {string} query\n * @return {HTMLElement | null}\n */\nexport const querySelector = (el, query) => el.querySelector(query)\n\n/**\n * @param {HTMLElement|ShadowRoot} el\n * @param {string} query\n * @return {NodeListOf<HTMLElement>}\n */\nexport const querySelectorAll = (el, query) => el.querySelectorAll(query)\n\n/**\n * @param {string} id\n * @return {HTMLElement}\n */\nexport const getElementById = id => /** @type {HTMLElement} */ (doc.getElementById(id))\n\n/**\n * @param {string} html\n * @return {HTMLElement}\n */\nconst _parse = html => domParser.parseFromString(`<html><body>${html}</body></html>`, 'text/html').body\n\n/**\n * @param {string} html\n * @return {DocumentFragment}\n */\nexport const parseFragment = html => fragment(/** @type {any} */ (_parse(html).childNodes))\n\n/**\n * @param {string} html\n * @return {HTMLElement}\n */\nexport const parseElement = html => /** @type HTMLElement */ (_parse(html).firstElementChild)\n\n/**\n * @param {HTMLElement} oldEl\n * @param {HTMLElement|DocumentFragment} newEl\n */\nexport const replaceWith = (oldEl, newEl) => oldEl.replaceWith(newEl)\n\n/**\n * @param {HTMLElement} parent\n * @param {HTMLElement} el\n * @param {Node|null} ref\n * @return {HTMLElement}\n */\nexport const insertBefore = (parent, el, ref) => parent.insertBefore(el, ref)\n\n/**\n * @param {Node} parent\n * @param {Node} child\n * @return {Node}\n */\nexport const appendChild = (parent, child) => parent.appendChild(child)\n\nexport const ELEMENT_NODE = doc.ELEMENT_NODE\nexport const TEXT_NODE = doc.TEXT_NODE\nexport const CDATA_SECTION_NODE = doc.CDATA_SECTION_NODE\nexport const COMMENT_NODE = doc.COMMENT_NODE\nexport const DOCUMENT_NODE = doc.DOCUMENT_NODE\nexport const DOCUMENT_TYPE_NODE = doc.DOCUMENT_TYPE_NODE\nexport const DOCUMENT_FRAGMENT_NODE = doc.DOCUMENT_FRAGMENT_NODE\n\n/**\n * @param {any} node\n * @param {number} type\n */\nexport const checkNodeType = (node, type) => node.nodeType === type\n\n/**\n * @param {Node} parent\n * @param {HTMLElement} child\n */\nexport const isParentOf = (parent, child) => {\n  let p = child.parentNode\n  while (p && p !== parent) {\n    p = p.parentNode\n  }\n  return p === parent\n}\n/* c8 ignore stop */\n","/**\n * Utility module to work with EcmaScript Symbols.\n *\n * @module symbol\n */\n\n/**\n * Return fresh symbol.\n *\n * @return {Symbol}\n */\nexport const create = Symbol\n\n/**\n * @param {any} s\n * @return {boolean}\n */\nexport const isSymbol = s => typeof s === 'symbol'\n","/**\n * Utility module to work with time.\n *\n * @module time\n */\n\nimport * as metric from './metric.js'\nimport * as math from './math.js'\n\n/**\n * Return current time.\n *\n * @return {Date}\n */\nexport const getDate = () => new Date()\n\n/**\n * Return current unix time.\n *\n * @return {number}\n */\nexport const getUnixTime = Date.now\n\n/**\n * Transform time (in ms) to a human readable format. E.g. 1100 => 1.1s. 60s => 1min. .001 => 10μs.\n *\n * @param {number} d duration in milliseconds\n * @return {string} humanized approximation of time\n */\nexport const humanizeDuration = d => {\n  if (d < 60000) {\n    const p = metric.prefix(d, -1)\n    return math.round(p.n * 100) / 100 + p.prefix + 's'\n  }\n  d = math.floor(d / 1000)\n  const seconds = d % 60\n  const minutes = math.floor(d / 60) % 60\n  const hours = math.floor(d / 3600) % 24\n  const days = math.floor(d / 86400)\n  if (days > 0) {\n    return days + 'd' + ((hours > 0 || minutes > 30) ? ' ' + (minutes > 30 ? hours + 1 : hours) + 'h' : '')\n  }\n  if (hours > 0) {\n    /* c8 ignore next */\n    return hours + 'h' + ((minutes > 0 || seconds > 30) ? ' ' + (seconds > 30 ? minutes + 1 : minutes) + 'min' : '')\n  }\n  return minutes + 'min' + (seconds > 0 ? ' ' + seconds + 's' : '')\n}\n","import * as symbol from './symbol.js'\nimport * as time from './time.js'\nimport * as env from './environment.js'\nimport * as func from './function.js'\n\nexport const BOLD = symbol.create()\nexport const UNBOLD = symbol.create()\nexport const BLUE = symbol.create()\nexport const GREY = symbol.create()\nexport const GREEN = symbol.create()\nexport const RED = symbol.create()\nexport const PURPLE = symbol.create()\nexport const ORANGE = symbol.create()\nexport const UNCOLOR = symbol.create()\n\n/* c8 ignore start */\n/**\n * @param {Array<string|Symbol|Object|number>} args\n * @return {Array<string|object|number>}\n */\nexport const computeNoColorLoggingArgs = args => {\n  const strBuilder = []\n  const logArgs = []\n  // try with formatting until we find something unsupported\n  let i = 0\n  for (; i < args.length; i++) {\n    const arg = args[i]\n    if (arg.constructor === String || arg.constructor === Number) {\n      strBuilder.push(arg)\n    } else if (arg.constructor === Object) {\n      logArgs.push(JSON.stringify(arg))\n    }\n  }\n  return logArgs\n}\n/* c8 ignore stop */\n\nconst loggingColors = [GREEN, PURPLE, ORANGE, BLUE]\nlet nextColor = 0\nlet lastLoggingTime = time.getUnixTime()\n\n/* c8 ignore start */\n/**\n * @param {function(...any):void} _print\n * @param {string} moduleName\n * @return {function(...any):void}\n */\nexport const createModuleLogger = (_print, moduleName) => {\n  const color = loggingColors[nextColor]\n  const debugRegexVar = env.getVariable('log')\n  const doLogging = debugRegexVar !== null &&\n    (debugRegexVar === '*' || debugRegexVar === 'true' ||\n      new RegExp(debugRegexVar, 'gi').test(moduleName))\n  nextColor = (nextColor + 1) % loggingColors.length\n  moduleName += ': '\n  return !doLogging\n    ? func.nop\n    : (...args) => {\n        const timeNow = time.getUnixTime()\n        const timeDiff = timeNow - lastLoggingTime\n        lastLoggingTime = timeNow\n        _print(\n          color,\n          moduleName,\n          UNCOLOR,\n          ...args.map((arg) =>\n            (typeof arg === 'string' || typeof arg === 'symbol')\n              ? arg\n              : JSON.stringify(arg)\n          ),\n          color,\n          ' +' + timeDiff + 'ms'\n        )\n      }\n}\n/* c8 ignore stop */\n","/**\n * Isomorphic logging module with support for colors!\n *\n * @module logging\n */\n\nimport * as env from './environment.js'\nimport * as set from './set.js'\nimport * as pair from './pair.js'\nimport * as dom from './dom.js'\nimport * as json from './json.js'\nimport * as map from './map.js'\nimport * as eventloop from './eventloop.js'\nimport * as math from './math.js'\nimport * as common from './logging.common.js'\n\nexport { BOLD, UNBOLD, BLUE, GREY, GREEN, RED, PURPLE, ORANGE, UNCOLOR } from './logging.common.js'\n\n/**\n * @type {Object<Symbol,pair.Pair<string,string>>}\n */\nconst _browserStyleMap = {\n  [common.BOLD]: pair.create('font-weight', 'bold'),\n  [common.UNBOLD]: pair.create('font-weight', 'normal'),\n  [common.BLUE]: pair.create('color', 'blue'),\n  [common.GREEN]: pair.create('color', 'green'),\n  [common.GREY]: pair.create('color', 'grey'),\n  [common.RED]: pair.create('color', 'red'),\n  [common.PURPLE]: pair.create('color', 'purple'),\n  [common.ORANGE]: pair.create('color', 'orange'), // not well supported in chrome when debugging node with inspector - TODO: deprecate\n  [common.UNCOLOR]: pair.create('color', 'black')\n}\n\n/**\n * @param {Array<string|Symbol|Object|number>} args\n * @return {Array<string|object|number>}\n */\n/* c8 ignore start */\nconst computeBrowserLoggingArgs = (args) => {\n  const strBuilder = []\n  const styles = []\n  const currentStyle = map.create()\n  /**\n   * @type {Array<string|Object|number>}\n   */\n  let logArgs = []\n  // try with formatting until we find something unsupported\n  let i = 0\n  for (; i < args.length; i++) {\n    const arg = args[i]\n    // @ts-ignore\n    const style = _browserStyleMap[arg]\n    if (style !== undefined) {\n      currentStyle.set(style.left, style.right)\n    } else {\n      if (arg.constructor === String || arg.constructor === Number) {\n        const style = dom.mapToStyleString(currentStyle)\n        if (i > 0 || style.length > 0) {\n          strBuilder.push('%c' + arg)\n          styles.push(style)\n        } else {\n          strBuilder.push(arg)\n        }\n      } else {\n        break\n      }\n    }\n  }\n  if (i > 0) {\n    // create logArgs with what we have so far\n    logArgs = styles\n    logArgs.unshift(strBuilder.join(''))\n  }\n  // append the rest\n  for (; i < args.length; i++) {\n    const arg = args[i]\n    if (!(arg instanceof Symbol)) {\n      logArgs.push(arg)\n    }\n  }\n  return logArgs\n}\n/* c8 ignore stop */\n\n/* c8 ignore start */\nconst computeLoggingArgs = env.supportsColor\n  ? computeBrowserLoggingArgs\n  : common.computeNoColorLoggingArgs\n/* c8 ignore stop */\n\n/**\n * @param {Array<string|Symbol|Object|number>} args\n */\nexport const print = (...args) => {\n  console.log(...computeLoggingArgs(args))\n  /* c8 ignore next */\n  vconsoles.forEach((vc) => vc.print(args))\n}\n\n/* c8 ignore start */\n/**\n * @param {Array<string|Symbol|Object|number>} args\n */\nexport const warn = (...args) => {\n  console.warn(...computeLoggingArgs(args))\n  args.unshift(common.ORANGE)\n  vconsoles.forEach((vc) => vc.print(args))\n}\n/* c8 ignore stop */\n\n/**\n * @param {Error} err\n */\n/* c8 ignore start */\nexport const printError = (err) => {\n  console.error(err)\n  vconsoles.forEach((vc) => vc.printError(err))\n}\n/* c8 ignore stop */\n\n/**\n * @param {string} url image location\n * @param {number} height height of the image in pixel\n */\n/* c8 ignore start */\nexport const printImg = (url, height) => {\n  if (env.isBrowser) {\n    console.log(\n      '%c                      ',\n      `font-size: ${height}px; background-size: contain; background-repeat: no-repeat; background-image: url(${url})`\n    )\n    // console.log('%c                ', `font-size: ${height}x; background: url(${url}) no-repeat;`)\n  }\n  vconsoles.forEach((vc) => vc.printImg(url, height))\n}\n/* c8 ignore stop */\n\n/**\n * @param {string} base64\n * @param {number} height\n */\n/* c8 ignore next 2 */\nexport const printImgBase64 = (base64, height) =>\n  printImg(`data:image/gif;base64,${base64}`, height)\n\n/**\n * @param {Array<string|Symbol|Object|number>} args\n */\nexport const group = (...args) => {\n  console.group(...computeLoggingArgs(args))\n  /* c8 ignore next */\n  vconsoles.forEach((vc) => vc.group(args))\n}\n\n/**\n * @param {Array<string|Symbol|Object|number>} args\n */\nexport const groupCollapsed = (...args) => {\n  console.groupCollapsed(...computeLoggingArgs(args))\n  /* c8 ignore next */\n  vconsoles.forEach((vc) => vc.groupCollapsed(args))\n}\n\nexport const groupEnd = () => {\n  console.groupEnd()\n  /* c8 ignore next */\n  vconsoles.forEach((vc) => vc.groupEnd())\n}\n\n/**\n * @param {function():Node} createNode\n */\n/* c8 ignore next 2 */\nexport const printDom = (createNode) =>\n  vconsoles.forEach((vc) => vc.printDom(createNode()))\n\n/**\n * @param {HTMLCanvasElement} canvas\n * @param {number} height\n */\n/* c8 ignore next 2 */\nexport const printCanvas = (canvas, height) =>\n  printImg(canvas.toDataURL(), height)\n\nexport const vconsoles = set.create()\n\n/**\n * @param {Array<string|Symbol|Object|number>} args\n * @return {Array<Element>}\n */\n/* c8 ignore start */\nconst _computeLineSpans = (args) => {\n  const spans = []\n  const currentStyle = new Map()\n  // try with formatting until we find something unsupported\n  let i = 0\n  for (; i < args.length; i++) {\n    const arg = args[i]\n    // @ts-ignore\n    const style = _browserStyleMap[arg]\n    if (style !== undefined) {\n      currentStyle.set(style.left, style.right)\n    } else {\n      if (arg.constructor === String || arg.constructor === Number) {\n        // @ts-ignore\n        const span = dom.element('span', [\n          pair.create('style', dom.mapToStyleString(currentStyle))\n        ], [dom.text(arg.toString())])\n        if (span.innerHTML === '') {\n          span.innerHTML = '&nbsp;'\n        }\n        spans.push(span)\n      } else {\n        break\n      }\n    }\n  }\n  // append the rest\n  for (; i < args.length; i++) {\n    let content = args[i]\n    if (!(content instanceof Symbol)) {\n      if (content.constructor !== String && content.constructor !== Number) {\n        content = ' ' + json.stringify(content) + ' '\n      }\n      spans.push(\n        dom.element('span', [], [dom.text(/** @type {string} */ (content))])\n      )\n    }\n  }\n  return spans\n}\n/* c8 ignore stop */\n\nconst lineStyle =\n  'font-family:monospace;border-bottom:1px solid #e2e2e2;padding:2px;'\n\n/* c8 ignore start */\nexport class VConsole {\n  /**\n   * @param {Element} dom\n   */\n  constructor (dom) {\n    this.dom = dom\n    /**\n     * @type {Element}\n     */\n    this.ccontainer = this.dom\n    this.depth = 0\n    vconsoles.add(this)\n  }\n\n  /**\n   * @param {Array<string|Symbol|Object|number>} args\n   * @param {boolean} collapsed\n   */\n  group (args, collapsed = false) {\n    eventloop.enqueue(() => {\n      const triangleDown = dom.element('span', [\n        pair.create('hidden', collapsed),\n        pair.create('style', 'color:grey;font-size:120%;')\n      ], [dom.text('▼')])\n      const triangleRight = dom.element('span', [\n        pair.create('hidden', !collapsed),\n        pair.create('style', 'color:grey;font-size:125%;')\n      ], [dom.text('▶')])\n      const content = dom.element(\n        'div',\n        [pair.create(\n          'style',\n          `${lineStyle};padding-left:${this.depth * 10}px`\n        )],\n        [triangleDown, triangleRight, dom.text(' ')].concat(\n          _computeLineSpans(args)\n        )\n      )\n      const nextContainer = dom.element('div', [\n        pair.create('hidden', collapsed)\n      ])\n      const nextLine = dom.element('div', [], [content, nextContainer])\n      dom.append(this.ccontainer, [nextLine])\n      this.ccontainer = nextContainer\n      this.depth++\n      // when header is clicked, collapse/uncollapse container\n      dom.addEventListener(content, 'click', (_event) => {\n        nextContainer.toggleAttribute('hidden')\n        triangleDown.toggleAttribute('hidden')\n        triangleRight.toggleAttribute('hidden')\n      })\n    })\n  }\n\n  /**\n   * @param {Array<string|Symbol|Object|number>} args\n   */\n  groupCollapsed (args) {\n    this.group(args, true)\n  }\n\n  groupEnd () {\n    eventloop.enqueue(() => {\n      if (this.depth > 0) {\n        this.depth--\n        // @ts-ignore\n        this.ccontainer = this.ccontainer.parentElement.parentElement\n      }\n    })\n  }\n\n  /**\n   * @param {Array<string|Symbol|Object|number>} args\n   */\n  print (args) {\n    eventloop.enqueue(() => {\n      dom.append(this.ccontainer, [\n        dom.element('div', [\n          pair.create(\n            'style',\n            `${lineStyle};padding-left:${this.depth * 10}px`\n          )\n        ], _computeLineSpans(args))\n      ])\n    })\n  }\n\n  /**\n   * @param {Error} err\n   */\n  printError (err) {\n    this.print([common.RED, common.BOLD, err.toString()])\n  }\n\n  /**\n   * @param {string} url\n   * @param {number} height\n   */\n  printImg (url, height) {\n    eventloop.enqueue(() => {\n      dom.append(this.ccontainer, [\n        dom.element('img', [\n          pair.create('src', url),\n          pair.create('height', `${math.round(height * 1.5)}px`)\n        ])\n      ])\n    })\n  }\n\n  /**\n   * @param {Node} node\n   */\n  printDom (node) {\n    eventloop.enqueue(() => {\n      dom.append(this.ccontainer, [node])\n    })\n  }\n\n  destroy () {\n    eventloop.enqueue(() => {\n      vconsoles.delete(this)\n    })\n  }\n}\n/* c8 ignore stop */\n\n/**\n * @param {Element} dom\n */\n/* c8 ignore next */\nexport const createVConsole = (dom) => new VConsole(dom)\n\n/**\n * @param {string} moduleName\n * @return {function(...any):void}\n */\nexport const createModuleLogger = (moduleName) => common.createModuleLogger(print, moduleName)\n","/**\n * Utility module to create and manipulate Iterators.\n *\n * @module iterator\n */\n\n/**\n * @template T,R\n * @param {Iterator<T>} iterator\n * @param {function(T):R} f\n * @return {IterableIterator<R>}\n */\nexport const mapIterator = (iterator, f) => ({\n  [Symbol.iterator] () {\n    return this\n  },\n  // @ts-ignore\n  next () {\n    const r = iterator.next()\n    return { value: r.done ? undefined : f(r.value), done: r.done }\n  }\n})\n\n/**\n * @template T\n * @param {function():IteratorResult<T>} next\n * @return {IterableIterator<T>}\n */\nexport const createIterator = next => ({\n  /**\n   * @return {IterableIterator<T>}\n   */\n  [Symbol.iterator] () {\n    return this\n  },\n  // @ts-ignore\n  next\n})\n\n/**\n * @template T\n * @param {Iterator<T>} iterator\n * @param {function(T):boolean} filter\n */\nexport const iteratorFilter = (iterator, filter) => createIterator(() => {\n  let res\n  do {\n    res = iterator.next()\n  } while (!res.done && !filter(res.value))\n  return res\n})\n\n/**\n * @template T,M\n * @param {Iterator<T>} iterator\n * @param {function(T):M} fmap\n */\nexport const iteratorMap = (iterator, fmap) => createIterator(() => {\n  const { done, value } = iterator.next()\n  return { done, value: done ? undefined : fmap(value) }\n})\n","import { Observable } from 'lib0/observable';\nimport * as array from 'lib0/array';\nimport * as math from 'lib0/math';\nimport * as map from 'lib0/map';\nimport * as encoding from 'lib0/encoding';\nimport * as decoding from 'lib0/decoding';\nimport * as random from 'lib0/random';\nimport * as promise from 'lib0/promise';\nimport * as buffer from 'lib0/buffer';\nimport * as error from 'lib0/error';\nimport * as binary from 'lib0/binary';\nimport * as f from 'lib0/function';\nimport { callAll } from 'lib0/function';\nimport * as set from 'lib0/set';\nimport * as logging from 'lib0/logging';\nimport * as time from 'lib0/time';\nimport * as string from 'lib0/string';\nimport * as iterator from 'lib0/iterator';\nimport * as object from 'lib0/object';\n\n/**\n * This is an abstract interface that all Connectors should implement to keep them interchangeable.\n *\n * @note This interface is experimental and it is not advised to actually inherit this class.\n *       It just serves as typing information.\n *\n * @extends {Observable<any>}\n */\nclass AbstractConnector extends Observable {\n  /**\n   * @param {Doc} ydoc\n   * @param {any} awareness\n   */\n  constructor (ydoc, awareness) {\n    super();\n    this.doc = ydoc;\n    this.awareness = awareness;\n  }\n}\n\nclass DeleteItem {\n  /**\n   * @param {number} clock\n   * @param {number} len\n   */\n  constructor (clock, len) {\n    /**\n     * @type {number}\n     */\n    this.clock = clock;\n    /**\n     * @type {number}\n     */\n    this.len = len;\n  }\n}\n\n/**\n * We no longer maintain a DeleteStore. DeleteSet is a temporary object that is created when needed.\n * - When created in a transaction, it must only be accessed after sorting, and merging\n *   - This DeleteSet is send to other clients\n * - We do not create a DeleteSet when we send a sync message. The DeleteSet message is created directly from StructStore\n * - We read a DeleteSet as part of a sync/update message. In this case the DeleteSet is already sorted and merged.\n */\nclass DeleteSet {\n  constructor () {\n    /**\n     * @type {Map<number,Array<DeleteItem>>}\n     */\n    this.clients = new Map();\n  }\n}\n\n/**\n * Iterate over all structs that the DeleteSet gc's.\n *\n * @param {Transaction} transaction\n * @param {DeleteSet} ds\n * @param {function(GC|Item):void} f\n *\n * @function\n */\nconst iterateDeletedStructs = (transaction, ds, f) =>\n  ds.clients.forEach((deletes, clientid) => {\n    const structs = /** @type {Array<GC|Item>} */ (transaction.doc.store.clients.get(clientid));\n    for (let i = 0; i < deletes.length; i++) {\n      const del = deletes[i];\n      iterateStructs(transaction, structs, del.clock, del.len, f);\n    }\n  });\n\n/**\n * @param {Array<DeleteItem>} dis\n * @param {number} clock\n * @return {number|null}\n *\n * @private\n * @function\n */\nconst findIndexDS = (dis, clock) => {\n  let left = 0;\n  let right = dis.length - 1;\n  while (left <= right) {\n    const midindex = math.floor((left + right) / 2);\n    const mid = dis[midindex];\n    const midclock = mid.clock;\n    if (midclock <= clock) {\n      if (clock < midclock + mid.len) {\n        return midindex\n      }\n      left = midindex + 1;\n    } else {\n      right = midindex - 1;\n    }\n  }\n  return null\n};\n\n/**\n * @param {DeleteSet} ds\n * @param {ID} id\n * @return {boolean}\n *\n * @private\n * @function\n */\nconst isDeleted = (ds, id) => {\n  const dis = ds.clients.get(id.client);\n  return dis !== undefined && findIndexDS(dis, id.clock) !== null\n};\n\n/**\n * @param {DeleteSet} ds\n *\n * @private\n * @function\n */\nconst sortAndMergeDeleteSet = ds => {\n  ds.clients.forEach(dels => {\n    dels.sort((a, b) => a.clock - b.clock);\n    // merge items without filtering or splicing the array\n    // i is the current pointer\n    // j refers to the current insert position for the pointed item\n    // try to merge dels[i] into dels[j-1] or set dels[j]=dels[i]\n    let i, j;\n    for (i = 1, j = 1; i < dels.length; i++) {\n      const left = dels[j - 1];\n      const right = dels[i];\n      if (left.clock + left.len >= right.clock) {\n        left.len = math.max(left.len, right.clock + right.len - left.clock);\n      } else {\n        if (j < i) {\n          dels[j] = right;\n        }\n        j++;\n      }\n    }\n    dels.length = j;\n  });\n};\n\n/**\n * @param {Array<DeleteSet>} dss\n * @return {DeleteSet} A fresh DeleteSet\n */\nconst mergeDeleteSets = dss => {\n  const merged = new DeleteSet();\n  for (let dssI = 0; dssI < dss.length; dssI++) {\n    dss[dssI].clients.forEach((delsLeft, client) => {\n      if (!merged.clients.has(client)) {\n        // Write all missing keys from current ds and all following.\n        // If merged already contains `client` current ds has already been added.\n        /**\n         * @type {Array<DeleteItem>}\n         */\n        const dels = delsLeft.slice();\n        for (let i = dssI + 1; i < dss.length; i++) {\n          array.appendTo(dels, dss[i].clients.get(client) || []);\n        }\n        merged.clients.set(client, dels);\n      }\n    });\n  }\n  sortAndMergeDeleteSet(merged);\n  return merged\n};\n\n/**\n * @param {DeleteSet} ds\n * @param {number} client\n * @param {number} clock\n * @param {number} length\n *\n * @private\n * @function\n */\nconst addToDeleteSet = (ds, client, clock, length) => {\n  map.setIfUndefined(ds.clients, client, () => /** @type {Array<DeleteItem>} */ ([])).push(new DeleteItem(clock, length));\n};\n\nconst createDeleteSet = () => new DeleteSet();\n\n/**\n * @param {StructStore} ss\n * @return {DeleteSet} Merged and sorted DeleteSet\n *\n * @private\n * @function\n */\nconst createDeleteSetFromStructStore = ss => {\n  const ds = createDeleteSet();\n  ss.clients.forEach((structs, client) => {\n    /**\n     * @type {Array<DeleteItem>}\n     */\n    const dsitems = [];\n    for (let i = 0; i < structs.length; i++) {\n      const struct = structs[i];\n      if (struct.deleted) {\n        const clock = struct.id.clock;\n        let len = struct.length;\n        if (i + 1 < structs.length) {\n          for (let next = structs[i + 1]; i + 1 < structs.length && next.deleted; next = structs[++i + 1]) {\n            len += next.length;\n          }\n        }\n        dsitems.push(new DeleteItem(clock, len));\n      }\n    }\n    if (dsitems.length > 0) {\n      ds.clients.set(client, dsitems);\n    }\n  });\n  return ds\n};\n\n/**\n * @param {DSEncoderV1 | DSEncoderV2} encoder\n * @param {DeleteSet} ds\n *\n * @private\n * @function\n */\nconst writeDeleteSet = (encoder, ds) => {\n  encoding.writeVarUint(encoder.restEncoder, ds.clients.size);\n\n  // Ensure that the delete set is written in a deterministic order\n  array.from(ds.clients.entries())\n    .sort((a, b) => b[0] - a[0])\n    .forEach(([client, dsitems]) => {\n      encoder.resetDsCurVal();\n      encoding.writeVarUint(encoder.restEncoder, client);\n      const len = dsitems.length;\n      encoding.writeVarUint(encoder.restEncoder, len);\n      for (let i = 0; i < len; i++) {\n        const item = dsitems[i];\n        encoder.writeDsClock(item.clock);\n        encoder.writeDsLen(item.len);\n      }\n    });\n};\n\n/**\n * @param {DSDecoderV1 | DSDecoderV2} decoder\n * @return {DeleteSet}\n *\n * @private\n * @function\n */\nconst readDeleteSet = decoder => {\n  const ds = new DeleteSet();\n  const numClients = decoding.readVarUint(decoder.restDecoder);\n  for (let i = 0; i < numClients; i++) {\n    decoder.resetDsCurVal();\n    const client = decoding.readVarUint(decoder.restDecoder);\n    const numberOfDeletes = decoding.readVarUint(decoder.restDecoder);\n    if (numberOfDeletes > 0) {\n      const dsField = map.setIfUndefined(ds.clients, client, () => /** @type {Array<DeleteItem>} */ ([]));\n      for (let i = 0; i < numberOfDeletes; i++) {\n        dsField.push(new DeleteItem(decoder.readDsClock(), decoder.readDsLen()));\n      }\n    }\n  }\n  return ds\n};\n\n/**\n * @todo YDecoder also contains references to String and other Decoders. Would make sense to exchange YDecoder.toUint8Array for YDecoder.DsToUint8Array()..\n */\n\n/**\n * @param {DSDecoderV1 | DSDecoderV2} decoder\n * @param {Transaction} transaction\n * @param {StructStore} store\n * @return {Uint8Array|null} Returns a v2 update containing all deletes that couldn't be applied yet; or null if all deletes were applied successfully.\n *\n * @private\n * @function\n */\nconst readAndApplyDeleteSet = (decoder, transaction, store) => {\n  const unappliedDS = new DeleteSet();\n  const numClients = decoding.readVarUint(decoder.restDecoder);\n  for (let i = 0; i < numClients; i++) {\n    decoder.resetDsCurVal();\n    const client = decoding.readVarUint(decoder.restDecoder);\n    const numberOfDeletes = decoding.readVarUint(decoder.restDecoder);\n    const structs = store.clients.get(client) || [];\n    const state = getState(store, client);\n    for (let i = 0; i < numberOfDeletes; i++) {\n      const clock = decoder.readDsClock();\n      const clockEnd = clock + decoder.readDsLen();\n      if (clock < state) {\n        if (state < clockEnd) {\n          addToDeleteSet(unappliedDS, client, state, clockEnd - state);\n        }\n        let index = findIndexSS(structs, clock);\n        /**\n         * We can ignore the case of GC and Delete structs, because we are going to skip them\n         * @type {Item}\n         */\n        // @ts-ignore\n        let struct = structs[index];\n        // split the first item if necessary\n        if (!struct.deleted && struct.id.clock < clock) {\n          structs.splice(index + 1, 0, splitItem(transaction, struct, clock - struct.id.clock));\n          index++; // increase we now want to use the next struct\n        }\n        while (index < structs.length) {\n          // @ts-ignore\n          struct = structs[index++];\n          if (struct.id.clock < clockEnd) {\n            if (!struct.deleted) {\n              if (clockEnd < struct.id.clock + struct.length) {\n                structs.splice(index, 0, splitItem(transaction, struct, clockEnd - struct.id.clock));\n              }\n              struct.delete(transaction);\n            }\n          } else {\n            break\n          }\n        }\n      } else {\n        addToDeleteSet(unappliedDS, client, clock, clockEnd - clock);\n      }\n    }\n  }\n  if (unappliedDS.clients.size > 0) {\n    const ds = new UpdateEncoderV2();\n    encoding.writeVarUint(ds.restEncoder, 0); // encode 0 structs\n    writeDeleteSet(ds, unappliedDS);\n    return ds.toUint8Array()\n  }\n  return null\n};\n\n/**\n * @param {DeleteSet} ds1\n * @param {DeleteSet} ds2\n */\nconst equalDeleteSets = (ds1, ds2) => {\n  if (ds1.clients.size !== ds2.clients.size) return false\n  for (const [client, deleteItems1] of ds1.clients.entries()) {\n    const deleteItems2 = /** @type {Array<import('../internals.js').DeleteItem>} */ (ds2.clients.get(client));\n    if (deleteItems2 === undefined || deleteItems1.length !== deleteItems2.length) return false\n    for (let i = 0; i < deleteItems1.length; i++) {\n      const di1 = deleteItems1[i];\n      const di2 = deleteItems2[i];\n      if (di1.clock !== di2.clock || di1.len !== di2.len) {\n        return false\n      }\n    }\n  }\n  return true\n};\n\n/**\n * @module Y\n */\n\nconst generateNewClientId = random.uint32;\n\n/**\n * @typedef {Object} DocOpts\n * @property {boolean} [DocOpts.gc=true] Disable garbage collection (default: gc=true)\n * @property {function(Item):boolean} [DocOpts.gcFilter] Will be called before an Item is garbage collected. Return false to keep the Item.\n * @property {string} [DocOpts.guid] Define a globally unique identifier for this document\n * @property {string | null} [DocOpts.collectionid] Associate this document with a collection. This only plays a role if your provider has a concept of collection.\n * @property {any} [DocOpts.meta] Any kind of meta information you want to associate with this document. If this is a subdocument, remote peers will store the meta information as well.\n * @property {boolean} [DocOpts.autoLoad] If a subdocument, automatically load document. If this is a subdocument, remote peers will load the document as well automatically.\n * @property {boolean} [DocOpts.shouldLoad] Whether the document should be synced by the provider now. This is toggled to true when you call ydoc.load()\n */\n\n/**\n * A Yjs instance handles the state of shared data.\n * @extends Observable<string>\n */\nclass Doc extends Observable {\n  /**\n   * @param {DocOpts} opts configuration\n   */\n  constructor ({ guid = random.uuidv4(), collectionid = null, gc = true, gcFilter = () => true, meta = null, autoLoad = false, shouldLoad = true } = {}) {\n    super();\n    this.gc = gc;\n    this.gcFilter = gcFilter;\n    this.clientID = generateNewClientId();\n    this.guid = guid;\n    this.collectionid = collectionid;\n    /**\n     * @type {Map<string, AbstractType<YEvent<any>>>}\n     */\n    this.share = new Map();\n    this.store = new StructStore();\n    /**\n     * @type {Transaction | null}\n     */\n    this._transaction = null;\n    /**\n     * @type {Array<Transaction>}\n     */\n    this._transactionCleanups = [];\n    /**\n     * @type {Set<Doc>}\n     */\n    this.subdocs = new Set();\n    /**\n     * If this document is a subdocument - a document integrated into another document - then _item is defined.\n     * @type {Item?}\n     */\n    this._item = null;\n    this.shouldLoad = shouldLoad;\n    this.autoLoad = autoLoad;\n    this.meta = meta;\n    /**\n     * This is set to true when the persistence provider loaded the document from the database or when the `sync` event fires.\n     * Note that not all providers implement this feature. Provider authors are encouraged to fire the `load` event when the doc content is loaded from the database.\n     *\n     * @type {boolean}\n     */\n    this.isLoaded = false;\n    /**\n     * This is set to true when the connection provider has successfully synced with a backend.\n     * Note that when using peer-to-peer providers this event may not provide very useful.\n     * Also note that not all providers implement this feature. Provider authors are encouraged to fire\n     * the `sync` event when the doc has been synced (with `true` as a parameter) or if connection is\n     * lost (with false as a parameter).\n     */\n    this.isSynced = false;\n    /**\n     * Promise that resolves once the document has been loaded from a presistence provider.\n     */\n    this.whenLoaded = promise.create(resolve => {\n      this.on('load', () => {\n        this.isLoaded = true;\n        resolve(this);\n      });\n    });\n    const provideSyncedPromise = () => promise.create(resolve => {\n      /**\n       * @param {boolean} isSynced\n       */\n      const eventHandler = (isSynced) => {\n        if (isSynced === undefined || isSynced === true) {\n          this.off('sync', eventHandler);\n          resolve();\n        }\n      };\n      this.on('sync', eventHandler);\n    });\n    this.on('sync', isSynced => {\n      if (isSynced === false && this.isSynced) {\n        this.whenSynced = provideSyncedPromise();\n      }\n      this.isSynced = isSynced === undefined || isSynced === true;\n      if (!this.isLoaded) {\n        this.emit('load', []);\n      }\n    });\n    /**\n     * Promise that resolves once the document has been synced with a backend.\n     * This promise is recreated when the connection is lost.\n     * Note the documentation about the `isSynced` property.\n     */\n    this.whenSynced = provideSyncedPromise();\n  }\n\n  /**\n   * Notify the parent document that you request to load data into this subdocument (if it is a subdocument).\n   *\n   * `load()` might be used in the future to request any provider to load the most current data.\n   *\n   * It is safe to call `load()` multiple times.\n   */\n  load () {\n    const item = this._item;\n    if (item !== null && !this.shouldLoad) {\n      transact(/** @type {any} */ (item.parent).doc, transaction => {\n        transaction.subdocsLoaded.add(this);\n      }, null, true);\n    }\n    this.shouldLoad = true;\n  }\n\n  getSubdocs () {\n    return this.subdocs\n  }\n\n  getSubdocGuids () {\n    return new Set(array.from(this.subdocs).map(doc => doc.guid))\n  }\n\n  /**\n   * Changes that happen inside of a transaction are bundled. This means that\n   * the observer fires _after_ the transaction is finished and that all changes\n   * that happened inside of the transaction are sent as one message to the\n   * other peers.\n   *\n   * @template T\n   * @param {function(Transaction):T} f The function that should be executed as a transaction\n   * @param {any} [origin] Origin of who started the transaction. Will be stored on transaction.origin\n   * @return T\n   *\n   * @public\n   */\n  transact (f, origin = null) {\n    return transact(this, f, origin)\n  }\n\n  /**\n   * Define a shared data type.\n   *\n   * Multiple calls of `y.get(name, TypeConstructor)` yield the same result\n   * and do not overwrite each other. I.e.\n   * `y.define(name, Y.Array) === y.define(name, Y.Array)`\n   *\n   * After this method is called, the type is also available on `y.share.get(name)`.\n   *\n   * *Best Practices:*\n   * Define all types right after the Yjs instance is created and store them in a separate object.\n   * Also use the typed methods `getText(name)`, `getArray(name)`, ..\n   *\n   * @example\n   *   const y = new Y(..)\n   *   const appState = {\n   *     document: y.getText('document')\n   *     comments: y.getArray('comments')\n   *   }\n   *\n   * @param {string} name\n   * @param {Function} TypeConstructor The constructor of the type definition. E.g. Y.Text, Y.Array, Y.Map, ...\n   * @return {AbstractType<any>} The created type. Constructed with TypeConstructor\n   *\n   * @public\n   */\n  get (name, TypeConstructor = AbstractType) {\n    const type = map.setIfUndefined(this.share, name, () => {\n      // @ts-ignore\n      const t = new TypeConstructor();\n      t._integrate(this, null);\n      return t\n    });\n    const Constr = type.constructor;\n    if (TypeConstructor !== AbstractType && Constr !== TypeConstructor) {\n      if (Constr === AbstractType) {\n        // @ts-ignore\n        const t = new TypeConstructor();\n        t._map = type._map;\n        type._map.forEach(/** @param {Item?} n */ n => {\n          for (; n !== null; n = n.left) {\n            // @ts-ignore\n            n.parent = t;\n          }\n        });\n        t._start = type._start;\n        for (let n = t._start; n !== null; n = n.right) {\n          n.parent = t;\n        }\n        t._length = type._length;\n        this.share.set(name, t);\n        t._integrate(this, null);\n        return t\n      } else {\n        throw new Error(`Type with the name ${name} has already been defined with a different constructor`)\n      }\n    }\n    return type\n  }\n\n  /**\n   * @template T\n   * @param {string} [name]\n   * @return {YArray<T>}\n   *\n   * @public\n   */\n  getArray (name = '') {\n    // @ts-ignore\n    return this.get(name, YArray)\n  }\n\n  /**\n   * @param {string} [name]\n   * @return {YText}\n   *\n   * @public\n   */\n  getText (name = '') {\n    // @ts-ignore\n    return this.get(name, YText)\n  }\n\n  /**\n   * @template T\n   * @param {string} [name]\n   * @return {YMap<T>}\n   *\n   * @public\n   */\n  getMap (name = '') {\n    // @ts-ignore\n    return this.get(name, YMap)\n  }\n\n  /**\n   * @param {string} [name]\n   * @return {YXmlFragment}\n   *\n   * @public\n   */\n  getXmlFragment (name = '') {\n    // @ts-ignore\n    return this.get(name, YXmlFragment)\n  }\n\n  /**\n   * Converts the entire document into a js object, recursively traversing each yjs type\n   * Doesn't log types that have not been defined (using ydoc.getType(..)).\n   *\n   * @deprecated Do not use this method and rather call toJSON directly on the shared types.\n   *\n   * @return {Object<string, any>}\n   */\n  toJSON () {\n    /**\n     * @type {Object<string, any>}\n     */\n    const doc = {};\n\n    this.share.forEach((value, key) => {\n      doc[key] = value.toJSON();\n    });\n\n    return doc\n  }\n\n  /**\n   * Emit `destroy` event and unregister all event handlers.\n   */\n  destroy () {\n    array.from(this.subdocs).forEach(subdoc => subdoc.destroy());\n    const item = this._item;\n    if (item !== null) {\n      this._item = null;\n      const content = /** @type {ContentDoc} */ (item.content);\n      content.doc = new Doc({ guid: this.guid, ...content.opts, shouldLoad: false });\n      content.doc._item = item;\n      transact(/** @type {any} */ (item).parent.doc, transaction => {\n        const doc = content.doc;\n        if (!item.deleted) {\n          transaction.subdocsAdded.add(doc);\n        }\n        transaction.subdocsRemoved.add(this);\n      }, null, true);\n    }\n    this.emit('destroyed', [true]);\n    this.emit('destroy', [this]);\n    super.destroy();\n  }\n\n  /**\n   * @param {string} eventName\n   * @param {function(...any):any} f\n   */\n  on (eventName, f) {\n    super.on(eventName, f);\n  }\n\n  /**\n   * @param {string} eventName\n   * @param {function} f\n   */\n  off (eventName, f) {\n    super.off(eventName, f);\n  }\n}\n\nclass DSDecoderV1 {\n  /**\n   * @param {decoding.Decoder} decoder\n   */\n  constructor (decoder) {\n    this.restDecoder = decoder;\n  }\n\n  resetDsCurVal () {\n    // nop\n  }\n\n  /**\n   * @return {number}\n   */\n  readDsClock () {\n    return decoding.readVarUint(this.restDecoder)\n  }\n\n  /**\n   * @return {number}\n   */\n  readDsLen () {\n    return decoding.readVarUint(this.restDecoder)\n  }\n}\n\nclass UpdateDecoderV1 extends DSDecoderV1 {\n  /**\n   * @return {ID}\n   */\n  readLeftID () {\n    return createID(decoding.readVarUint(this.restDecoder), decoding.readVarUint(this.restDecoder))\n  }\n\n  /**\n   * @return {ID}\n   */\n  readRightID () {\n    return createID(decoding.readVarUint(this.restDecoder), decoding.readVarUint(this.restDecoder))\n  }\n\n  /**\n   * Read the next client id.\n   * Use this in favor of readID whenever possible to reduce the number of objects created.\n   */\n  readClient () {\n    return decoding.readVarUint(this.restDecoder)\n  }\n\n  /**\n   * @return {number} info An unsigned 8-bit integer\n   */\n  readInfo () {\n    return decoding.readUint8(this.restDecoder)\n  }\n\n  /**\n   * @return {string}\n   */\n  readString () {\n    return decoding.readVarString(this.restDecoder)\n  }\n\n  /**\n   * @return {boolean} isKey\n   */\n  readParentInfo () {\n    return decoding.readVarUint(this.restDecoder) === 1\n  }\n\n  /**\n   * @return {number} info An unsigned 8-bit integer\n   */\n  readTypeRef () {\n    return decoding.readVarUint(this.restDecoder)\n  }\n\n  /**\n   * Write len of a struct - well suited for Opt RLE encoder.\n   *\n   * @return {number} len\n   */\n  readLen () {\n    return decoding.readVarUint(this.restDecoder)\n  }\n\n  /**\n   * @return {any}\n   */\n  readAny () {\n    return decoding.readAny(this.restDecoder)\n  }\n\n  /**\n   * @return {Uint8Array}\n   */\n  readBuf () {\n    return buffer.copyUint8Array(decoding.readVarUint8Array(this.restDecoder))\n  }\n\n  /**\n   * Legacy implementation uses JSON parse. We use any-decoding in v2.\n   *\n   * @return {any}\n   */\n  readJSON () {\n    return JSON.parse(decoding.readVarString(this.restDecoder))\n  }\n\n  /**\n   * @return {string}\n   */\n  readKey () {\n    return decoding.readVarString(this.restDecoder)\n  }\n}\n\nclass DSDecoderV2 {\n  /**\n   * @param {decoding.Decoder} decoder\n   */\n  constructor (decoder) {\n    /**\n     * @private\n     */\n    this.dsCurrVal = 0;\n    this.restDecoder = decoder;\n  }\n\n  resetDsCurVal () {\n    this.dsCurrVal = 0;\n  }\n\n  /**\n   * @return {number}\n   */\n  readDsClock () {\n    this.dsCurrVal += decoding.readVarUint(this.restDecoder);\n    return this.dsCurrVal\n  }\n\n  /**\n   * @return {number}\n   */\n  readDsLen () {\n    const diff = decoding.readVarUint(this.restDecoder) + 1;\n    this.dsCurrVal += diff;\n    return diff\n  }\n}\n\nclass UpdateDecoderV2 extends DSDecoderV2 {\n  /**\n   * @param {decoding.Decoder} decoder\n   */\n  constructor (decoder) {\n    super(decoder);\n    /**\n     * List of cached keys. If the keys[id] does not exist, we read a new key\n     * from stringEncoder and push it to keys.\n     *\n     * @type {Array<string>}\n     */\n    this.keys = [];\n    decoding.readVarUint(decoder); // read feature flag - currently unused\n    this.keyClockDecoder = new decoding.IntDiffOptRleDecoder(decoding.readVarUint8Array(decoder));\n    this.clientDecoder = new decoding.UintOptRleDecoder(decoding.readVarUint8Array(decoder));\n    this.leftClockDecoder = new decoding.IntDiffOptRleDecoder(decoding.readVarUint8Array(decoder));\n    this.rightClockDecoder = new decoding.IntDiffOptRleDecoder(decoding.readVarUint8Array(decoder));\n    this.infoDecoder = new decoding.RleDecoder(decoding.readVarUint8Array(decoder), decoding.readUint8);\n    this.stringDecoder = new decoding.StringDecoder(decoding.readVarUint8Array(decoder));\n    this.parentInfoDecoder = new decoding.RleDecoder(decoding.readVarUint8Array(decoder), decoding.readUint8);\n    this.typeRefDecoder = new decoding.UintOptRleDecoder(decoding.readVarUint8Array(decoder));\n    this.lenDecoder = new decoding.UintOptRleDecoder(decoding.readVarUint8Array(decoder));\n  }\n\n  /**\n   * @return {ID}\n   */\n  readLeftID () {\n    return new ID(this.clientDecoder.read(), this.leftClockDecoder.read())\n  }\n\n  /**\n   * @return {ID}\n   */\n  readRightID () {\n    return new ID(this.clientDecoder.read(), this.rightClockDecoder.read())\n  }\n\n  /**\n   * Read the next client id.\n   * Use this in favor of readID whenever possible to reduce the number of objects created.\n   */\n  readClient () {\n    return this.clientDecoder.read()\n  }\n\n  /**\n   * @return {number} info An unsigned 8-bit integer\n   */\n  readInfo () {\n    return /** @type {number} */ (this.infoDecoder.read())\n  }\n\n  /**\n   * @return {string}\n   */\n  readString () {\n    return this.stringDecoder.read()\n  }\n\n  /**\n   * @return {boolean}\n   */\n  readParentInfo () {\n    return this.parentInfoDecoder.read() === 1\n  }\n\n  /**\n   * @return {number} An unsigned 8-bit integer\n   */\n  readTypeRef () {\n    return this.typeRefDecoder.read()\n  }\n\n  /**\n   * Write len of a struct - well suited for Opt RLE encoder.\n   *\n   * @return {number}\n   */\n  readLen () {\n    return this.lenDecoder.read()\n  }\n\n  /**\n   * @return {any}\n   */\n  readAny () {\n    return decoding.readAny(this.restDecoder)\n  }\n\n  /**\n   * @return {Uint8Array}\n   */\n  readBuf () {\n    return decoding.readVarUint8Array(this.restDecoder)\n  }\n\n  /**\n   * This is mainly here for legacy purposes.\n   *\n   * Initial we incoded objects using JSON. Now we use the much faster lib0/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.\n   *\n   * @return {any}\n   */\n  readJSON () {\n    return decoding.readAny(this.restDecoder)\n  }\n\n  /**\n   * @return {string}\n   */\n  readKey () {\n    const keyClock = this.keyClockDecoder.read();\n    if (keyClock < this.keys.length) {\n      return this.keys[keyClock]\n    } else {\n      const key = this.stringDecoder.read();\n      this.keys.push(key);\n      return key\n    }\n  }\n}\n\nclass DSEncoderV1 {\n  constructor () {\n    this.restEncoder = encoding.createEncoder();\n  }\n\n  toUint8Array () {\n    return encoding.toUint8Array(this.restEncoder)\n  }\n\n  resetDsCurVal () {\n    // nop\n  }\n\n  /**\n   * @param {number} clock\n   */\n  writeDsClock (clock) {\n    encoding.writeVarUint(this.restEncoder, clock);\n  }\n\n  /**\n   * @param {number} len\n   */\n  writeDsLen (len) {\n    encoding.writeVarUint(this.restEncoder, len);\n  }\n}\n\nclass UpdateEncoderV1 extends DSEncoderV1 {\n  /**\n   * @param {ID} id\n   */\n  writeLeftID (id) {\n    encoding.writeVarUint(this.restEncoder, id.client);\n    encoding.writeVarUint(this.restEncoder, id.clock);\n  }\n\n  /**\n   * @param {ID} id\n   */\n  writeRightID (id) {\n    encoding.writeVarUint(this.restEncoder, id.client);\n    encoding.writeVarUint(this.restEncoder, id.clock);\n  }\n\n  /**\n   * Use writeClient and writeClock instead of writeID if possible.\n   * @param {number} client\n   */\n  writeClient (client) {\n    encoding.writeVarUint(this.restEncoder, client);\n  }\n\n  /**\n   * @param {number} info An unsigned 8-bit integer\n   */\n  writeInfo (info) {\n    encoding.writeUint8(this.restEncoder, info);\n  }\n\n  /**\n   * @param {string} s\n   */\n  writeString (s) {\n    encoding.writeVarString(this.restEncoder, s);\n  }\n\n  /**\n   * @param {boolean} isYKey\n   */\n  writeParentInfo (isYKey) {\n    encoding.writeVarUint(this.restEncoder, isYKey ? 1 : 0);\n  }\n\n  /**\n   * @param {number} info An unsigned 8-bit integer\n   */\n  writeTypeRef (info) {\n    encoding.writeVarUint(this.restEncoder, info);\n  }\n\n  /**\n   * Write len of a struct - well suited for Opt RLE encoder.\n   *\n   * @param {number} len\n   */\n  writeLen (len) {\n    encoding.writeVarUint(this.restEncoder, len);\n  }\n\n  /**\n   * @param {any} any\n   */\n  writeAny (any) {\n    encoding.writeAny(this.restEncoder, any);\n  }\n\n  /**\n   * @param {Uint8Array} buf\n   */\n  writeBuf (buf) {\n    encoding.writeVarUint8Array(this.restEncoder, buf);\n  }\n\n  /**\n   * @param {any} embed\n   */\n  writeJSON (embed) {\n    encoding.writeVarString(this.restEncoder, JSON.stringify(embed));\n  }\n\n  /**\n   * @param {string} key\n   */\n  writeKey (key) {\n    encoding.writeVarString(this.restEncoder, key);\n  }\n}\n\nclass DSEncoderV2 {\n  constructor () {\n    this.restEncoder = encoding.createEncoder(); // encodes all the rest / non-optimized\n    this.dsCurrVal = 0;\n  }\n\n  toUint8Array () {\n    return encoding.toUint8Array(this.restEncoder)\n  }\n\n  resetDsCurVal () {\n    this.dsCurrVal = 0;\n  }\n\n  /**\n   * @param {number} clock\n   */\n  writeDsClock (clock) {\n    const diff = clock - this.dsCurrVal;\n    this.dsCurrVal = clock;\n    encoding.writeVarUint(this.restEncoder, diff);\n  }\n\n  /**\n   * @param {number} len\n   */\n  writeDsLen (len) {\n    if (len === 0) {\n      error.unexpectedCase();\n    }\n    encoding.writeVarUint(this.restEncoder, len - 1);\n    this.dsCurrVal += len;\n  }\n}\n\nclass UpdateEncoderV2 extends DSEncoderV2 {\n  constructor () {\n    super();\n    /**\n     * @type {Map<string,number>}\n     */\n    this.keyMap = new Map();\n    /**\n     * Refers to the next uniqe key-identifier to me used.\n     * See writeKey method for more information.\n     *\n     * @type {number}\n     */\n    this.keyClock = 0;\n    this.keyClockEncoder = new encoding.IntDiffOptRleEncoder();\n    this.clientEncoder = new encoding.UintOptRleEncoder();\n    this.leftClockEncoder = new encoding.IntDiffOptRleEncoder();\n    this.rightClockEncoder = new encoding.IntDiffOptRleEncoder();\n    this.infoEncoder = new encoding.RleEncoder(encoding.writeUint8);\n    this.stringEncoder = new encoding.StringEncoder();\n    this.parentInfoEncoder = new encoding.RleEncoder(encoding.writeUint8);\n    this.typeRefEncoder = new encoding.UintOptRleEncoder();\n    this.lenEncoder = new encoding.UintOptRleEncoder();\n  }\n\n  toUint8Array () {\n    const encoder = encoding.createEncoder();\n    encoding.writeVarUint(encoder, 0); // this is a feature flag that we might use in the future\n    encoding.writeVarUint8Array(encoder, this.keyClockEncoder.toUint8Array());\n    encoding.writeVarUint8Array(encoder, this.clientEncoder.toUint8Array());\n    encoding.writeVarUint8Array(encoder, this.leftClockEncoder.toUint8Array());\n    encoding.writeVarUint8Array(encoder, this.rightClockEncoder.toUint8Array());\n    encoding.writeVarUint8Array(encoder, encoding.toUint8Array(this.infoEncoder));\n    encoding.writeVarUint8Array(encoder, this.stringEncoder.toUint8Array());\n    encoding.writeVarUint8Array(encoder, encoding.toUint8Array(this.parentInfoEncoder));\n    encoding.writeVarUint8Array(encoder, this.typeRefEncoder.toUint8Array());\n    encoding.writeVarUint8Array(encoder, this.lenEncoder.toUint8Array());\n    // @note The rest encoder is appended! (note the missing var)\n    encoding.writeUint8Array(encoder, encoding.toUint8Array(this.restEncoder));\n    return encoding.toUint8Array(encoder)\n  }\n\n  /**\n   * @param {ID} id\n   */\n  writeLeftID (id) {\n    this.clientEncoder.write(id.client);\n    this.leftClockEncoder.write(id.clock);\n  }\n\n  /**\n   * @param {ID} id\n   */\n  writeRightID (id) {\n    this.clientEncoder.write(id.client);\n    this.rightClockEncoder.write(id.clock);\n  }\n\n  /**\n   * @param {number} client\n   */\n  writeClient (client) {\n    this.clientEncoder.write(client);\n  }\n\n  /**\n   * @param {number} info An unsigned 8-bit integer\n   */\n  writeInfo (info) {\n    this.infoEncoder.write(info);\n  }\n\n  /**\n   * @param {string} s\n   */\n  writeString (s) {\n    this.stringEncoder.write(s);\n  }\n\n  /**\n   * @param {boolean} isYKey\n   */\n  writeParentInfo (isYKey) {\n    this.parentInfoEncoder.write(isYKey ? 1 : 0);\n  }\n\n  /**\n   * @param {number} info An unsigned 8-bit integer\n   */\n  writeTypeRef (info) {\n    this.typeRefEncoder.write(info);\n  }\n\n  /**\n   * Write len of a struct - well suited for Opt RLE encoder.\n   *\n   * @param {number} len\n   */\n  writeLen (len) {\n    this.lenEncoder.write(len);\n  }\n\n  /**\n   * @param {any} any\n   */\n  writeAny (any) {\n    encoding.writeAny(this.restEncoder, any);\n  }\n\n  /**\n   * @param {Uint8Array} buf\n   */\n  writeBuf (buf) {\n    encoding.writeVarUint8Array(this.restEncoder, buf);\n  }\n\n  /**\n   * This is mainly here for legacy purposes.\n   *\n   * Initial we incoded objects using JSON. Now we use the much faster lib0/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.\n   *\n   * @param {any} embed\n   */\n  writeJSON (embed) {\n    encoding.writeAny(this.restEncoder, embed);\n  }\n\n  /**\n   * Property keys are often reused. For example, in y-prosemirror the key `bold` might\n   * occur very often. For a 3d application, the key `position` might occur very often.\n   *\n   * We cache these keys in a Map and refer to them via a unique number.\n   *\n   * @param {string} key\n   */\n  writeKey (key) {\n    const clock = this.keyMap.get(key);\n    if (clock === undefined) {\n      /**\n       * @todo uncomment to introduce this feature finally\n       *\n       * Background. The ContentFormat object was always encoded using writeKey, but the decoder used to use readString.\n       * Furthermore, I forgot to set the keyclock. So everything was working fine.\n       *\n       * However, this feature here is basically useless as it is not being used (it actually only consumes extra memory).\n       *\n       * I don't know yet how to reintroduce this feature..\n       *\n       * Older clients won't be able to read updates when we reintroduce this feature. So this should probably be done using a flag.\n       *\n       */\n      // this.keyMap.set(key, this.keyClock)\n      this.keyClockEncoder.write(this.keyClock++);\n      this.stringEncoder.write(key);\n    } else {\n      this.keyClockEncoder.write(clock);\n    }\n  }\n}\n\n/**\n * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n * @param {Array<GC|Item>} structs All structs by `client`\n * @param {number} client\n * @param {number} clock write structs starting with `ID(client,clock)`\n *\n * @function\n */\nconst writeStructs = (encoder, structs, client, clock) => {\n  // write first id\n  clock = math.max(clock, structs[0].id.clock); // make sure the first id exists\n  const startNewStructs = findIndexSS(structs, clock);\n  // write # encoded structs\n  encoding.writeVarUint(encoder.restEncoder, structs.length - startNewStructs);\n  encoder.writeClient(client);\n  encoding.writeVarUint(encoder.restEncoder, clock);\n  const firstStruct = structs[startNewStructs];\n  // write first struct with an offset\n  firstStruct.write(encoder, clock - firstStruct.id.clock);\n  for (let i = startNewStructs + 1; i < structs.length; i++) {\n    structs[i].write(encoder, 0);\n  }\n};\n\n/**\n * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n * @param {StructStore} store\n * @param {Map<number,number>} _sm\n *\n * @private\n * @function\n */\nconst writeClientsStructs = (encoder, store, _sm) => {\n  // we filter all valid _sm entries into sm\n  const sm = new Map();\n  _sm.forEach((clock, client) => {\n    // only write if new structs are available\n    if (getState(store, client) > clock) {\n      sm.set(client, clock);\n    }\n  });\n  getStateVector(store).forEach((_clock, client) => {\n    if (!_sm.has(client)) {\n      sm.set(client, 0);\n    }\n  });\n  // write # states that were updated\n  encoding.writeVarUint(encoder.restEncoder, sm.size);\n  // Write items with higher client ids first\n  // This heavily improves the conflict algorithm.\n  array.from(sm.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {\n    writeStructs(encoder, /** @type {Array<GC|Item>} */ (store.clients.get(client)), client, clock);\n  });\n};\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder The decoder object to read data from.\n * @param {Doc} doc\n * @return {Map<number, { i: number, refs: Array<Item | GC> }>}\n *\n * @private\n * @function\n */\nconst readClientsStructRefs = (decoder, doc) => {\n  /**\n   * @type {Map<number, { i: number, refs: Array<Item | GC> }>}\n   */\n  const clientRefs = map.create();\n  const numOfStateUpdates = decoding.readVarUint(decoder.restDecoder);\n  for (let i = 0; i < numOfStateUpdates; i++) {\n    const numberOfStructs = decoding.readVarUint(decoder.restDecoder);\n    /**\n     * @type {Array<GC|Item>}\n     */\n    const refs = new Array(numberOfStructs);\n    const client = decoder.readClient();\n    let clock = decoding.readVarUint(decoder.restDecoder);\n    // const start = performance.now()\n    clientRefs.set(client, { i: 0, refs });\n    for (let i = 0; i < numberOfStructs; i++) {\n      const info = decoder.readInfo();\n      switch (binary.BITS5 & info) {\n        case 0: { // GC\n          const len = decoder.readLen();\n          refs[i] = new GC(createID(client, clock), len);\n          clock += len;\n          break\n        }\n        case 10: { // Skip Struct (nothing to apply)\n          // @todo we could reduce the amount of checks by adding Skip struct to clientRefs so we know that something is missing.\n          const len = decoding.readVarUint(decoder.restDecoder);\n          refs[i] = new Skip(createID(client, clock), len);\n          clock += len;\n          break\n        }\n        default: { // Item with content\n          /**\n           * The optimized implementation doesn't use any variables because inlining variables is faster.\n           * Below a non-optimized version is shown that implements the basic algorithm with\n           * a few comments\n           */\n          const cantCopyParentInfo = (info & (binary.BIT7 | binary.BIT8)) === 0;\n          // If parent = null and neither left nor right are defined, then we know that `parent` is child of `y`\n          // and we read the next string as parentYKey.\n          // It indicates how we store/retrieve parent from `y.share`\n          // @type {string|null}\n          const struct = new Item(\n            createID(client, clock),\n            null, // leftd\n            (info & binary.BIT8) === binary.BIT8 ? decoder.readLeftID() : null, // origin\n            null, // right\n            (info & binary.BIT7) === binary.BIT7 ? decoder.readRightID() : null, // right origin\n            cantCopyParentInfo ? (decoder.readParentInfo() ? doc.get(decoder.readString()) : decoder.readLeftID()) : null, // parent\n            cantCopyParentInfo && (info & binary.BIT6) === binary.BIT6 ? decoder.readString() : null, // parentSub\n            readItemContent(decoder, info) // item content\n          );\n          /* A non-optimized implementation of the above algorithm:\n\n          // The item that was originally to the left of this item.\n          const origin = (info & binary.BIT8) === binary.BIT8 ? decoder.readLeftID() : null\n          // The item that was originally to the right of this item.\n          const rightOrigin = (info & binary.BIT7) === binary.BIT7 ? decoder.readRightID() : null\n          const cantCopyParentInfo = (info & (binary.BIT7 | binary.BIT8)) === 0\n          const hasParentYKey = cantCopyParentInfo ? decoder.readParentInfo() : false\n          // If parent = null and neither left nor right are defined, then we know that `parent` is child of `y`\n          // and we read the next string as parentYKey.\n          // It indicates how we store/retrieve parent from `y.share`\n          // @type {string|null}\n          const parentYKey = cantCopyParentInfo && hasParentYKey ? decoder.readString() : null\n\n          const struct = new Item(\n            createID(client, clock),\n            null, // leftd\n            origin, // origin\n            null, // right\n            rightOrigin, // right origin\n            cantCopyParentInfo && !hasParentYKey ? decoder.readLeftID() : (parentYKey !== null ? doc.get(parentYKey) : null), // parent\n            cantCopyParentInfo && (info & binary.BIT6) === binary.BIT6 ? decoder.readString() : null, // parentSub\n            readItemContent(decoder, info) // item content\n          )\n          */\n          refs[i] = struct;\n          clock += struct.length;\n        }\n      }\n    }\n    // console.log('time to read: ', performance.now() - start) // @todo remove\n  }\n  return clientRefs\n};\n\n/**\n * Resume computing structs generated by struct readers.\n *\n * While there is something to do, we integrate structs in this order\n * 1. top element on stack, if stack is not empty\n * 2. next element from current struct reader (if empty, use next struct reader)\n *\n * If struct causally depends on another struct (ref.missing), we put next reader of\n * `ref.id.client` on top of stack.\n *\n * At some point we find a struct that has no causal dependencies,\n * then we start emptying the stack.\n *\n * It is not possible to have circles: i.e. struct1 (from client1) depends on struct2 (from client2)\n * depends on struct3 (from client1). Therefore the max stack size is eqaul to `structReaders.length`.\n *\n * This method is implemented in a way so that we can resume computation if this update\n * causally depends on another update.\n *\n * @param {Transaction} transaction\n * @param {StructStore} store\n * @param {Map<number, { i: number, refs: (GC | Item)[] }>} clientsStructRefs\n * @return { null | { update: Uint8Array, missing: Map<number,number> } }\n *\n * @private\n * @function\n */\nconst integrateStructs = (transaction, store, clientsStructRefs) => {\n  /**\n   * @type {Array<Item | GC>}\n   */\n  const stack = [];\n  // sort them so that we take the higher id first, in case of conflicts the lower id will probably not conflict with the id from the higher user.\n  let clientsStructRefsIds = array.from(clientsStructRefs.keys()).sort((a, b) => a - b);\n  if (clientsStructRefsIds.length === 0) {\n    return null\n  }\n  const getNextStructTarget = () => {\n    if (clientsStructRefsIds.length === 0) {\n      return null\n    }\n    let nextStructsTarget = /** @type {{i:number,refs:Array<GC|Item>}} */ (clientsStructRefs.get(clientsStructRefsIds[clientsStructRefsIds.length - 1]));\n    while (nextStructsTarget.refs.length === nextStructsTarget.i) {\n      clientsStructRefsIds.pop();\n      if (clientsStructRefsIds.length > 0) {\n        nextStructsTarget = /** @type {{i:number,refs:Array<GC|Item>}} */ (clientsStructRefs.get(clientsStructRefsIds[clientsStructRefsIds.length - 1]));\n      } else {\n        return null\n      }\n    }\n    return nextStructsTarget\n  };\n  let curStructsTarget = getNextStructTarget();\n  if (curStructsTarget === null && stack.length === 0) {\n    return null\n  }\n\n  /**\n   * @type {StructStore}\n   */\n  const restStructs = new StructStore();\n  const missingSV = new Map();\n  /**\n   * @param {number} client\n   * @param {number} clock\n   */\n  const updateMissingSv = (client, clock) => {\n    const mclock = missingSV.get(client);\n    if (mclock == null || mclock > clock) {\n      missingSV.set(client, clock);\n    }\n  };\n  /**\n   * @type {GC|Item}\n   */\n  let stackHead = /** @type {any} */ (curStructsTarget).refs[/** @type {any} */ (curStructsTarget).i++];\n  // caching the state because it is used very often\n  const state = new Map();\n\n  const addStackToRestSS = () => {\n    for (const item of stack) {\n      const client = item.id.client;\n      const unapplicableItems = clientsStructRefs.get(client);\n      if (unapplicableItems) {\n        // decrement because we weren't able to apply previous operation\n        unapplicableItems.i--;\n        restStructs.clients.set(client, unapplicableItems.refs.slice(unapplicableItems.i));\n        clientsStructRefs.delete(client);\n        unapplicableItems.i = 0;\n        unapplicableItems.refs = [];\n      } else {\n        // item was the last item on clientsStructRefs and the field was already cleared. Add item to restStructs and continue\n        restStructs.clients.set(client, [item]);\n      }\n      // remove client from clientsStructRefsIds to prevent users from applying the same update again\n      clientsStructRefsIds = clientsStructRefsIds.filter(c => c !== client);\n    }\n    stack.length = 0;\n  };\n\n  // iterate over all struct readers until we are done\n  while (true) {\n    if (stackHead.constructor !== Skip) {\n      const localClock = map.setIfUndefined(state, stackHead.id.client, () => getState(store, stackHead.id.client));\n      const offset = localClock - stackHead.id.clock;\n      if (offset < 0) {\n        // update from the same client is missing\n        stack.push(stackHead);\n        updateMissingSv(stackHead.id.client, stackHead.id.clock - 1);\n        // hid a dead wall, add all items from stack to restSS\n        addStackToRestSS();\n      } else {\n        const missing = stackHead.getMissing(transaction, store);\n        if (missing !== null) {\n          stack.push(stackHead);\n          // get the struct reader that has the missing struct\n          /**\n           * @type {{ refs: Array<GC|Item>, i: number }}\n           */\n          const structRefs = clientsStructRefs.get(/** @type {number} */ (missing)) || { refs: [], i: 0 };\n          if (structRefs.refs.length === structRefs.i) {\n            // This update message causally depends on another update message that doesn't exist yet\n            updateMissingSv(/** @type {number} */ (missing), getState(store, missing));\n            addStackToRestSS();\n          } else {\n            stackHead = structRefs.refs[structRefs.i++];\n            continue\n          }\n        } else if (offset === 0 || offset < stackHead.length) {\n          // all fine, apply the stackhead\n          stackHead.integrate(transaction, offset);\n          state.set(stackHead.id.client, stackHead.id.clock + stackHead.length);\n        }\n      }\n    }\n    // iterate to next stackHead\n    if (stack.length > 0) {\n      stackHead = /** @type {GC|Item} */ (stack.pop());\n    } else if (curStructsTarget !== null && curStructsTarget.i < curStructsTarget.refs.length) {\n      stackHead = /** @type {GC|Item} */ (curStructsTarget.refs[curStructsTarget.i++]);\n    } else {\n      curStructsTarget = getNextStructTarget();\n      if (curStructsTarget === null) {\n        // we are done!\n        break\n      } else {\n        stackHead = /** @type {GC|Item} */ (curStructsTarget.refs[curStructsTarget.i++]);\n      }\n    }\n  }\n  if (restStructs.clients.size > 0) {\n    const encoder = new UpdateEncoderV2();\n    writeClientsStructs(encoder, restStructs, new Map());\n    // write empty deleteset\n    // writeDeleteSet(encoder, new DeleteSet())\n    encoding.writeVarUint(encoder.restEncoder, 0); // => no need for an extra function call, just write 0 deletes\n    return { missing: missingSV, update: encoder.toUint8Array() }\n  }\n  return null\n};\n\n/**\n * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n * @param {Transaction} transaction\n *\n * @private\n * @function\n */\nconst writeStructsFromTransaction = (encoder, transaction) => writeClientsStructs(encoder, transaction.doc.store, transaction.beforeState);\n\n/**\n * Read and apply a document update.\n *\n * This function has the same effect as `applyUpdate` but accepts an decoder.\n *\n * @param {decoding.Decoder} decoder\n * @param {Doc} ydoc\n * @param {any} [transactionOrigin] This will be stored on `transaction.origin` and `.on('update', (update, origin))`\n * @param {UpdateDecoderV1 | UpdateDecoderV2} [structDecoder]\n *\n * @function\n */\nconst readUpdateV2 = (decoder, ydoc, transactionOrigin, structDecoder = new UpdateDecoderV2(decoder)) =>\n  transact(ydoc, transaction => {\n    // force that transaction.local is set to non-local\n    transaction.local = false;\n    let retry = false;\n    const doc = transaction.doc;\n    const store = doc.store;\n    // let start = performance.now()\n    const ss = readClientsStructRefs(structDecoder, doc);\n    // console.log('time to read structs: ', performance.now() - start) // @todo remove\n    // start = performance.now()\n    // console.log('time to merge: ', performance.now() - start) // @todo remove\n    // start = performance.now()\n    const restStructs = integrateStructs(transaction, store, ss);\n    const pending = store.pendingStructs;\n    if (pending) {\n      // check if we can apply something\n      for (const [client, clock] of pending.missing) {\n        if (clock < getState(store, client)) {\n          retry = true;\n          break\n        }\n      }\n      if (restStructs) {\n        // merge restStructs into store.pending\n        for (const [client, clock] of restStructs.missing) {\n          const mclock = pending.missing.get(client);\n          if (mclock == null || mclock > clock) {\n            pending.missing.set(client, clock);\n          }\n        }\n        pending.update = mergeUpdatesV2([pending.update, restStructs.update]);\n      }\n    } else {\n      store.pendingStructs = restStructs;\n    }\n    // console.log('time to integrate: ', performance.now() - start) // @todo remove\n    // start = performance.now()\n    const dsRest = readAndApplyDeleteSet(structDecoder, transaction, store);\n    if (store.pendingDs) {\n      // @todo we could make a lower-bound state-vector check as we do above\n      const pendingDSUpdate = new UpdateDecoderV2(decoding.createDecoder(store.pendingDs));\n      decoding.readVarUint(pendingDSUpdate.restDecoder); // read 0 structs, because we only encode deletes in pendingdsupdate\n      const dsRest2 = readAndApplyDeleteSet(pendingDSUpdate, transaction, store);\n      if (dsRest && dsRest2) {\n        // case 1: ds1 != null && ds2 != null\n        store.pendingDs = mergeUpdatesV2([dsRest, dsRest2]);\n      } else {\n        // case 2: ds1 != null\n        // case 3: ds2 != null\n        // case 4: ds1 == null && ds2 == null\n        store.pendingDs = dsRest || dsRest2;\n      }\n    } else {\n      // Either dsRest == null && pendingDs == null OR dsRest != null\n      store.pendingDs = dsRest;\n    }\n    // console.log('time to cleanup: ', performance.now() - start) // @todo remove\n    // start = performance.now()\n\n    // console.log('time to resume delete readers: ', performance.now() - start) // @todo remove\n    // start = performance.now()\n    if (retry) {\n      const update = /** @type {{update: Uint8Array}} */ (store.pendingStructs).update;\n      store.pendingStructs = null;\n      applyUpdateV2(transaction.doc, update);\n    }\n  }, transactionOrigin, false);\n\n/**\n * Read and apply a document update.\n *\n * This function has the same effect as `applyUpdate` but accepts an decoder.\n *\n * @param {decoding.Decoder} decoder\n * @param {Doc} ydoc\n * @param {any} [transactionOrigin] This will be stored on `transaction.origin` and `.on('update', (update, origin))`\n *\n * @function\n */\nconst readUpdate = (decoder, ydoc, transactionOrigin) => readUpdateV2(decoder, ydoc, transactionOrigin, new UpdateDecoderV1(decoder));\n\n/**\n * Apply a document update created by, for example, `y.on('update', update => ..)` or `update = encodeStateAsUpdate()`.\n *\n * This function has the same effect as `readUpdate` but accepts an Uint8Array instead of a Decoder.\n *\n * @param {Doc} ydoc\n * @param {Uint8Array} update\n * @param {any} [transactionOrigin] This will be stored on `transaction.origin` and `.on('update', (update, origin))`\n * @param {typeof UpdateDecoderV1 | typeof UpdateDecoderV2} [YDecoder]\n *\n * @function\n */\nconst applyUpdateV2 = (ydoc, update, transactionOrigin, YDecoder = UpdateDecoderV2) => {\n  const decoder = decoding.createDecoder(update);\n  readUpdateV2(decoder, ydoc, transactionOrigin, new YDecoder(decoder));\n};\n\n/**\n * Apply a document update created by, for example, `y.on('update', update => ..)` or `update = encodeStateAsUpdate()`.\n *\n * This function has the same effect as `readUpdate` but accepts an Uint8Array instead of a Decoder.\n *\n * @param {Doc} ydoc\n * @param {Uint8Array} update\n * @param {any} [transactionOrigin] This will be stored on `transaction.origin` and `.on('update', (update, origin))`\n *\n * @function\n */\nconst applyUpdate = (ydoc, update, transactionOrigin) => applyUpdateV2(ydoc, update, transactionOrigin, UpdateDecoderV1);\n\n/**\n * Write all the document as a single update message. If you specify the state of the remote client (`targetStateVector`) it will\n * only write the operations that are missing.\n *\n * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n * @param {Doc} doc\n * @param {Map<number,number>} [targetStateVector] The state of the target that receives the update. Leave empty to write all known structs\n *\n * @function\n */\nconst writeStateAsUpdate = (encoder, doc, targetStateVector = new Map()) => {\n  writeClientsStructs(encoder, doc.store, targetStateVector);\n  writeDeleteSet(encoder, createDeleteSetFromStructStore(doc.store));\n};\n\n/**\n * Write all the document as a single update message that can be applied on the remote document. If you specify the state of the remote client (`targetState`) it will\n * only write the operations that are missing.\n *\n * Use `writeStateAsUpdate` instead if you are working with lib0/encoding.js#Encoder\n *\n * @param {Doc} doc\n * @param {Uint8Array} [encodedTargetStateVector] The state of the target that receives the update. Leave empty to write all known structs\n * @param {UpdateEncoderV1 | UpdateEncoderV2} [encoder]\n * @return {Uint8Array}\n *\n * @function\n */\nconst encodeStateAsUpdateV2 = (doc, encodedTargetStateVector = new Uint8Array([0]), encoder = new UpdateEncoderV2()) => {\n  const targetStateVector = decodeStateVector(encodedTargetStateVector);\n  writeStateAsUpdate(encoder, doc, targetStateVector);\n  const updates = [encoder.toUint8Array()];\n  // also add the pending updates (if there are any)\n  if (doc.store.pendingDs) {\n    updates.push(doc.store.pendingDs);\n  }\n  if (doc.store.pendingStructs) {\n    updates.push(diffUpdateV2(doc.store.pendingStructs.update, encodedTargetStateVector));\n  }\n  if (updates.length > 1) {\n    if (encoder.constructor === UpdateEncoderV1) {\n      return mergeUpdates(updates.map((update, i) => i === 0 ? update : convertUpdateFormatV2ToV1(update)))\n    } else if (encoder.constructor === UpdateEncoderV2) {\n      return mergeUpdatesV2(updates)\n    }\n  }\n  return updates[0]\n};\n\n/**\n * Write all the document as a single update message that can be applied on the remote document. If you specify the state of the remote client (`targetState`) it will\n * only write the operations that are missing.\n *\n * Use `writeStateAsUpdate` instead if you are working with lib0/encoding.js#Encoder\n *\n * @param {Doc} doc\n * @param {Uint8Array} [encodedTargetStateVector] The state of the target that receives the update. Leave empty to write all known structs\n * @return {Uint8Array}\n *\n * @function\n */\nconst encodeStateAsUpdate = (doc, encodedTargetStateVector) => encodeStateAsUpdateV2(doc, encodedTargetStateVector, new UpdateEncoderV1());\n\n/**\n * Read state vector from Decoder and return as Map\n *\n * @param {DSDecoderV1 | DSDecoderV2} decoder\n * @return {Map<number,number>} Maps `client` to the number next expected `clock` from that client.\n *\n * @function\n */\nconst readStateVector = decoder => {\n  const ss = new Map();\n  const ssLength = decoding.readVarUint(decoder.restDecoder);\n  for (let i = 0; i < ssLength; i++) {\n    const client = decoding.readVarUint(decoder.restDecoder);\n    const clock = decoding.readVarUint(decoder.restDecoder);\n    ss.set(client, clock);\n  }\n  return ss\n};\n\n/**\n * Read decodedState and return State as Map.\n *\n * @param {Uint8Array} decodedState\n * @return {Map<number,number>} Maps `client` to the number next expected `clock` from that client.\n *\n * @function\n */\n// export const decodeStateVectorV2 = decodedState => readStateVector(new DSDecoderV2(decoding.createDecoder(decodedState)))\n\n/**\n * Read decodedState and return State as Map.\n *\n * @param {Uint8Array} decodedState\n * @return {Map<number,number>} Maps `client` to the number next expected `clock` from that client.\n *\n * @function\n */\nconst decodeStateVector = decodedState => readStateVector(new DSDecoderV1(decoding.createDecoder(decodedState)));\n\n/**\n * @param {DSEncoderV1 | DSEncoderV2} encoder\n * @param {Map<number,number>} sv\n * @function\n */\nconst writeStateVector = (encoder, sv) => {\n  encoding.writeVarUint(encoder.restEncoder, sv.size);\n  array.from(sv.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {\n    encoding.writeVarUint(encoder.restEncoder, client); // @todo use a special client decoder that is based on mapping\n    encoding.writeVarUint(encoder.restEncoder, clock);\n  });\n  return encoder\n};\n\n/**\n * @param {DSEncoderV1 | DSEncoderV2} encoder\n * @param {Doc} doc\n *\n * @function\n */\nconst writeDocumentStateVector = (encoder, doc) => writeStateVector(encoder, getStateVector(doc.store));\n\n/**\n * Encode State as Uint8Array.\n *\n * @param {Doc|Map<number,number>} doc\n * @param {DSEncoderV1 | DSEncoderV2} [encoder]\n * @return {Uint8Array}\n *\n * @function\n */\nconst encodeStateVectorV2 = (doc, encoder = new DSEncoderV2()) => {\n  if (doc instanceof Map) {\n    writeStateVector(encoder, doc);\n  } else {\n    writeDocumentStateVector(encoder, doc);\n  }\n  return encoder.toUint8Array()\n};\n\n/**\n * Encode State as Uint8Array.\n *\n * @param {Doc|Map<number,number>} doc\n * @return {Uint8Array}\n *\n * @function\n */\nconst encodeStateVector = doc => encodeStateVectorV2(doc, new DSEncoderV1());\n\n/**\n * General event handler implementation.\n *\n * @template ARG0, ARG1\n *\n * @private\n */\nclass EventHandler {\n  constructor () {\n    /**\n     * @type {Array<function(ARG0, ARG1):void>}\n     */\n    this.l = [];\n  }\n}\n\n/**\n * @template ARG0,ARG1\n * @returns {EventHandler<ARG0,ARG1>}\n *\n * @private\n * @function\n */\nconst createEventHandler = () => new EventHandler();\n\n/**\n * Adds an event listener that is called when\n * {@link EventHandler#callEventListeners} is called.\n *\n * @template ARG0,ARG1\n * @param {EventHandler<ARG0,ARG1>} eventHandler\n * @param {function(ARG0,ARG1):void} f The event handler.\n *\n * @private\n * @function\n */\nconst addEventHandlerListener = (eventHandler, f) =>\n  eventHandler.l.push(f);\n\n/**\n * Removes an event listener.\n *\n * @template ARG0,ARG1\n * @param {EventHandler<ARG0,ARG1>} eventHandler\n * @param {function(ARG0,ARG1):void} f The event handler that was added with\n *                     {@link EventHandler#addEventListener}\n *\n * @private\n * @function\n */\nconst removeEventHandlerListener = (eventHandler, f) => {\n  const l = eventHandler.l;\n  const len = l.length;\n  eventHandler.l = l.filter(g => f !== g);\n  if (len === eventHandler.l.length) {\n    console.error('[yjs] Tried to remove event handler that doesn\\'t exist.');\n  }\n};\n\n/**\n * Call all event listeners that were added via\n * {@link EventHandler#addEventListener}.\n *\n * @template ARG0,ARG1\n * @param {EventHandler<ARG0,ARG1>} eventHandler\n * @param {ARG0} arg0\n * @param {ARG1} arg1\n *\n * @private\n * @function\n */\nconst callEventHandlerListeners = (eventHandler, arg0, arg1) =>\n  f.callAll(eventHandler.l, [arg0, arg1]);\n\nclass ID {\n  /**\n   * @param {number} client client id\n   * @param {number} clock unique per client id, continuous number\n   */\n  constructor (client, clock) {\n    /**\n     * Client id\n     * @type {number}\n     */\n    this.client = client;\n    /**\n     * unique per client id, continuous number\n     * @type {number}\n     */\n    this.clock = clock;\n  }\n}\n\n/**\n * @param {ID | null} a\n * @param {ID | null} b\n * @return {boolean}\n *\n * @function\n */\nconst compareIDs = (a, b) => a === b || (a !== null && b !== null && a.client === b.client && a.clock === b.clock);\n\n/**\n * @param {number} client\n * @param {number} clock\n *\n * @private\n * @function\n */\nconst createID = (client, clock) => new ID(client, clock);\n\n/**\n * @param {encoding.Encoder} encoder\n * @param {ID} id\n *\n * @private\n * @function\n */\nconst writeID = (encoder, id) => {\n  encoding.writeVarUint(encoder, id.client);\n  encoding.writeVarUint(encoder, id.clock);\n};\n\n/**\n * Read ID.\n * * If first varUint read is 0xFFFFFF a RootID is returned.\n * * Otherwise an ID is returned\n *\n * @param {decoding.Decoder} decoder\n * @return {ID}\n *\n * @private\n * @function\n */\nconst readID = decoder =>\n  createID(decoding.readVarUint(decoder), decoding.readVarUint(decoder));\n\n/**\n * The top types are mapped from y.share.get(keyname) => type.\n * `type` does not store any information about the `keyname`.\n * This function finds the correct `keyname` for `type` and throws otherwise.\n *\n * @param {AbstractType<any>} type\n * @return {string}\n *\n * @private\n * @function\n */\nconst findRootTypeKey = type => {\n  // @ts-ignore _y must be defined, otherwise unexpected case\n  for (const [key, value] of type.doc.share.entries()) {\n    if (value === type) {\n      return key\n    }\n  }\n  throw error.unexpectedCase()\n};\n\n/**\n * Check if `parent` is a parent of `child`.\n *\n * @param {AbstractType<any>} parent\n * @param {Item|null} child\n * @return {Boolean} Whether `parent` is a parent of `child`.\n *\n * @private\n * @function\n */\nconst isParentOf = (parent, child) => {\n  while (child !== null) {\n    if (child.parent === parent) {\n      return true\n    }\n    child = /** @type {AbstractType<any>} */ (child.parent)._item;\n  }\n  return false\n};\n\n/**\n * Convenient helper to log type information.\n *\n * Do not use in productive systems as the output can be immense!\n *\n * @param {AbstractType<any>} type\n */\nconst logType = type => {\n  const res = [];\n  let n = type._start;\n  while (n) {\n    res.push(n);\n    n = n.right;\n  }\n  console.log('Children: ', res);\n  console.log('Children content: ', res.filter(m => !m.deleted).map(m => m.content));\n};\n\nclass PermanentUserData {\n  /**\n   * @param {Doc} doc\n   * @param {YMap<any>} [storeType]\n   */\n  constructor (doc, storeType = doc.getMap('users')) {\n    /**\n     * @type {Map<string,DeleteSet>}\n     */\n    const dss = new Map();\n    this.yusers = storeType;\n    this.doc = doc;\n    /**\n     * Maps from clientid to userDescription\n     *\n     * @type {Map<number,string>}\n     */\n    this.clients = new Map();\n    this.dss = dss;\n    /**\n     * @param {YMap<any>} user\n     * @param {string} userDescription\n     */\n    const initUser = (user, userDescription) => {\n      /**\n       * @type {YArray<Uint8Array>}\n       */\n      const ds = user.get('ds');\n      const ids = user.get('ids');\n      const addClientId = /** @param {number} clientid */ clientid => this.clients.set(clientid, userDescription);\n      ds.observe(/** @param {YArrayEvent<any>} event */ event => {\n        event.changes.added.forEach(item => {\n          item.content.getContent().forEach(encodedDs => {\n            if (encodedDs instanceof Uint8Array) {\n              this.dss.set(userDescription, mergeDeleteSets([this.dss.get(userDescription) || createDeleteSet(), readDeleteSet(new DSDecoderV1(decoding.createDecoder(encodedDs)))]));\n            }\n          });\n        });\n      });\n      this.dss.set(userDescription, mergeDeleteSets(ds.map(encodedDs => readDeleteSet(new DSDecoderV1(decoding.createDecoder(encodedDs))))));\n      ids.observe(/** @param {YArrayEvent<any>} event */ event =>\n        event.changes.added.forEach(item => item.content.getContent().forEach(addClientId))\n      );\n      ids.forEach(addClientId);\n    };\n    // observe users\n    storeType.observe(event => {\n      event.keysChanged.forEach(userDescription =>\n        initUser(storeType.get(userDescription), userDescription)\n      );\n    });\n    // add intial data\n    storeType.forEach(initUser);\n  }\n\n  /**\n   * @param {Doc} doc\n   * @param {number} clientid\n   * @param {string} userDescription\n   * @param {Object} conf\n   * @param {function(Transaction, DeleteSet):boolean} [conf.filter]\n   */\n  setUserMapping (doc, clientid, userDescription, { filter = () => true } = {}) {\n    const users = this.yusers;\n    let user = users.get(userDescription);\n    if (!user) {\n      user = new YMap();\n      user.set('ids', new YArray());\n      user.set('ds', new YArray());\n      users.set(userDescription, user);\n    }\n    user.get('ids').push([clientid]);\n    users.observe(_event => {\n      setTimeout(() => {\n        const userOverwrite = users.get(userDescription);\n        if (userOverwrite !== user) {\n          // user was overwritten, port all data over to the next user object\n          // @todo Experiment with Y.Sets here\n          user = userOverwrite;\n          // @todo iterate over old type\n          this.clients.forEach((_userDescription, clientid) => {\n            if (userDescription === _userDescription) {\n              user.get('ids').push([clientid]);\n            }\n          });\n          const encoder = new DSEncoderV1();\n          const ds = this.dss.get(userDescription);\n          if (ds) {\n            writeDeleteSet(encoder, ds);\n            user.get('ds').push([encoder.toUint8Array()]);\n          }\n        }\n      }, 0);\n    });\n    doc.on('afterTransaction', /** @param {Transaction} transaction */ transaction => {\n      setTimeout(() => {\n        const yds = user.get('ds');\n        const ds = transaction.deleteSet;\n        if (transaction.local && ds.clients.size > 0 && filter(transaction, ds)) {\n          const encoder = new DSEncoderV1();\n          writeDeleteSet(encoder, ds);\n          yds.push([encoder.toUint8Array()]);\n        }\n      });\n    });\n  }\n\n  /**\n   * @param {number} clientid\n   * @return {any}\n   */\n  getUserByClientId (clientid) {\n    return this.clients.get(clientid) || null\n  }\n\n  /**\n   * @param {ID} id\n   * @return {string | null}\n   */\n  getUserByDeletedId (id) {\n    for (const [userDescription, ds] of this.dss.entries()) {\n      if (isDeleted(ds, id)) {\n        return userDescription\n      }\n    }\n    return null\n  }\n}\n\n/**\n * A relative position is based on the Yjs model and is not affected by document changes.\n * E.g. If you place a relative position before a certain character, it will always point to this character.\n * If you place a relative position at the end of a type, it will always point to the end of the type.\n *\n * A numeric position is often unsuited for user selections, because it does not change when content is inserted\n * before or after.\n *\n * ```Insert(0, 'x')('a|bc') = 'xa|bc'``` Where | is the relative position.\n *\n * One of the properties must be defined.\n *\n * @example\n *   // Current cursor position is at position 10\n *   const relativePosition = createRelativePositionFromIndex(yText, 10)\n *   // modify yText\n *   yText.insert(0, 'abc')\n *   yText.delete(3, 10)\n *   // Compute the cursor position\n *   const absolutePosition = createAbsolutePositionFromRelativePosition(y, relativePosition)\n *   absolutePosition.type === yText // => true\n *   console.log('cursor location is ' + absolutePosition.index) // => cursor location is 3\n *\n */\nclass RelativePosition {\n  /**\n   * @param {ID|null} type\n   * @param {string|null} tname\n   * @param {ID|null} item\n   * @param {number} assoc\n   */\n  constructor (type, tname, item, assoc = 0) {\n    /**\n     * @type {ID|null}\n     */\n    this.type = type;\n    /**\n     * @type {string|null}\n     */\n    this.tname = tname;\n    /**\n     * @type {ID | null}\n     */\n    this.item = item;\n    /**\n     * A relative position is associated to a specific character. By default\n     * assoc >= 0, the relative position is associated to the character\n     * after the meant position.\n     * I.e. position 1 in 'ab' is associated to character 'b'.\n     *\n     * If assoc < 0, then the relative position is associated to the caharacter\n     * before the meant position.\n     *\n     * @type {number}\n     */\n    this.assoc = assoc;\n  }\n}\n\n/**\n * @param {RelativePosition} rpos\n * @return {any}\n */\nconst relativePositionToJSON = rpos => {\n  const json = {};\n  if (rpos.type) {\n    json.type = rpos.type;\n  }\n  if (rpos.tname) {\n    json.tname = rpos.tname;\n  }\n  if (rpos.item) {\n    json.item = rpos.item;\n  }\n  if (rpos.assoc != null) {\n    json.assoc = rpos.assoc;\n  }\n  return json\n};\n\n/**\n * @param {any} json\n * @return {RelativePosition}\n *\n * @function\n */\nconst createRelativePositionFromJSON = json => new RelativePosition(json.type == null ? null : createID(json.type.client, json.type.clock), json.tname || null, json.item == null ? null : createID(json.item.client, json.item.clock), json.assoc == null ? 0 : json.assoc);\n\nclass AbsolutePosition {\n  /**\n   * @param {AbstractType<any>} type\n   * @param {number} index\n   * @param {number} [assoc]\n   */\n  constructor (type, index, assoc = 0) {\n    /**\n     * @type {AbstractType<any>}\n     */\n    this.type = type;\n    /**\n     * @type {number}\n     */\n    this.index = index;\n    this.assoc = assoc;\n  }\n}\n\n/**\n * @param {AbstractType<any>} type\n * @param {number} index\n * @param {number} [assoc]\n *\n * @function\n */\nconst createAbsolutePosition = (type, index, assoc = 0) => new AbsolutePosition(type, index, assoc);\n\n/**\n * @param {AbstractType<any>} type\n * @param {ID|null} item\n * @param {number} [assoc]\n *\n * @function\n */\nconst createRelativePosition = (type, item, assoc) => {\n  let typeid = null;\n  let tname = null;\n  if (type._item === null) {\n    tname = findRootTypeKey(type);\n  } else {\n    typeid = createID(type._item.id.client, type._item.id.clock);\n  }\n  return new RelativePosition(typeid, tname, item, assoc)\n};\n\n/**\n * Create a relativePosition based on a absolute position.\n *\n * @param {AbstractType<any>} type The base type (e.g. YText or YArray).\n * @param {number} index The absolute position.\n * @param {number} [assoc]\n * @return {RelativePosition}\n *\n * @function\n */\nconst createRelativePositionFromTypeIndex = (type, index, assoc = 0) => {\n  let t = type._start;\n  if (assoc < 0) {\n    // associated to the left character or the beginning of a type, increment index if possible.\n    if (index === 0) {\n      return createRelativePosition(type, null, assoc)\n    }\n    index--;\n  }\n  while (t !== null) {\n    if (!t.deleted && t.countable) {\n      if (t.length > index) {\n        // case 1: found position somewhere in the linked list\n        return createRelativePosition(type, createID(t.id.client, t.id.clock + index), assoc)\n      }\n      index -= t.length;\n    }\n    if (t.right === null && assoc < 0) {\n      // left-associated position, return last available id\n      return createRelativePosition(type, t.lastId, assoc)\n    }\n    t = t.right;\n  }\n  return createRelativePosition(type, null, assoc)\n};\n\n/**\n * @param {encoding.Encoder} encoder\n * @param {RelativePosition} rpos\n *\n * @function\n */\nconst writeRelativePosition = (encoder, rpos) => {\n  const { type, tname, item, assoc } = rpos;\n  if (item !== null) {\n    encoding.writeVarUint(encoder, 0);\n    writeID(encoder, item);\n  } else if (tname !== null) {\n    // case 2: found position at the end of the list and type is stored in y.share\n    encoding.writeUint8(encoder, 1);\n    encoding.writeVarString(encoder, tname);\n  } else if (type !== null) {\n    // case 3: found position at the end of the list and type is attached to an item\n    encoding.writeUint8(encoder, 2);\n    writeID(encoder, type);\n  } else {\n    throw error.unexpectedCase()\n  }\n  encoding.writeVarInt(encoder, assoc);\n  return encoder\n};\n\n/**\n * @param {RelativePosition} rpos\n * @return {Uint8Array}\n */\nconst encodeRelativePosition = rpos => {\n  const encoder = encoding.createEncoder();\n  writeRelativePosition(encoder, rpos);\n  return encoding.toUint8Array(encoder)\n};\n\n/**\n * @param {decoding.Decoder} decoder\n * @return {RelativePosition}\n *\n * @function\n */\nconst readRelativePosition = decoder => {\n  let type = null;\n  let tname = null;\n  let itemID = null;\n  switch (decoding.readVarUint(decoder)) {\n    case 0:\n      // case 1: found position somewhere in the linked list\n      itemID = readID(decoder);\n      break\n    case 1:\n      // case 2: found position at the end of the list and type is stored in y.share\n      tname = decoding.readVarString(decoder);\n      break\n    case 2: {\n      // case 3: found position at the end of the list and type is attached to an item\n      type = readID(decoder);\n    }\n  }\n  const assoc = decoding.hasContent(decoder) ? decoding.readVarInt(decoder) : 0;\n  return new RelativePosition(type, tname, itemID, assoc)\n};\n\n/**\n * @param {Uint8Array} uint8Array\n * @return {RelativePosition}\n */\nconst decodeRelativePosition = uint8Array => readRelativePosition(decoding.createDecoder(uint8Array));\n\n/**\n * @param {RelativePosition} rpos\n * @param {Doc} doc\n * @return {AbsolutePosition|null}\n *\n * @function\n */\nconst createAbsolutePositionFromRelativePosition = (rpos, doc) => {\n  const store = doc.store;\n  const rightID = rpos.item;\n  const typeID = rpos.type;\n  const tname = rpos.tname;\n  const assoc = rpos.assoc;\n  let type = null;\n  let index = 0;\n  if (rightID !== null) {\n    if (getState(store, rightID.client) <= rightID.clock) {\n      return null\n    }\n    const res = followRedone(store, rightID);\n    const right = res.item;\n    if (!(right instanceof Item)) {\n      return null\n    }\n    type = /** @type {AbstractType<any>} */ (right.parent);\n    if (type._item === null || !type._item.deleted) {\n      index = (right.deleted || !right.countable) ? 0 : (res.diff + (assoc >= 0 ? 0 : 1)); // adjust position based on left association if necessary\n      let n = right.left;\n      while (n !== null) {\n        if (!n.deleted && n.countable) {\n          index += n.length;\n        }\n        n = n.left;\n      }\n    }\n  } else {\n    if (tname !== null) {\n      type = doc.get(tname);\n    } else if (typeID !== null) {\n      if (getState(store, typeID.client) <= typeID.clock) {\n        // type does not exist yet\n        return null\n      }\n      const { item } = followRedone(store, typeID);\n      if (item instanceof Item && item.content instanceof ContentType) {\n        type = item.content.type;\n      } else {\n        // struct is garbage collected\n        return null\n      }\n    } else {\n      throw error.unexpectedCase()\n    }\n    if (assoc >= 0) {\n      index = type._length;\n    } else {\n      index = 0;\n    }\n  }\n  return createAbsolutePosition(type, index, rpos.assoc)\n};\n\n/**\n * @param {RelativePosition|null} a\n * @param {RelativePosition|null} b\n * @return {boolean}\n *\n * @function\n */\nconst compareRelativePositions = (a, b) => a === b || (\n  a !== null && b !== null && a.tname === b.tname && compareIDs(a.item, b.item) && compareIDs(a.type, b.type) && a.assoc === b.assoc\n);\n\nclass Snapshot {\n  /**\n   * @param {DeleteSet} ds\n   * @param {Map<number,number>} sv state map\n   */\n  constructor (ds, sv) {\n    /**\n     * @type {DeleteSet}\n     */\n    this.ds = ds;\n    /**\n     * State Map\n     * @type {Map<number,number>}\n     */\n    this.sv = sv;\n  }\n}\n\n/**\n * @param {Snapshot} snap1\n * @param {Snapshot} snap2\n * @return {boolean}\n */\nconst equalSnapshots = (snap1, snap2) => {\n  const ds1 = snap1.ds.clients;\n  const ds2 = snap2.ds.clients;\n  const sv1 = snap1.sv;\n  const sv2 = snap2.sv;\n  if (sv1.size !== sv2.size || ds1.size !== ds2.size) {\n    return false\n  }\n  for (const [key, value] of sv1.entries()) {\n    if (sv2.get(key) !== value) {\n      return false\n    }\n  }\n  for (const [client, dsitems1] of ds1.entries()) {\n    const dsitems2 = ds2.get(client) || [];\n    if (dsitems1.length !== dsitems2.length) {\n      return false\n    }\n    for (let i = 0; i < dsitems1.length; i++) {\n      const dsitem1 = dsitems1[i];\n      const dsitem2 = dsitems2[i];\n      if (dsitem1.clock !== dsitem2.clock || dsitem1.len !== dsitem2.len) {\n        return false\n      }\n    }\n  }\n  return true\n};\n\n/**\n * @param {Snapshot} snapshot\n * @param {DSEncoderV1 | DSEncoderV2} [encoder]\n * @return {Uint8Array}\n */\nconst encodeSnapshotV2 = (snapshot, encoder = new DSEncoderV2()) => {\n  writeDeleteSet(encoder, snapshot.ds);\n  writeStateVector(encoder, snapshot.sv);\n  return encoder.toUint8Array()\n};\n\n/**\n * @param {Snapshot} snapshot\n * @return {Uint8Array}\n */\nconst encodeSnapshot = snapshot => encodeSnapshotV2(snapshot, new DSEncoderV1());\n\n/**\n * @param {Uint8Array} buf\n * @param {DSDecoderV1 | DSDecoderV2} [decoder]\n * @return {Snapshot}\n */\nconst decodeSnapshotV2 = (buf, decoder = new DSDecoderV2(decoding.createDecoder(buf))) => {\n  return new Snapshot(readDeleteSet(decoder), readStateVector(decoder))\n};\n\n/**\n * @param {Uint8Array} buf\n * @return {Snapshot}\n */\nconst decodeSnapshot = buf => decodeSnapshotV2(buf, new DSDecoderV1(decoding.createDecoder(buf)));\n\n/**\n * @param {DeleteSet} ds\n * @param {Map<number,number>} sm\n * @return {Snapshot}\n */\nconst createSnapshot = (ds, sm) => new Snapshot(ds, sm);\n\nconst emptySnapshot = createSnapshot(createDeleteSet(), new Map());\n\n/**\n * @param {Doc} doc\n * @return {Snapshot}\n */\nconst snapshot = doc => createSnapshot(createDeleteSetFromStructStore(doc.store), getStateVector(doc.store));\n\n/**\n * @param {Item} item\n * @param {Snapshot|undefined} snapshot\n *\n * @protected\n * @function\n */\nconst isVisible = (item, snapshot) => snapshot === undefined\n  ? !item.deleted\n  : snapshot.sv.has(item.id.client) && (snapshot.sv.get(item.id.client) || 0) > item.id.clock && !isDeleted(snapshot.ds, item.id);\n\n/**\n * @param {Transaction} transaction\n * @param {Snapshot} snapshot\n */\nconst splitSnapshotAffectedStructs = (transaction, snapshot) => {\n  const meta = map.setIfUndefined(transaction.meta, splitSnapshotAffectedStructs, set.create);\n  const store = transaction.doc.store;\n  // check if we already split for this snapshot\n  if (!meta.has(snapshot)) {\n    snapshot.sv.forEach((clock, client) => {\n      if (clock < getState(store, client)) {\n        getItemCleanStart(transaction, createID(client, clock));\n      }\n    });\n    iterateDeletedStructs(transaction, snapshot.ds, _item => {});\n    meta.add(snapshot);\n  }\n};\n\n/**\n * @example\n *  const ydoc = new Y.Doc({ gc: false })\n *  ydoc.getText().insert(0, 'world!')\n *  const snapshot = Y.snapshot(ydoc)\n *  ydoc.getText().insert(0, 'hello ')\n *  const restored = Y.createDocFromSnapshot(ydoc, snapshot)\n *  assert(restored.getText().toString() === 'world!')\n *\n * @param {Doc} originDoc\n * @param {Snapshot} snapshot\n * @param {Doc} [newDoc] Optionally, you may define the Yjs document that receives the data from originDoc\n * @return {Doc}\n */\nconst createDocFromSnapshot = (originDoc, snapshot, newDoc = new Doc()) => {\n  if (originDoc.gc) {\n    // we should not try to restore a GC-ed document, because some of the restored items might have their content deleted\n    throw new Error('Garbage-collection must be disabled in `originDoc`!')\n  }\n  const { sv, ds } = snapshot;\n\n  const encoder = new UpdateEncoderV2();\n  originDoc.transact(transaction => {\n    let size = 0;\n    sv.forEach(clock => {\n      if (clock > 0) {\n        size++;\n      }\n    });\n    encoding.writeVarUint(encoder.restEncoder, size);\n    // splitting the structs before writing them to the encoder\n    for (const [client, clock] of sv) {\n      if (clock === 0) {\n        continue\n      }\n      if (clock < getState(originDoc.store, client)) {\n        getItemCleanStart(transaction, createID(client, clock));\n      }\n      const structs = originDoc.store.clients.get(client) || [];\n      const lastStructIndex = findIndexSS(structs, clock - 1);\n      // write # encoded structs\n      encoding.writeVarUint(encoder.restEncoder, lastStructIndex + 1);\n      encoder.writeClient(client);\n      // first clock written is 0\n      encoding.writeVarUint(encoder.restEncoder, 0);\n      for (let i = 0; i <= lastStructIndex; i++) {\n        structs[i].write(encoder, 0);\n      }\n    }\n    writeDeleteSet(encoder, ds);\n  });\n\n  applyUpdateV2(newDoc, encoder.toUint8Array(), 'snapshot');\n  return newDoc\n};\n\n/**\n * @param {Snapshot} snapshot\n * @param {Uint8Array} update\n * @param {typeof UpdateDecoderV2 | typeof UpdateDecoderV1} [YDecoder]\n */\nconst snapshotContainsUpdateV2 = (snapshot, update, YDecoder = UpdateDecoderV2) => {\n  const updateDecoder = new YDecoder(decoding.createDecoder(update));\n  const lazyDecoder = new LazyStructReader(updateDecoder, false);\n  for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {\n    if ((snapshot.sv.get(curr.id.client) || 0) < curr.id.clock + curr.length) {\n      return false\n    }\n  }\n  const mergedDS = mergeDeleteSets([snapshot.ds, readDeleteSet(updateDecoder)]);\n  return equalDeleteSets(snapshot.ds, mergedDS)\n};\n\n/**\n * @param {Snapshot} snapshot\n * @param {Uint8Array} update\n */\nconst snapshotContainsUpdate = (snapshot, update) => snapshotContainsUpdateV2(snapshot, update, UpdateDecoderV1);\n\nclass StructStore {\n  constructor () {\n    /**\n     * @type {Map<number,Array<GC|Item>>}\n     */\n    this.clients = new Map();\n    /**\n     * @type {null | { missing: Map<number, number>, update: Uint8Array }}\n     */\n    this.pendingStructs = null;\n    /**\n     * @type {null | Uint8Array}\n     */\n    this.pendingDs = null;\n  }\n}\n\n/**\n * Return the states as a Map<client,clock>.\n * Note that clock refers to the next expected clock id.\n *\n * @param {StructStore} store\n * @return {Map<number,number>}\n *\n * @public\n * @function\n */\nconst getStateVector = store => {\n  const sm = new Map();\n  store.clients.forEach((structs, client) => {\n    const struct = structs[structs.length - 1];\n    sm.set(client, struct.id.clock + struct.length);\n  });\n  return sm\n};\n\n/**\n * @param {StructStore} store\n * @param {number} client\n * @return {number}\n *\n * @public\n * @function\n */\nconst getState = (store, client) => {\n  const structs = store.clients.get(client);\n  if (structs === undefined) {\n    return 0\n  }\n  const lastStruct = structs[structs.length - 1];\n  return lastStruct.id.clock + lastStruct.length\n};\n\n/**\n * @param {StructStore} store\n * @param {GC|Item} struct\n *\n * @private\n * @function\n */\nconst addStruct = (store, struct) => {\n  let structs = store.clients.get(struct.id.client);\n  if (structs === undefined) {\n    structs = [];\n    store.clients.set(struct.id.client, structs);\n  } else {\n    const lastStruct = structs[structs.length - 1];\n    if (lastStruct.id.clock + lastStruct.length !== struct.id.clock) {\n      throw error.unexpectedCase()\n    }\n  }\n  structs.push(struct);\n};\n\n/**\n * Perform a binary search on a sorted array\n * @param {Array<Item|GC>} structs\n * @param {number} clock\n * @return {number}\n *\n * @private\n * @function\n */\nconst findIndexSS = (structs, clock) => {\n  let left = 0;\n  let right = structs.length - 1;\n  let mid = structs[right];\n  let midclock = mid.id.clock;\n  if (midclock === clock) {\n    return right\n  }\n  // @todo does it even make sense to pivot the search?\n  // If a good split misses, it might actually increase the time to find the correct item.\n  // Currently, the only advantage is that search with pivoting might find the item on the first try.\n  let midindex = math.floor((clock / (midclock + mid.length - 1)) * right); // pivoting the search\n  while (left <= right) {\n    mid = structs[midindex];\n    midclock = mid.id.clock;\n    if (midclock <= clock) {\n      if (clock < midclock + mid.length) {\n        return midindex\n      }\n      left = midindex + 1;\n    } else {\n      right = midindex - 1;\n    }\n    midindex = math.floor((left + right) / 2);\n  }\n  // Always check state before looking for a struct in StructStore\n  // Therefore the case of not finding a struct is unexpected\n  throw error.unexpectedCase()\n};\n\n/**\n * Expects that id is actually in store. This function throws or is an infinite loop otherwise.\n *\n * @param {StructStore} store\n * @param {ID} id\n * @return {GC|Item}\n *\n * @private\n * @function\n */\nconst find = (store, id) => {\n  /**\n   * @type {Array<GC|Item>}\n   */\n  // @ts-ignore\n  const structs = store.clients.get(id.client);\n  return structs[findIndexSS(structs, id.clock)]\n};\n\n/**\n * Expects that id is actually in store. This function throws or is an infinite loop otherwise.\n * @private\n * @function\n */\nconst getItem = /** @type {function(StructStore,ID):Item} */ (find);\n\n/**\n * @param {Transaction} transaction\n * @param {Array<Item|GC>} structs\n * @param {number} clock\n */\nconst findIndexCleanStart = (transaction, structs, clock) => {\n  const index = findIndexSS(structs, clock);\n  const struct = structs[index];\n  if (struct.id.clock < clock && struct instanceof Item) {\n    structs.splice(index + 1, 0, splitItem(transaction, struct, clock - struct.id.clock));\n    return index + 1\n  }\n  return index\n};\n\n/**\n * Expects that id is actually in store. This function throws or is an infinite loop otherwise.\n *\n * @param {Transaction} transaction\n * @param {ID} id\n * @return {Item}\n *\n * @private\n * @function\n */\nconst getItemCleanStart = (transaction, id) => {\n  const structs = /** @type {Array<Item>} */ (transaction.doc.store.clients.get(id.client));\n  return structs[findIndexCleanStart(transaction, structs, id.clock)]\n};\n\n/**\n * Expects that id is actually in store. This function throws or is an infinite loop otherwise.\n *\n * @param {Transaction} transaction\n * @param {StructStore} store\n * @param {ID} id\n * @return {Item}\n *\n * @private\n * @function\n */\nconst getItemCleanEnd = (transaction, store, id) => {\n  /**\n   * @type {Array<Item>}\n   */\n  // @ts-ignore\n  const structs = store.clients.get(id.client);\n  const index = findIndexSS(structs, id.clock);\n  const struct = structs[index];\n  if (id.clock !== struct.id.clock + struct.length - 1 && struct.constructor !== GC) {\n    structs.splice(index + 1, 0, splitItem(transaction, struct, id.clock - struct.id.clock + 1));\n  }\n  return struct\n};\n\n/**\n * Replace `item` with `newitem` in store\n * @param {StructStore} store\n * @param {GC|Item} struct\n * @param {GC|Item} newStruct\n *\n * @private\n * @function\n */\nconst replaceStruct = (store, struct, newStruct) => {\n  const structs = /** @type {Array<GC|Item>} */ (store.clients.get(struct.id.client));\n  structs[findIndexSS(structs, struct.id.clock)] = newStruct;\n};\n\n/**\n * Iterate over a range of structs\n *\n * @param {Transaction} transaction\n * @param {Array<Item|GC>} structs\n * @param {number} clockStart Inclusive start\n * @param {number} len\n * @param {function(GC|Item):void} f\n *\n * @function\n */\nconst iterateStructs = (transaction, structs, clockStart, len, f) => {\n  if (len === 0) {\n    return\n  }\n  const clockEnd = clockStart + len;\n  let index = findIndexCleanStart(transaction, structs, clockStart);\n  let struct;\n  do {\n    struct = structs[index++];\n    if (clockEnd < struct.id.clock + struct.length) {\n      findIndexCleanStart(transaction, structs, clockEnd);\n    }\n    f(struct);\n  } while (index < structs.length && structs[index].id.clock < clockEnd)\n};\n\n/**\n * A transaction is created for every change on the Yjs model. It is possible\n * to bundle changes on the Yjs model in a single transaction to\n * minimize the number on messages sent and the number of observer calls.\n * If possible the user of this library should bundle as many changes as\n * possible. Here is an example to illustrate the advantages of bundling:\n *\n * @example\n * const map = y.define('map', YMap)\n * // Log content when change is triggered\n * map.observe(() => {\n *   console.log('change triggered')\n * })\n * // Each change on the map type triggers a log message:\n * map.set('a', 0) // => \"change triggered\"\n * map.set('b', 0) // => \"change triggered\"\n * // When put in a transaction, it will trigger the log after the transaction:\n * y.transact(() => {\n *   map.set('a', 1)\n *   map.set('b', 1)\n * }) // => \"change triggered\"\n *\n * @public\n */\nclass Transaction {\n  /**\n   * @param {Doc} doc\n   * @param {any} origin\n   * @param {boolean} local\n   */\n  constructor (doc, origin, local) {\n    /**\n     * The Yjs instance.\n     * @type {Doc}\n     */\n    this.doc = doc;\n    /**\n     * Describes the set of deleted items by ids\n     * @type {DeleteSet}\n     */\n    this.deleteSet = new DeleteSet();\n    /**\n     * Holds the state before the transaction started.\n     * @type {Map<Number,Number>}\n     */\n    this.beforeState = getStateVector(doc.store);\n    /**\n     * Holds the state after the transaction.\n     * @type {Map<Number,Number>}\n     */\n    this.afterState = new Map();\n    /**\n     * All types that were directly modified (property added or child\n     * inserted/deleted). New types are not included in this Set.\n     * Maps from type to parentSubs (`item.parentSub = null` for YArray)\n     * @type {Map<AbstractType<YEvent<any>>,Set<String|null>>}\n     */\n    this.changed = new Map();\n    /**\n     * Stores the events for the types that observe also child elements.\n     * It is mainly used by `observeDeep`.\n     * @type {Map<AbstractType<YEvent<any>>,Array<YEvent<any>>>}\n     */\n    this.changedParentTypes = new Map();\n    /**\n     * @type {Array<AbstractStruct>}\n     */\n    this._mergeStructs = [];\n    /**\n     * @type {any}\n     */\n    this.origin = origin;\n    /**\n     * Stores meta information on the transaction\n     * @type {Map<any,any>}\n     */\n    this.meta = new Map();\n    /**\n     * Whether this change originates from this doc.\n     * @type {boolean}\n     */\n    this.local = local;\n    /**\n     * @type {Set<Doc>}\n     */\n    this.subdocsAdded = new Set();\n    /**\n     * @type {Set<Doc>}\n     */\n    this.subdocsRemoved = new Set();\n    /**\n     * @type {Set<Doc>}\n     */\n    this.subdocsLoaded = new Set();\n    /**\n     * @type {boolean}\n     */\n    this._needFormattingCleanup = false;\n  }\n}\n\n/**\n * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n * @param {Transaction} transaction\n * @return {boolean} Whether data was written.\n */\nconst writeUpdateMessageFromTransaction = (encoder, transaction) => {\n  if (transaction.deleteSet.clients.size === 0 && !map.any(transaction.afterState, (clock, client) => transaction.beforeState.get(client) !== clock)) {\n    return false\n  }\n  sortAndMergeDeleteSet(transaction.deleteSet);\n  writeStructsFromTransaction(encoder, transaction);\n  writeDeleteSet(encoder, transaction.deleteSet);\n  return true\n};\n\n/**\n * If `type.parent` was added in current transaction, `type` technically\n * did not change, it was just added and we should not fire events for `type`.\n *\n * @param {Transaction} transaction\n * @param {AbstractType<YEvent<any>>} type\n * @param {string|null} parentSub\n */\nconst addChangedTypeToTransaction = (transaction, type, parentSub) => {\n  const item = type._item;\n  if (item === null || (item.id.clock < (transaction.beforeState.get(item.id.client) || 0) && !item.deleted)) {\n    map.setIfUndefined(transaction.changed, type, set.create).add(parentSub);\n  }\n};\n\n/**\n * @param {Array<AbstractStruct>} structs\n * @param {number} pos\n * @return {number} # of merged structs\n */\nconst tryToMergeWithLefts = (structs, pos) => {\n  let right = structs[pos];\n  let left = structs[pos - 1];\n  let i = pos;\n  for (; i > 0; right = left, left = structs[--i - 1]) {\n    if (left.deleted === right.deleted && left.constructor === right.constructor) {\n      if (left.mergeWith(right)) {\n        if (right instanceof Item && right.parentSub !== null && /** @type {AbstractType<any>} */ (right.parent)._map.get(right.parentSub) === right) {\n          /** @type {AbstractType<any>} */ (right.parent)._map.set(right.parentSub, /** @type {Item} */ (left));\n        }\n        continue\n      }\n    }\n    break\n  }\n  const merged = pos - i;\n  if (merged) {\n    // remove all merged structs from the array\n    structs.splice(pos + 1 - merged, merged);\n  }\n  return merged\n};\n\n/**\n * @param {DeleteSet} ds\n * @param {StructStore} store\n * @param {function(Item):boolean} gcFilter\n */\nconst tryGcDeleteSet = (ds, store, gcFilter) => {\n  for (const [client, deleteItems] of ds.clients.entries()) {\n    const structs = /** @type {Array<GC|Item>} */ (store.clients.get(client));\n    for (let di = deleteItems.length - 1; di >= 0; di--) {\n      const deleteItem = deleteItems[di];\n      const endDeleteItemClock = deleteItem.clock + deleteItem.len;\n      for (\n        let si = findIndexSS(structs, deleteItem.clock), struct = structs[si];\n        si < structs.length && struct.id.clock < endDeleteItemClock;\n        struct = structs[++si]\n      ) {\n        const struct = structs[si];\n        if (deleteItem.clock + deleteItem.len <= struct.id.clock) {\n          break\n        }\n        if (struct instanceof Item && struct.deleted && !struct.keep && gcFilter(struct)) {\n          struct.gc(store, false);\n        }\n      }\n    }\n  }\n};\n\n/**\n * @param {DeleteSet} ds\n * @param {StructStore} store\n */\nconst tryMergeDeleteSet = (ds, store) => {\n  // try to merge deleted / gc'd items\n  // merge from right to left for better efficiecy and so we don't miss any merge targets\n  ds.clients.forEach((deleteItems, client) => {\n    const structs = /** @type {Array<GC|Item>} */ (store.clients.get(client));\n    for (let di = deleteItems.length - 1; di >= 0; di--) {\n      const deleteItem = deleteItems[di];\n      // start with merging the item next to the last deleted item\n      const mostRightIndexToCheck = math.min(structs.length - 1, 1 + findIndexSS(structs, deleteItem.clock + deleteItem.len - 1));\n      for (\n        let si = mostRightIndexToCheck, struct = structs[si];\n        si > 0 && struct.id.clock >= deleteItem.clock;\n        struct = structs[si]\n      ) {\n        si -= 1 + tryToMergeWithLefts(structs, si);\n      }\n    }\n  });\n};\n\n/**\n * @param {DeleteSet} ds\n * @param {StructStore} store\n * @param {function(Item):boolean} gcFilter\n */\nconst tryGc = (ds, store, gcFilter) => {\n  tryGcDeleteSet(ds, store, gcFilter);\n  tryMergeDeleteSet(ds, store);\n};\n\n/**\n * @param {Array<Transaction>} transactionCleanups\n * @param {number} i\n */\nconst cleanupTransactions = (transactionCleanups, i) => {\n  if (i < transactionCleanups.length) {\n    const transaction = transactionCleanups[i];\n    const doc = transaction.doc;\n    const store = doc.store;\n    const ds = transaction.deleteSet;\n    const mergeStructs = transaction._mergeStructs;\n    try {\n      sortAndMergeDeleteSet(ds);\n      transaction.afterState = getStateVector(transaction.doc.store);\n      doc.emit('beforeObserverCalls', [transaction, doc]);\n      /**\n       * An array of event callbacks.\n       *\n       * Each callback is called even if the other ones throw errors.\n       *\n       * @type {Array<function():void>}\n       */\n      const fs = [];\n      // observe events on changed types\n      transaction.changed.forEach((subs, itemtype) =>\n        fs.push(() => {\n          if (itemtype._item === null || !itemtype._item.deleted) {\n            itemtype._callObserver(transaction, subs);\n          }\n        })\n      );\n      fs.push(() => {\n        // deep observe events\n        transaction.changedParentTypes.forEach((events, type) => {\n          // We need to think about the possibility that the user transforms the\n          // Y.Doc in the event.\n          if (type._dEH.l.length > 0 && (type._item === null || !type._item.deleted)) {\n            events = events\n              .filter(event =>\n                event.target._item === null || !event.target._item.deleted\n              );\n            events\n              .forEach(event => {\n                event.currentTarget = type;\n                // path is relative to the current target\n                event._path = null;\n              });\n            // sort events by path length so that top-level events are fired first.\n            events\n              .sort((event1, event2) => event1.path.length - event2.path.length);\n            // We don't need to check for events.length\n            // because we know it has at least one element\n            callEventHandlerListeners(type._dEH, events, transaction);\n          }\n        });\n      });\n      fs.push(() => doc.emit('afterTransaction', [transaction, doc]));\n      callAll(fs, []);\n      if (transaction._needFormattingCleanup) {\n        cleanupYTextAfterTransaction(transaction);\n      }\n    } finally {\n      // Replace deleted items with ItemDeleted / GC.\n      // This is where content is actually remove from the Yjs Doc.\n      if (doc.gc) {\n        tryGcDeleteSet(ds, store, doc.gcFilter);\n      }\n      tryMergeDeleteSet(ds, store);\n\n      // on all affected store.clients props, try to merge\n      transaction.afterState.forEach((clock, client) => {\n        const beforeClock = transaction.beforeState.get(client) || 0;\n        if (beforeClock !== clock) {\n          const structs = /** @type {Array<GC|Item>} */ (store.clients.get(client));\n          // we iterate from right to left so we can safely remove entries\n          const firstChangePos = math.max(findIndexSS(structs, beforeClock), 1);\n          for (let i = structs.length - 1; i >= firstChangePos;) {\n            i -= 1 + tryToMergeWithLefts(structs, i);\n          }\n        }\n      });\n      // try to merge mergeStructs\n      // @todo: it makes more sense to transform mergeStructs to a DS, sort it, and merge from right to left\n      //        but at the moment DS does not handle duplicates\n      for (let i = mergeStructs.length - 1; i >= 0; i--) {\n        const { client, clock } = mergeStructs[i].id;\n        const structs = /** @type {Array<GC|Item>} */ (store.clients.get(client));\n        const replacedStructPos = findIndexSS(structs, clock);\n        if (replacedStructPos + 1 < structs.length) {\n          if (tryToMergeWithLefts(structs, replacedStructPos + 1) > 1) {\n            continue // no need to perform next check, both are already merged\n          }\n        }\n        if (replacedStructPos > 0) {\n          tryToMergeWithLefts(structs, replacedStructPos);\n        }\n      }\n      if (!transaction.local && transaction.afterState.get(doc.clientID) !== transaction.beforeState.get(doc.clientID)) {\n        logging.print(logging.ORANGE, logging.BOLD, '[yjs] ', logging.UNBOLD, logging.RED, 'Changed the client-id because another client seems to be using it.');\n        doc.clientID = generateNewClientId();\n      }\n      // @todo Merge all the transactions into one and provide send the data as a single update message\n      doc.emit('afterTransactionCleanup', [transaction, doc]);\n      if (doc._observers.has('update')) {\n        const encoder = new UpdateEncoderV1();\n        const hasContent = writeUpdateMessageFromTransaction(encoder, transaction);\n        if (hasContent) {\n          doc.emit('update', [encoder.toUint8Array(), transaction.origin, doc, transaction]);\n        }\n      }\n      if (doc._observers.has('updateV2')) {\n        const encoder = new UpdateEncoderV2();\n        const hasContent = writeUpdateMessageFromTransaction(encoder, transaction);\n        if (hasContent) {\n          doc.emit('updateV2', [encoder.toUint8Array(), transaction.origin, doc, transaction]);\n        }\n      }\n      const { subdocsAdded, subdocsLoaded, subdocsRemoved } = transaction;\n      if (subdocsAdded.size > 0 || subdocsRemoved.size > 0 || subdocsLoaded.size > 0) {\n        subdocsAdded.forEach(subdoc => {\n          subdoc.clientID = doc.clientID;\n          if (subdoc.collectionid == null) {\n            subdoc.collectionid = doc.collectionid;\n          }\n          doc.subdocs.add(subdoc);\n        });\n        subdocsRemoved.forEach(subdoc => doc.subdocs.delete(subdoc));\n        doc.emit('subdocs', [{ loaded: subdocsLoaded, added: subdocsAdded, removed: subdocsRemoved }, doc, transaction]);\n        subdocsRemoved.forEach(subdoc => subdoc.destroy());\n      }\n\n      if (transactionCleanups.length <= i + 1) {\n        doc._transactionCleanups = [];\n        doc.emit('afterAllTransactions', [doc, transactionCleanups]);\n      } else {\n        cleanupTransactions(transactionCleanups, i + 1);\n      }\n    }\n  }\n};\n\n/**\n * Implements the functionality of `y.transact(()=>{..})`\n *\n * @template T\n * @param {Doc} doc\n * @param {function(Transaction):T} f\n * @param {any} [origin=true]\n * @return {T}\n *\n * @function\n */\nconst transact = (doc, f, origin = null, local = true) => {\n  const transactionCleanups = doc._transactionCleanups;\n  let initialCall = false;\n  /**\n   * @type {any}\n   */\n  let result = null;\n  if (doc._transaction === null) {\n    initialCall = true;\n    doc._transaction = new Transaction(doc, origin, local);\n    transactionCleanups.push(doc._transaction);\n    if (transactionCleanups.length === 1) {\n      doc.emit('beforeAllTransactions', [doc]);\n    }\n    doc.emit('beforeTransaction', [doc._transaction, doc]);\n  }\n  try {\n    result = f(doc._transaction);\n  } finally {\n    if (initialCall) {\n      const finishCleanup = doc._transaction === transactionCleanups[0];\n      doc._transaction = null;\n      if (finishCleanup) {\n        // The first transaction ended, now process observer calls.\n        // Observer call may create new transactions for which we need to call the observers and do cleanup.\n        // We don't want to nest these calls, so we execute these calls one after\n        // another.\n        // Also we need to ensure that all cleanups are called, even if the\n        // observes throw errors.\n        // This file is full of hacky try {} finally {} blocks to ensure that an\n        // event can throw errors and also that the cleanup is called.\n        cleanupTransactions(transactionCleanups, 0);\n      }\n    }\n  }\n  return result\n};\n\nclass StackItem {\n  /**\n   * @param {DeleteSet} deletions\n   * @param {DeleteSet} insertions\n   */\n  constructor (deletions, insertions) {\n    this.insertions = insertions;\n    this.deletions = deletions;\n    /**\n     * Use this to save and restore metadata like selection range\n     */\n    this.meta = new Map();\n  }\n}\n/**\n * @param {Transaction} tr\n * @param {UndoManager} um\n * @param {StackItem} stackItem\n */\nconst clearUndoManagerStackItem = (tr, um, stackItem) => {\n  iterateDeletedStructs(tr, stackItem.deletions, item => {\n    if (item instanceof Item && um.scope.some(type => isParentOf(type, item))) {\n      keepItem(item, false);\n    }\n  });\n};\n\n/**\n * @param {UndoManager} undoManager\n * @param {Array<StackItem>} stack\n * @param {string} eventType\n * @return {StackItem?}\n */\nconst popStackItem = (undoManager, stack, eventType) => {\n  /**\n   * Whether a change happened\n   * @type {StackItem?}\n   */\n  let result = null;\n  /**\n   * Keep a reference to the transaction so we can fire the event with the changedParentTypes\n   * @type {any}\n   */\n  let _tr = null;\n  const doc = undoManager.doc;\n  const scope = undoManager.scope;\n  transact(doc, transaction => {\n    while (stack.length > 0 && result === null) {\n      const store = doc.store;\n      const stackItem = /** @type {StackItem} */ (stack.pop());\n      /**\n       * @type {Set<Item>}\n       */\n      const itemsToRedo = new Set();\n      /**\n       * @type {Array<Item>}\n       */\n      const itemsToDelete = [];\n      let performedChange = false;\n      iterateDeletedStructs(transaction, stackItem.insertions, struct => {\n        if (struct instanceof Item) {\n          if (struct.redone !== null) {\n            let { item, diff } = followRedone(store, struct.id);\n            if (diff > 0) {\n              item = getItemCleanStart(transaction, createID(item.id.client, item.id.clock + diff));\n            }\n            struct = item;\n          }\n          if (!struct.deleted && scope.some(type => isParentOf(type, /** @type {Item} */ (struct)))) {\n            itemsToDelete.push(struct);\n          }\n        }\n      });\n      iterateDeletedStructs(transaction, stackItem.deletions, struct => {\n        if (\n          struct instanceof Item &&\n          scope.some(type => isParentOf(type, struct)) &&\n          // Never redo structs in stackItem.insertions because they were created and deleted in the same capture interval.\n          !isDeleted(stackItem.insertions, struct.id)\n        ) {\n          itemsToRedo.add(struct);\n        }\n      });\n      itemsToRedo.forEach(struct => {\n        performedChange = redoItem(transaction, struct, itemsToRedo, stackItem.insertions, undoManager.ignoreRemoteMapChanges, undoManager) !== null || performedChange;\n      });\n      // We want to delete in reverse order so that children are deleted before\n      // parents, so we have more information available when items are filtered.\n      for (let i = itemsToDelete.length - 1; i >= 0; i--) {\n        const item = itemsToDelete[i];\n        if (undoManager.deleteFilter(item)) {\n          item.delete(transaction);\n          performedChange = true;\n        }\n      }\n      result = performedChange ? stackItem : null;\n    }\n    transaction.changed.forEach((subProps, type) => {\n      // destroy search marker if necessary\n      if (subProps.has(null) && type._searchMarker) {\n        type._searchMarker.length = 0;\n      }\n    });\n    _tr = transaction;\n  }, undoManager);\n  if (result != null) {\n    const changedParentTypes = _tr.changedParentTypes;\n    undoManager.emit('stack-item-popped', [{ stackItem: result, type: eventType, changedParentTypes }, undoManager]);\n  }\n  return result\n};\n\n/**\n * @typedef {Object} UndoManagerOptions\n * @property {number} [UndoManagerOptions.captureTimeout=500]\n * @property {function(Transaction):boolean} [UndoManagerOptions.captureTransaction] Do not capture changes of a Transaction if result false.\n * @property {function(Item):boolean} [UndoManagerOptions.deleteFilter=()=>true] Sometimes\n * it is necessary to filter what an Undo/Redo operation can delete. If this\n * filter returns false, the type/item won't be deleted even it is in the\n * undo/redo scope.\n * @property {Set<any>} [UndoManagerOptions.trackedOrigins=new Set([null])]\n * @property {boolean} [ignoreRemoteMapChanges] Experimental. By default, the UndoManager will never overwrite remote changes. Enable this property to enable overwriting remote changes on key-value changes (Y.Map, properties on Y.Xml, etc..).\n * @property {Doc} [doc] The document that this UndoManager operates on. Only needed if typeScope is empty.\n */\n\n/**\n * Fires 'stack-item-added' event when a stack item was added to either the undo- or\n * the redo-stack. You may store additional stack information via the\n * metadata property on `event.stackItem.meta` (it is a `Map` of metadata properties).\n * Fires 'stack-item-popped' event when a stack item was popped from either the\n * undo- or the redo-stack. You may restore the saved stack information from `event.stackItem.meta`.\n *\n * @extends {Observable<'stack-item-added'|'stack-item-popped'|'stack-cleared'|'stack-item-updated'>}\n */\nclass UndoManager extends Observable {\n  /**\n   * @param {AbstractType<any>|Array<AbstractType<any>>} typeScope Accepts either a single type, or an array of types\n   * @param {UndoManagerOptions} options\n   */\n  constructor (typeScope, {\n    captureTimeout = 500,\n    captureTransaction = _tr => true,\n    deleteFilter = () => true,\n    trackedOrigins = new Set([null]),\n    ignoreRemoteMapChanges = false,\n    doc = /** @type {Doc} */ (array.isArray(typeScope) ? typeScope[0].doc : typeScope.doc)\n  } = {}) {\n    super();\n    /**\n     * @type {Array<AbstractType<any>>}\n     */\n    this.scope = [];\n    this.addToScope(typeScope);\n    this.deleteFilter = deleteFilter;\n    trackedOrigins.add(this);\n    this.trackedOrigins = trackedOrigins;\n    this.captureTransaction = captureTransaction;\n    /**\n     * @type {Array<StackItem>}\n     */\n    this.undoStack = [];\n    /**\n     * @type {Array<StackItem>}\n     */\n    this.redoStack = [];\n    /**\n     * Whether the client is currently undoing (calling UndoManager.undo)\n     *\n     * @type {boolean}\n     */\n    this.undoing = false;\n    this.redoing = false;\n    this.doc = doc;\n    this.lastChange = 0;\n    this.ignoreRemoteMapChanges = ignoreRemoteMapChanges;\n    this.captureTimeout = captureTimeout;\n    /**\n     * @param {Transaction} transaction\n     */\n    this.afterTransactionHandler = transaction => {\n      // Only track certain transactions\n      if (\n        !this.captureTransaction(transaction) ||\n        !this.scope.some(type => transaction.changedParentTypes.has(type)) ||\n        (!this.trackedOrigins.has(transaction.origin) && (!transaction.origin || !this.trackedOrigins.has(transaction.origin.constructor)))\n      ) {\n        return\n      }\n      const undoing = this.undoing;\n      const redoing = this.redoing;\n      const stack = undoing ? this.redoStack : this.undoStack;\n      if (undoing) {\n        this.stopCapturing(); // next undo should not be appended to last stack item\n      } else if (!redoing) {\n        // neither undoing nor redoing: delete redoStack\n        this.clear(false, true);\n      }\n      const insertions = new DeleteSet();\n      transaction.afterState.forEach((endClock, client) => {\n        const startClock = transaction.beforeState.get(client) || 0;\n        const len = endClock - startClock;\n        if (len > 0) {\n          addToDeleteSet(insertions, client, startClock, len);\n        }\n      });\n      const now = time.getUnixTime();\n      let didAdd = false;\n      if (this.lastChange > 0 && now - this.lastChange < this.captureTimeout && stack.length > 0 && !undoing && !redoing) {\n        // append change to last stack op\n        const lastOp = stack[stack.length - 1];\n        lastOp.deletions = mergeDeleteSets([lastOp.deletions, transaction.deleteSet]);\n        lastOp.insertions = mergeDeleteSets([lastOp.insertions, insertions]);\n      } else {\n        // create a new stack op\n        stack.push(new StackItem(transaction.deleteSet, insertions));\n        didAdd = true;\n      }\n      if (!undoing && !redoing) {\n        this.lastChange = now;\n      }\n      // make sure that deleted structs are not gc'd\n      iterateDeletedStructs(transaction, transaction.deleteSet, /** @param {Item|GC} item */ item => {\n        if (item instanceof Item && this.scope.some(type => isParentOf(type, item))) {\n          keepItem(item, true);\n        }\n      });\n      const changeEvent = [{ stackItem: stack[stack.length - 1], origin: transaction.origin, type: undoing ? 'redo' : 'undo', changedParentTypes: transaction.changedParentTypes }, this];\n      if (didAdd) {\n        this.emit('stack-item-added', changeEvent);\n      } else {\n        this.emit('stack-item-updated', changeEvent);\n      }\n    };\n    this.doc.on('afterTransaction', this.afterTransactionHandler);\n    this.doc.on('destroy', () => {\n      this.destroy();\n    });\n  }\n\n  /**\n   * @param {Array<AbstractType<any>> | AbstractType<any>} ytypes\n   */\n  addToScope (ytypes) {\n    ytypes = array.isArray(ytypes) ? ytypes : [ytypes];\n    ytypes.forEach(ytype => {\n      if (this.scope.every(yt => yt !== ytype)) {\n        this.scope.push(ytype);\n      }\n    });\n  }\n\n  /**\n   * @param {any} origin\n   */\n  addTrackedOrigin (origin) {\n    this.trackedOrigins.add(origin);\n  }\n\n  /**\n   * @param {any} origin\n   */\n  removeTrackedOrigin (origin) {\n    this.trackedOrigins.delete(origin);\n  }\n\n  clear (clearUndoStack = true, clearRedoStack = true) {\n    if ((clearUndoStack && this.canUndo()) || (clearRedoStack && this.canRedo())) {\n      this.doc.transact(tr => {\n        if (clearUndoStack) {\n          this.undoStack.forEach(item => clearUndoManagerStackItem(tr, this, item));\n          this.undoStack = [];\n        }\n        if (clearRedoStack) {\n          this.redoStack.forEach(item => clearUndoManagerStackItem(tr, this, item));\n          this.redoStack = [];\n        }\n        this.emit('stack-cleared', [{ undoStackCleared: clearUndoStack, redoStackCleared: clearRedoStack }]);\n      });\n    }\n  }\n\n  /**\n   * UndoManager merges Undo-StackItem if they are created within time-gap\n   * smaller than `options.captureTimeout`. Call `um.stopCapturing()` so that the next\n   * StackItem won't be merged.\n   *\n   *\n   * @example\n   *     // without stopCapturing\n   *     ytext.insert(0, 'a')\n   *     ytext.insert(1, 'b')\n   *     um.undo()\n   *     ytext.toString() // => '' (note that 'ab' was removed)\n   *     // with stopCapturing\n   *     ytext.insert(0, 'a')\n   *     um.stopCapturing()\n   *     ytext.insert(0, 'b')\n   *     um.undo()\n   *     ytext.toString() // => 'a' (note that only 'b' was removed)\n   *\n   */\n  stopCapturing () {\n    this.lastChange = 0;\n  }\n\n  /**\n   * Undo last changes on type.\n   *\n   * @return {StackItem?} Returns StackItem if a change was applied\n   */\n  undo () {\n    this.undoing = true;\n    let res;\n    try {\n      res = popStackItem(this, this.undoStack, 'undo');\n    } finally {\n      this.undoing = false;\n    }\n    return res\n  }\n\n  /**\n   * Redo last undo operation.\n   *\n   * @return {StackItem?} Returns StackItem if a change was applied\n   */\n  redo () {\n    this.redoing = true;\n    let res;\n    try {\n      res = popStackItem(this, this.redoStack, 'redo');\n    } finally {\n      this.redoing = false;\n    }\n    return res\n  }\n\n  /**\n   * Are undo steps available?\n   *\n   * @return {boolean} `true` if undo is possible\n   */\n  canUndo () {\n    return this.undoStack.length > 0\n  }\n\n  /**\n   * Are redo steps available?\n   *\n   * @return {boolean} `true` if redo is possible\n   */\n  canRedo () {\n    return this.redoStack.length > 0\n  }\n\n  destroy () {\n    this.trackedOrigins.delete(this);\n    this.doc.off('afterTransaction', this.afterTransactionHandler);\n    super.destroy();\n  }\n}\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n */\nfunction * lazyStructReaderGenerator (decoder) {\n  const numOfStateUpdates = decoding.readVarUint(decoder.restDecoder);\n  for (let i = 0; i < numOfStateUpdates; i++) {\n    const numberOfStructs = decoding.readVarUint(decoder.restDecoder);\n    const client = decoder.readClient();\n    let clock = decoding.readVarUint(decoder.restDecoder);\n    for (let i = 0; i < numberOfStructs; i++) {\n      const info = decoder.readInfo();\n      // @todo use switch instead of ifs\n      if (info === 10) {\n        const len = decoding.readVarUint(decoder.restDecoder);\n        yield new Skip(createID(client, clock), len);\n        clock += len;\n      } else if ((binary.BITS5 & info) !== 0) {\n        const cantCopyParentInfo = (info & (binary.BIT7 | binary.BIT8)) === 0;\n        // If parent = null and neither left nor right are defined, then we know that `parent` is child of `y`\n        // and we read the next string as parentYKey.\n        // It indicates how we store/retrieve parent from `y.share`\n        // @type {string|null}\n        const struct = new Item(\n          createID(client, clock),\n          null, // left\n          (info & binary.BIT8) === binary.BIT8 ? decoder.readLeftID() : null, // origin\n          null, // right\n          (info & binary.BIT7) === binary.BIT7 ? decoder.readRightID() : null, // right origin\n          // @ts-ignore Force writing a string here.\n          cantCopyParentInfo ? (decoder.readParentInfo() ? decoder.readString() : decoder.readLeftID()) : null, // parent\n          cantCopyParentInfo && (info & binary.BIT6) === binary.BIT6 ? decoder.readString() : null, // parentSub\n          readItemContent(decoder, info) // item content\n        );\n        yield struct;\n        clock += struct.length;\n      } else {\n        const len = decoder.readLen();\n        yield new GC(createID(client, clock), len);\n        clock += len;\n      }\n    }\n  }\n}\n\nclass LazyStructReader {\n  /**\n   * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n   * @param {boolean} filterSkips\n   */\n  constructor (decoder, filterSkips) {\n    this.gen = lazyStructReaderGenerator(decoder);\n    /**\n     * @type {null | Item | Skip | GC}\n     */\n    this.curr = null;\n    this.done = false;\n    this.filterSkips = filterSkips;\n    this.next();\n  }\n\n  /**\n   * @return {Item | GC | Skip |null}\n   */\n  next () {\n    // ignore \"Skip\" structs\n    do {\n      this.curr = this.gen.next().value || null;\n    } while (this.filterSkips && this.curr !== null && this.curr.constructor === Skip)\n    return this.curr\n  }\n}\n\n/**\n * @param {Uint8Array} update\n *\n */\nconst logUpdate = update => logUpdateV2(update, UpdateDecoderV1);\n\n/**\n * @param {Uint8Array} update\n * @param {typeof UpdateDecoderV2 | typeof UpdateDecoderV1} [YDecoder]\n *\n */\nconst logUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {\n  const structs = [];\n  const updateDecoder = new YDecoder(decoding.createDecoder(update));\n  const lazyDecoder = new LazyStructReader(updateDecoder, false);\n  for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {\n    structs.push(curr);\n  }\n  logging.print('Structs: ', structs);\n  const ds = readDeleteSet(updateDecoder);\n  logging.print('DeleteSet: ', ds);\n};\n\n/**\n * @param {Uint8Array} update\n *\n */\nconst decodeUpdate = (update) => decodeUpdateV2(update, UpdateDecoderV1);\n\n/**\n * @param {Uint8Array} update\n * @param {typeof UpdateDecoderV2 | typeof UpdateDecoderV1} [YDecoder]\n *\n */\nconst decodeUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {\n  const structs = [];\n  const updateDecoder = new YDecoder(decoding.createDecoder(update));\n  const lazyDecoder = new LazyStructReader(updateDecoder, false);\n  for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {\n    structs.push(curr);\n  }\n  return {\n    structs,\n    ds: readDeleteSet(updateDecoder)\n  }\n};\n\nclass LazyStructWriter {\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   */\n  constructor (encoder) {\n    this.currClient = 0;\n    this.startClock = 0;\n    this.written = 0;\n    this.encoder = encoder;\n    /**\n     * We want to write operations lazily, but also we need to know beforehand how many operations we want to write for each client.\n     *\n     * This kind of meta-information (#clients, #structs-per-client-written) is written to the restEncoder.\n     *\n     * We fragment the restEncoder and store a slice of it per-client until we know how many clients there are.\n     * When we flush (toUint8Array) we write the restEncoder using the fragments and the meta-information.\n     *\n     * @type {Array<{ written: number, restEncoder: Uint8Array }>}\n     */\n    this.clientStructs = [];\n  }\n}\n\n/**\n * @param {Array<Uint8Array>} updates\n * @return {Uint8Array}\n */\nconst mergeUpdates = updates => mergeUpdatesV2(updates, UpdateDecoderV1, UpdateEncoderV1);\n\n/**\n * @param {Uint8Array} update\n * @param {typeof DSEncoderV1 | typeof DSEncoderV2} YEncoder\n * @param {typeof UpdateDecoderV1 | typeof UpdateDecoderV2} YDecoder\n * @return {Uint8Array}\n */\nconst encodeStateVectorFromUpdateV2 = (update, YEncoder = DSEncoderV2, YDecoder = UpdateDecoderV2) => {\n  const encoder = new YEncoder();\n  const updateDecoder = new LazyStructReader(new YDecoder(decoding.createDecoder(update)), false);\n  let curr = updateDecoder.curr;\n  if (curr !== null) {\n    let size = 0;\n    let currClient = curr.id.client;\n    let stopCounting = curr.id.clock !== 0; // must start at 0\n    let currClock = stopCounting ? 0 : curr.id.clock + curr.length;\n    for (; curr !== null; curr = updateDecoder.next()) {\n      if (currClient !== curr.id.client) {\n        if (currClock !== 0) {\n          size++;\n          // We found a new client\n          // write what we have to the encoder\n          encoding.writeVarUint(encoder.restEncoder, currClient);\n          encoding.writeVarUint(encoder.restEncoder, currClock);\n        }\n        currClient = curr.id.client;\n        currClock = 0;\n        stopCounting = curr.id.clock !== 0;\n      }\n      // we ignore skips\n      if (curr.constructor === Skip) {\n        stopCounting = true;\n      }\n      if (!stopCounting) {\n        currClock = curr.id.clock + curr.length;\n      }\n    }\n    // write what we have\n    if (currClock !== 0) {\n      size++;\n      encoding.writeVarUint(encoder.restEncoder, currClient);\n      encoding.writeVarUint(encoder.restEncoder, currClock);\n    }\n    // prepend the size of the state vector\n    const enc = encoding.createEncoder();\n    encoding.writeVarUint(enc, size);\n    encoding.writeBinaryEncoder(enc, encoder.restEncoder);\n    encoder.restEncoder = enc;\n    return encoder.toUint8Array()\n  } else {\n    encoding.writeVarUint(encoder.restEncoder, 0);\n    return encoder.toUint8Array()\n  }\n};\n\n/**\n * @param {Uint8Array} update\n * @return {Uint8Array}\n */\nconst encodeStateVectorFromUpdate = update => encodeStateVectorFromUpdateV2(update, DSEncoderV1, UpdateDecoderV1);\n\n/**\n * @param {Uint8Array} update\n * @param {typeof UpdateDecoderV1 | typeof UpdateDecoderV2} YDecoder\n * @return {{ from: Map<number,number>, to: Map<number,number> }}\n */\nconst parseUpdateMetaV2 = (update, YDecoder = UpdateDecoderV2) => {\n  /**\n   * @type {Map<number, number>}\n   */\n  const from = new Map();\n  /**\n   * @type {Map<number, number>}\n   */\n  const to = new Map();\n  const updateDecoder = new LazyStructReader(new YDecoder(decoding.createDecoder(update)), false);\n  let curr = updateDecoder.curr;\n  if (curr !== null) {\n    let currClient = curr.id.client;\n    let currClock = curr.id.clock;\n    // write the beginning to `from`\n    from.set(currClient, currClock);\n    for (; curr !== null; curr = updateDecoder.next()) {\n      if (currClient !== curr.id.client) {\n        // We found a new client\n        // write the end to `to`\n        to.set(currClient, currClock);\n        // write the beginning to `from`\n        from.set(curr.id.client, curr.id.clock);\n        // update currClient\n        currClient = curr.id.client;\n      }\n      currClock = curr.id.clock + curr.length;\n    }\n    // write the end to `to`\n    to.set(currClient, currClock);\n  }\n  return { from, to }\n};\n\n/**\n * @param {Uint8Array} update\n * @return {{ from: Map<number,number>, to: Map<number,number> }}\n */\nconst parseUpdateMeta = update => parseUpdateMetaV2(update, UpdateDecoderV1);\n\n/**\n * This method is intended to slice any kind of struct and retrieve the right part.\n * It does not handle side-effects, so it should only be used by the lazy-encoder.\n *\n * @param {Item | GC | Skip} left\n * @param {number} diff\n * @return {Item | GC}\n */\nconst sliceStruct = (left, diff) => {\n  if (left.constructor === GC) {\n    const { client, clock } = left.id;\n    return new GC(createID(client, clock + diff), left.length - diff)\n  } else if (left.constructor === Skip) {\n    const { client, clock } = left.id;\n    return new Skip(createID(client, clock + diff), left.length - diff)\n  } else {\n    const leftItem = /** @type {Item} */ (left);\n    const { client, clock } = leftItem.id;\n    return new Item(\n      createID(client, clock + diff),\n      null,\n      createID(client, clock + diff - 1),\n      null,\n      leftItem.rightOrigin,\n      leftItem.parent,\n      leftItem.parentSub,\n      leftItem.content.splice(diff)\n    )\n  }\n};\n\n/**\n *\n * This function works similarly to `readUpdateV2`.\n *\n * @param {Array<Uint8Array>} updates\n * @param {typeof UpdateDecoderV1 | typeof UpdateDecoderV2} [YDecoder]\n * @param {typeof UpdateEncoderV1 | typeof UpdateEncoderV2} [YEncoder]\n * @return {Uint8Array}\n */\nconst mergeUpdatesV2 = (updates, YDecoder = UpdateDecoderV2, YEncoder = UpdateEncoderV2) => {\n  if (updates.length === 1) {\n    return updates[0]\n  }\n  const updateDecoders = updates.map(update => new YDecoder(decoding.createDecoder(update)));\n  let lazyStructDecoders = updateDecoders.map(decoder => new LazyStructReader(decoder, true));\n\n  /**\n   * @todo we don't need offset because we always slice before\n   * @type {null | { struct: Item | GC | Skip, offset: number }}\n   */\n  let currWrite = null;\n\n  const updateEncoder = new YEncoder();\n  // write structs lazily\n  const lazyStructEncoder = new LazyStructWriter(updateEncoder);\n\n  // Note: We need to ensure that all lazyStructDecoders are fully consumed\n  // Note: Should merge document updates whenever possible - even from different updates\n  // Note: Should handle that some operations cannot be applied yet ()\n\n  while (true) {\n    // Write higher clients first ⇒ sort by clientID & clock and remove decoders without content\n    lazyStructDecoders = lazyStructDecoders.filter(dec => dec.curr !== null);\n    lazyStructDecoders.sort(\n      /** @type {function(any,any):number} */ (dec1, dec2) => {\n        if (dec1.curr.id.client === dec2.curr.id.client) {\n          const clockDiff = dec1.curr.id.clock - dec2.curr.id.clock;\n          if (clockDiff === 0) {\n            // @todo remove references to skip since the structDecoders must filter Skips.\n            return dec1.curr.constructor === dec2.curr.constructor\n              ? 0\n              : dec1.curr.constructor === Skip ? 1 : -1 // we are filtering skips anyway.\n          } else {\n            return clockDiff\n          }\n        } else {\n          return dec2.curr.id.client - dec1.curr.id.client\n        }\n      }\n    );\n    if (lazyStructDecoders.length === 0) {\n      break\n    }\n    const currDecoder = lazyStructDecoders[0];\n    // write from currDecoder until the next operation is from another client or if filler-struct\n    // then we need to reorder the decoders and find the next operation to write\n    const firstClient = /** @type {Item | GC} */ (currDecoder.curr).id.client;\n\n    if (currWrite !== null) {\n      let curr = /** @type {Item | GC | null} */ (currDecoder.curr);\n      let iterated = false;\n\n      // iterate until we find something that we haven't written already\n      // remember: first the high client-ids are written\n      while (curr !== null && curr.id.clock + curr.length <= currWrite.struct.id.clock + currWrite.struct.length && curr.id.client >= currWrite.struct.id.client) {\n        curr = currDecoder.next();\n        iterated = true;\n      }\n      if (\n        curr === null || // current decoder is empty\n        curr.id.client !== firstClient || // check whether there is another decoder that has has updates from `firstClient`\n        (iterated && curr.id.clock > currWrite.struct.id.clock + currWrite.struct.length) // the above while loop was used and we are potentially missing updates\n      ) {\n        continue\n      }\n\n      if (firstClient !== currWrite.struct.id.client) {\n        writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);\n        currWrite = { struct: curr, offset: 0 };\n        currDecoder.next();\n      } else {\n        if (currWrite.struct.id.clock + currWrite.struct.length < curr.id.clock) {\n          // @todo write currStruct & set currStruct = Skip(clock = currStruct.id.clock + currStruct.length, length = curr.id.clock - self.clock)\n          if (currWrite.struct.constructor === Skip) {\n            // extend existing skip\n            currWrite.struct.length = curr.id.clock + curr.length - currWrite.struct.id.clock;\n          } else {\n            writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);\n            const diff = curr.id.clock - currWrite.struct.id.clock - currWrite.struct.length;\n            /**\n             * @type {Skip}\n             */\n            const struct = new Skip(createID(firstClient, currWrite.struct.id.clock + currWrite.struct.length), diff);\n            currWrite = { struct, offset: 0 };\n          }\n        } else { // if (currWrite.struct.id.clock + currWrite.struct.length >= curr.id.clock) {\n          const diff = currWrite.struct.id.clock + currWrite.struct.length - curr.id.clock;\n          if (diff > 0) {\n            if (currWrite.struct.constructor === Skip) {\n              // prefer to slice Skip because the other struct might contain more information\n              currWrite.struct.length -= diff;\n            } else {\n              curr = sliceStruct(curr, diff);\n            }\n          }\n          if (!currWrite.struct.mergeWith(/** @type {any} */ (curr))) {\n            writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);\n            currWrite = { struct: curr, offset: 0 };\n            currDecoder.next();\n          }\n        }\n      }\n    } else {\n      currWrite = { struct: /** @type {Item | GC} */ (currDecoder.curr), offset: 0 };\n      currDecoder.next();\n    }\n    for (\n      let next = currDecoder.curr;\n      next !== null && next.id.client === firstClient && next.id.clock === currWrite.struct.id.clock + currWrite.struct.length && next.constructor !== Skip;\n      next = currDecoder.next()\n    ) {\n      writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);\n      currWrite = { struct: next, offset: 0 };\n    }\n  }\n  if (currWrite !== null) {\n    writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);\n    currWrite = null;\n  }\n  finishLazyStructWriting(lazyStructEncoder);\n\n  const dss = updateDecoders.map(decoder => readDeleteSet(decoder));\n  const ds = mergeDeleteSets(dss);\n  writeDeleteSet(updateEncoder, ds);\n  return updateEncoder.toUint8Array()\n};\n\n/**\n * @param {Uint8Array} update\n * @param {Uint8Array} sv\n * @param {typeof UpdateDecoderV1 | typeof UpdateDecoderV2} [YDecoder]\n * @param {typeof UpdateEncoderV1 | typeof UpdateEncoderV2} [YEncoder]\n */\nconst diffUpdateV2 = (update, sv, YDecoder = UpdateDecoderV2, YEncoder = UpdateEncoderV2) => {\n  const state = decodeStateVector(sv);\n  const encoder = new YEncoder();\n  const lazyStructWriter = new LazyStructWriter(encoder);\n  const decoder = new YDecoder(decoding.createDecoder(update));\n  const reader = new LazyStructReader(decoder, false);\n  while (reader.curr) {\n    const curr = reader.curr;\n    const currClient = curr.id.client;\n    const svClock = state.get(currClient) || 0;\n    if (reader.curr.constructor === Skip) {\n      // the first written struct shouldn't be a skip\n      reader.next();\n      continue\n    }\n    if (curr.id.clock + curr.length > svClock) {\n      writeStructToLazyStructWriter(lazyStructWriter, curr, math.max(svClock - curr.id.clock, 0));\n      reader.next();\n      while (reader.curr && reader.curr.id.client === currClient) {\n        writeStructToLazyStructWriter(lazyStructWriter, reader.curr, 0);\n        reader.next();\n      }\n    } else {\n      // read until something new comes up\n      while (reader.curr && reader.curr.id.client === currClient && reader.curr.id.clock + reader.curr.length <= svClock) {\n        reader.next();\n      }\n    }\n  }\n  finishLazyStructWriting(lazyStructWriter);\n  // write ds\n  const ds = readDeleteSet(decoder);\n  writeDeleteSet(encoder, ds);\n  return encoder.toUint8Array()\n};\n\n/**\n * @param {Uint8Array} update\n * @param {Uint8Array} sv\n */\nconst diffUpdate = (update, sv) => diffUpdateV2(update, sv, UpdateDecoderV1, UpdateEncoderV1);\n\n/**\n * @param {LazyStructWriter} lazyWriter\n */\nconst flushLazyStructWriter = lazyWriter => {\n  if (lazyWriter.written > 0) {\n    lazyWriter.clientStructs.push({ written: lazyWriter.written, restEncoder: encoding.toUint8Array(lazyWriter.encoder.restEncoder) });\n    lazyWriter.encoder.restEncoder = encoding.createEncoder();\n    lazyWriter.written = 0;\n  }\n};\n\n/**\n * @param {LazyStructWriter} lazyWriter\n * @param {Item | GC} struct\n * @param {number} offset\n */\nconst writeStructToLazyStructWriter = (lazyWriter, struct, offset) => {\n  // flush curr if we start another client\n  if (lazyWriter.written > 0 && lazyWriter.currClient !== struct.id.client) {\n    flushLazyStructWriter(lazyWriter);\n  }\n  if (lazyWriter.written === 0) {\n    lazyWriter.currClient = struct.id.client;\n    // write next client\n    lazyWriter.encoder.writeClient(struct.id.client);\n    // write startClock\n    encoding.writeVarUint(lazyWriter.encoder.restEncoder, struct.id.clock + offset);\n  }\n  struct.write(lazyWriter.encoder, offset);\n  lazyWriter.written++;\n};\n/**\n * Call this function when we collected all parts and want to\n * put all the parts together. After calling this method,\n * you can continue using the UpdateEncoder.\n *\n * @param {LazyStructWriter} lazyWriter\n */\nconst finishLazyStructWriting = (lazyWriter) => {\n  flushLazyStructWriter(lazyWriter);\n\n  // this is a fresh encoder because we called flushCurr\n  const restEncoder = lazyWriter.encoder.restEncoder;\n\n  /**\n   * Now we put all the fragments together.\n   * This works similarly to `writeClientsStructs`\n   */\n\n  // write # states that were updated - i.e. the clients\n  encoding.writeVarUint(restEncoder, lazyWriter.clientStructs.length);\n\n  for (let i = 0; i < lazyWriter.clientStructs.length; i++) {\n    const partStructs = lazyWriter.clientStructs[i];\n    /**\n     * Works similarly to `writeStructs`\n     */\n    // write # encoded structs\n    encoding.writeVarUint(restEncoder, partStructs.written);\n    // write the rest of the fragment\n    encoding.writeUint8Array(restEncoder, partStructs.restEncoder);\n  }\n};\n\n/**\n * @param {Uint8Array} update\n * @param {function(Item|GC|Skip):Item|GC|Skip} blockTransformer\n * @param {typeof UpdateDecoderV2 | typeof UpdateDecoderV1} YDecoder\n * @param {typeof UpdateEncoderV2 | typeof UpdateEncoderV1 } YEncoder\n */\nconst convertUpdateFormat = (update, blockTransformer, YDecoder, YEncoder) => {\n  const updateDecoder = new YDecoder(decoding.createDecoder(update));\n  const lazyDecoder = new LazyStructReader(updateDecoder, false);\n  const updateEncoder = new YEncoder();\n  const lazyWriter = new LazyStructWriter(updateEncoder);\n  for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {\n    writeStructToLazyStructWriter(lazyWriter, blockTransformer(curr), 0);\n  }\n  finishLazyStructWriting(lazyWriter);\n  const ds = readDeleteSet(updateDecoder);\n  writeDeleteSet(updateEncoder, ds);\n  return updateEncoder.toUint8Array()\n};\n\n/**\n * @typedef {Object} ObfuscatorOptions\n * @property {boolean} [ObfuscatorOptions.formatting=true]\n * @property {boolean} [ObfuscatorOptions.subdocs=true]\n * @property {boolean} [ObfuscatorOptions.yxml=true] Whether to obfuscate nodeName / hookName\n */\n\n/**\n * @param {ObfuscatorOptions} obfuscator\n */\nconst createObfuscator = ({ formatting = true, subdocs = true, yxml = true } = {}) => {\n  let i = 0;\n  const mapKeyCache = map.create();\n  const nodeNameCache = map.create();\n  const formattingKeyCache = map.create();\n  const formattingValueCache = map.create();\n  formattingValueCache.set(null, null); // end of a formatting range should always be the end of a formatting range\n  /**\n   * @param {Item|GC|Skip} block\n   * @return {Item|GC|Skip}\n   */\n  return block => {\n    switch (block.constructor) {\n      case GC:\n      case Skip:\n        return block\n      case Item: {\n        const item = /** @type {Item} */ (block);\n        const content = item.content;\n        switch (content.constructor) {\n          case ContentDeleted:\n            break\n          case ContentType: {\n            if (yxml) {\n              const type = /** @type {ContentType} */ (content).type;\n              if (type instanceof YXmlElement) {\n                type.nodeName = map.setIfUndefined(nodeNameCache, type.nodeName, () => 'node-' + i);\n              }\n              if (type instanceof YXmlHook) {\n                type.hookName = map.setIfUndefined(nodeNameCache, type.hookName, () => 'hook-' + i);\n              }\n            }\n            break\n          }\n          case ContentAny: {\n            const c = /** @type {ContentAny} */ (content);\n            c.arr = c.arr.map(() => i);\n            break\n          }\n          case ContentBinary: {\n            const c = /** @type {ContentBinary} */ (content);\n            c.content = new Uint8Array([i]);\n            break\n          }\n          case ContentDoc: {\n            const c = /** @type {ContentDoc} */ (content);\n            if (subdocs) {\n              c.opts = {};\n              c.doc.guid = i + '';\n            }\n            break\n          }\n          case ContentEmbed: {\n            const c = /** @type {ContentEmbed} */ (content);\n            c.embed = {};\n            break\n          }\n          case ContentFormat: {\n            const c = /** @type {ContentFormat} */ (content);\n            if (formatting) {\n              c.key = map.setIfUndefined(formattingKeyCache, c.key, () => i + '');\n              c.value = map.setIfUndefined(formattingValueCache, c.value, () => ({ i }));\n            }\n            break\n          }\n          case ContentJSON: {\n            const c = /** @type {ContentJSON} */ (content);\n            c.arr = c.arr.map(() => i);\n            break\n          }\n          case ContentString: {\n            const c = /** @type {ContentString} */ (content);\n            c.str = string.repeat((i % 10) + '', c.str.length);\n            break\n          }\n          default:\n            // unknown content type\n            error.unexpectedCase();\n        }\n        if (item.parentSub) {\n          item.parentSub = map.setIfUndefined(mapKeyCache, item.parentSub, () => i + '');\n        }\n        i++;\n        return block\n      }\n      default:\n        // unknown block-type\n        error.unexpectedCase();\n    }\n  }\n};\n\n/**\n * This function obfuscates the content of a Yjs update. This is useful to share\n * buggy Yjs documents while significantly limiting the possibility that a\n * developer can on the user. Note that it might still be possible to deduce\n * some information by analyzing the \"structure\" of the document or by analyzing\n * the typing behavior using the CRDT-related metadata that is still kept fully\n * intact.\n *\n * @param {Uint8Array} update\n * @param {ObfuscatorOptions} [opts]\n */\nconst obfuscateUpdate = (update, opts) => convertUpdateFormat(update, createObfuscator(opts), UpdateDecoderV1, UpdateEncoderV1);\n\n/**\n * @param {Uint8Array} update\n * @param {ObfuscatorOptions} [opts]\n */\nconst obfuscateUpdateV2 = (update, opts) => convertUpdateFormat(update, createObfuscator(opts), UpdateDecoderV2, UpdateEncoderV2);\n\n/**\n * @param {Uint8Array} update\n */\nconst convertUpdateFormatV1ToV2 = update => convertUpdateFormat(update, f.id, UpdateDecoderV1, UpdateEncoderV2);\n\n/**\n * @param {Uint8Array} update\n */\nconst convertUpdateFormatV2ToV1 = update => convertUpdateFormat(update, f.id, UpdateDecoderV2, UpdateEncoderV1);\n\nconst errorComputeChanges = 'You must not compute changes after the event-handler fired.';\n\n/**\n * @template {AbstractType<any>} T\n * YEvent describes the changes on a YType.\n */\nclass YEvent {\n  /**\n   * @param {T} target The changed type.\n   * @param {Transaction} transaction\n   */\n  constructor (target, transaction) {\n    /**\n     * The type on which this event was created on.\n     * @type {T}\n     */\n    this.target = target;\n    /**\n     * The current target on which the observe callback is called.\n     * @type {AbstractType<any>}\n     */\n    this.currentTarget = target;\n    /**\n     * The transaction that triggered this event.\n     * @type {Transaction}\n     */\n    this.transaction = transaction;\n    /**\n     * @type {Object|null}\n     */\n    this._changes = null;\n    /**\n     * @type {null | Map<string, { action: 'add' | 'update' | 'delete', oldValue: any, newValue: any }>}\n     */\n    this._keys = null;\n    /**\n     * @type {null | Array<{ insert?: string | Array<any> | object | AbstractType<any>, retain?: number, delete?: number, attributes?: Object<string, any> }>}\n     */\n    this._delta = null;\n    /**\n     * @type {Array<string|number>|null}\n     */\n    this._path = null;\n  }\n\n  /**\n   * Computes the path from `y` to the changed type.\n   *\n   * @todo v14 should standardize on path: Array<{parent, index}> because that is easier to work with.\n   *\n   * The following property holds:\n   * @example\n   *   let type = y\n   *   event.path.forEach(dir => {\n   *     type = type.get(dir)\n   *   })\n   *   type === event.target // => true\n   */\n  get path () {\n    return this._path || (this._path = getPathTo(this.currentTarget, this.target))\n  }\n\n  /**\n   * Check if a struct is deleted by this event.\n   *\n   * In contrast to change.deleted, this method also returns true if the struct was added and then deleted.\n   *\n   * @param {AbstractStruct} struct\n   * @return {boolean}\n   */\n  deletes (struct) {\n    return isDeleted(this.transaction.deleteSet, struct.id)\n  }\n\n  /**\n   * @type {Map<string, { action: 'add' | 'update' | 'delete', oldValue: any, newValue: any }>}\n   */\n  get keys () {\n    if (this._keys === null) {\n      if (this.transaction.doc._transactionCleanups.length === 0) {\n        throw error.create(errorComputeChanges)\n      }\n      const keys = new Map();\n      const target = this.target;\n      const changed = /** @type Set<string|null> */ (this.transaction.changed.get(target));\n      changed.forEach(key => {\n        if (key !== null) {\n          const item = /** @type {Item} */ (target._map.get(key));\n          /**\n           * @type {'delete' | 'add' | 'update'}\n           */\n          let action;\n          let oldValue;\n          if (this.adds(item)) {\n            let prev = item.left;\n            while (prev !== null && this.adds(prev)) {\n              prev = prev.left;\n            }\n            if (this.deletes(item)) {\n              if (prev !== null && this.deletes(prev)) {\n                action = 'delete';\n                oldValue = array.last(prev.content.getContent());\n              } else {\n                return\n              }\n            } else {\n              if (prev !== null && this.deletes(prev)) {\n                action = 'update';\n                oldValue = array.last(prev.content.getContent());\n              } else {\n                action = 'add';\n                oldValue = undefined;\n              }\n            }\n          } else {\n            if (this.deletes(item)) {\n              action = 'delete';\n              oldValue = array.last(/** @type {Item} */ item.content.getContent());\n            } else {\n              return // nop\n            }\n          }\n          keys.set(key, { action, oldValue });\n        }\n      });\n      this._keys = keys;\n    }\n    return this._keys\n  }\n\n  /**\n   * This is a computed property. Note that this can only be safely computed during the\n   * event call. Computing this property after other changes happened might result in\n   * unexpected behavior (incorrect computation of deltas). A safe way to collect changes\n   * is to store the `changes` or the `delta` object. Avoid storing the `transaction` object.\n   *\n   * @type {Array<{insert?: string | Array<any> | object | AbstractType<any>, retain?: number, delete?: number, attributes?: Object<string, any>}>}\n   */\n  get delta () {\n    return this.changes.delta\n  }\n\n  /**\n   * Check if a struct is added by this event.\n   *\n   * In contrast to change.deleted, this method also returns true if the struct was added and then deleted.\n   *\n   * @param {AbstractStruct} struct\n   * @return {boolean}\n   */\n  adds (struct) {\n    return struct.id.clock >= (this.transaction.beforeState.get(struct.id.client) || 0)\n  }\n\n  /**\n   * This is a computed property. Note that this can only be safely computed during the\n   * event call. Computing this property after other changes happened might result in\n   * unexpected behavior (incorrect computation of deltas). A safe way to collect changes\n   * is to store the `changes` or the `delta` object. Avoid storing the `transaction` object.\n   *\n   * @type {{added:Set<Item>,deleted:Set<Item>,keys:Map<string,{action:'add'|'update'|'delete',oldValue:any}>,delta:Array<{insert?:Array<any>|string, delete?:number, retain?:number}>}}\n   */\n  get changes () {\n    let changes = this._changes;\n    if (changes === null) {\n      if (this.transaction.doc._transactionCleanups.length === 0) {\n        throw error.create(errorComputeChanges)\n      }\n      const target = this.target;\n      const added = set.create();\n      const deleted = set.create();\n      /**\n       * @type {Array<{insert:Array<any>}|{delete:number}|{retain:number}>}\n       */\n      const delta = [];\n      changes = {\n        added,\n        deleted,\n        delta,\n        keys: this.keys\n      };\n      const changed = /** @type Set<string|null> */ (this.transaction.changed.get(target));\n      if (changed.has(null)) {\n        /**\n         * @type {any}\n         */\n        let lastOp = null;\n        const packOp = () => {\n          if (lastOp) {\n            delta.push(lastOp);\n          }\n        };\n        for (let item = target._start; item !== null; item = item.right) {\n          if (item.deleted) {\n            if (this.deletes(item) && !this.adds(item)) {\n              if (lastOp === null || lastOp.delete === undefined) {\n                packOp();\n                lastOp = { delete: 0 };\n              }\n              lastOp.delete += item.length;\n              deleted.add(item);\n            } // else nop\n          } else {\n            if (this.adds(item)) {\n              if (lastOp === null || lastOp.insert === undefined) {\n                packOp();\n                lastOp = { insert: [] };\n              }\n              lastOp.insert = lastOp.insert.concat(item.content.getContent());\n              added.add(item);\n            } else {\n              if (lastOp === null || lastOp.retain === undefined) {\n                packOp();\n                lastOp = { retain: 0 };\n              }\n              lastOp.retain += item.length;\n            }\n          }\n        }\n        if (lastOp !== null && lastOp.retain === undefined) {\n          packOp();\n        }\n      }\n      this._changes = changes;\n    }\n    return /** @type {any} */ (changes)\n  }\n}\n\n/**\n * Compute the path from this type to the specified target.\n *\n * @example\n *   // `child` should be accessible via `type.get(path[0]).get(path[1])..`\n *   const path = type.getPathTo(child)\n *   // assuming `type instanceof YArray`\n *   console.log(path) // might look like => [2, 'key1']\n *   child === type.get(path[0]).get(path[1])\n *\n * @param {AbstractType<any>} parent\n * @param {AbstractType<any>} child target\n * @return {Array<string|number>} Path to the target\n *\n * @private\n * @function\n */\nconst getPathTo = (parent, child) => {\n  const path = [];\n  while (child._item !== null && child !== parent) {\n    if (child._item.parentSub !== null) {\n      // parent is map-ish\n      path.unshift(child._item.parentSub);\n    } else {\n      // parent is array-ish\n      let i = 0;\n      let c = /** @type {AbstractType<any>} */ (child._item.parent)._start;\n      while (c !== child._item && c !== null) {\n        if (!c.deleted) {\n          i++;\n        }\n        c = c.right;\n      }\n      path.unshift(i);\n    }\n    child = /** @type {AbstractType<any>} */ (child._item.parent);\n  }\n  return path\n};\n\nconst maxSearchMarker = 80;\n\n/**\n * A unique timestamp that identifies each marker.\n *\n * Time is relative,.. this is more like an ever-increasing clock.\n *\n * @type {number}\n */\nlet globalSearchMarkerTimestamp = 0;\n\nclass ArraySearchMarker {\n  /**\n   * @param {Item} p\n   * @param {number} index\n   */\n  constructor (p, index) {\n    p.marker = true;\n    this.p = p;\n    this.index = index;\n    this.timestamp = globalSearchMarkerTimestamp++;\n  }\n}\n\n/**\n * @param {ArraySearchMarker} marker\n */\nconst refreshMarkerTimestamp = marker => { marker.timestamp = globalSearchMarkerTimestamp++; };\n\n/**\n * This is rather complex so this function is the only thing that should overwrite a marker\n *\n * @param {ArraySearchMarker} marker\n * @param {Item} p\n * @param {number} index\n */\nconst overwriteMarker = (marker, p, index) => {\n  marker.p.marker = false;\n  marker.p = p;\n  p.marker = true;\n  marker.index = index;\n  marker.timestamp = globalSearchMarkerTimestamp++;\n};\n\n/**\n * @param {Array<ArraySearchMarker>} searchMarker\n * @param {Item} p\n * @param {number} index\n */\nconst markPosition = (searchMarker, p, index) => {\n  if (searchMarker.length >= maxSearchMarker) {\n    // override oldest marker (we don't want to create more objects)\n    const marker = searchMarker.reduce((a, b) => a.timestamp < b.timestamp ? a : b);\n    overwriteMarker(marker, p, index);\n    return marker\n  } else {\n    // create new marker\n    const pm = new ArraySearchMarker(p, index);\n    searchMarker.push(pm);\n    return pm\n  }\n};\n\n/**\n * Search marker help us to find positions in the associative array faster.\n *\n * They speed up the process of finding a position without much bookkeeping.\n *\n * A maximum of `maxSearchMarker` objects are created.\n *\n * This function always returns a refreshed marker (updated timestamp)\n *\n * @param {AbstractType<any>} yarray\n * @param {number} index\n */\nconst findMarker = (yarray, index) => {\n  if (yarray._start === null || index === 0 || yarray._searchMarker === null) {\n    return null\n  }\n  const marker = yarray._searchMarker.length === 0 ? null : yarray._searchMarker.reduce((a, b) => math.abs(index - a.index) < math.abs(index - b.index) ? a : b);\n  let p = yarray._start;\n  let pindex = 0;\n  if (marker !== null) {\n    p = marker.p;\n    pindex = marker.index;\n    refreshMarkerTimestamp(marker); // we used it, we might need to use it again\n  }\n  // iterate to right if possible\n  while (p.right !== null && pindex < index) {\n    if (!p.deleted && p.countable) {\n      if (index < pindex + p.length) {\n        break\n      }\n      pindex += p.length;\n    }\n    p = p.right;\n  }\n  // iterate to left if necessary (might be that pindex > index)\n  while (p.left !== null && pindex > index) {\n    p = p.left;\n    if (!p.deleted && p.countable) {\n      pindex -= p.length;\n    }\n  }\n  // we want to make sure that p can't be merged with left, because that would screw up everything\n  // in that cas just return what we have (it is most likely the best marker anyway)\n  // iterate to left until p can't be merged with left\n  while (p.left !== null && p.left.id.client === p.id.client && p.left.id.clock + p.left.length === p.id.clock) {\n    p = p.left;\n    if (!p.deleted && p.countable) {\n      pindex -= p.length;\n    }\n  }\n\n  // @todo remove!\n  // assure position\n  // {\n  //   let start = yarray._start\n  //   let pos = 0\n  //   while (start !== p) {\n  //     if (!start.deleted && start.countable) {\n  //       pos += start.length\n  //     }\n  //     start = /** @type {Item} */ (start.right)\n  //   }\n  //   if (pos !== pindex) {\n  //     debugger\n  //     throw new Error('Gotcha position fail!')\n  //   }\n  // }\n  // if (marker) {\n  //   if (window.lengthes == null) {\n  //     window.lengthes = []\n  //     window.getLengthes = () => window.lengthes.sort((a, b) => a - b)\n  //   }\n  //   window.lengthes.push(marker.index - pindex)\n  //   console.log('distance', marker.index - pindex, 'len', p && p.parent.length)\n  // }\n  if (marker !== null && math.abs(marker.index - pindex) < /** @type {YText|YArray<any>} */ (p.parent).length / maxSearchMarker) {\n    // adjust existing marker\n    overwriteMarker(marker, p, pindex);\n    return marker\n  } else {\n    // create new marker\n    return markPosition(yarray._searchMarker, p, pindex)\n  }\n};\n\n/**\n * Update markers when a change happened.\n *\n * This should be called before doing a deletion!\n *\n * @param {Array<ArraySearchMarker>} searchMarker\n * @param {number} index\n * @param {number} len If insertion, len is positive. If deletion, len is negative.\n */\nconst updateMarkerChanges = (searchMarker, index, len) => {\n  for (let i = searchMarker.length - 1; i >= 0; i--) {\n    const m = searchMarker[i];\n    if (len > 0) {\n      /**\n       * @type {Item|null}\n       */\n      let p = m.p;\n      p.marker = false;\n      // Ideally we just want to do a simple position comparison, but this will only work if\n      // search markers don't point to deleted items for formats.\n      // Iterate marker to prev undeleted countable position so we know what to do when updating a position\n      while (p && (p.deleted || !p.countable)) {\n        p = p.left;\n        if (p && !p.deleted && p.countable) {\n          // adjust position. the loop should break now\n          m.index -= p.length;\n        }\n      }\n      if (p === null || p.marker === true) {\n        // remove search marker if updated position is null or if position is already marked\n        searchMarker.splice(i, 1);\n        continue\n      }\n      m.p = p;\n      p.marker = true;\n    }\n    if (index < m.index || (len > 0 && index === m.index)) { // a simple index <= m.index check would actually suffice\n      m.index = math.max(index, m.index + len);\n    }\n  }\n};\n\n/**\n * Accumulate all (list) children of a type and return them as an Array.\n *\n * @param {AbstractType<any>} t\n * @return {Array<Item>}\n */\nconst getTypeChildren = t => {\n  let s = t._start;\n  const arr = [];\n  while (s) {\n    arr.push(s);\n    s = s.right;\n  }\n  return arr\n};\n\n/**\n * Call event listeners with an event. This will also add an event to all\n * parents (for `.observeDeep` handlers).\n *\n * @template EventType\n * @param {AbstractType<EventType>} type\n * @param {Transaction} transaction\n * @param {EventType} event\n */\nconst callTypeObservers = (type, transaction, event) => {\n  const changedType = type;\n  const changedParentTypes = transaction.changedParentTypes;\n  while (true) {\n    // @ts-ignore\n    map.setIfUndefined(changedParentTypes, type, () => []).push(event);\n    if (type._item === null) {\n      break\n    }\n    type = /** @type {AbstractType<any>} */ (type._item.parent);\n  }\n  callEventHandlerListeners(changedType._eH, event, transaction);\n};\n\n/**\n * @template EventType\n * Abstract Yjs Type class\n */\nclass AbstractType {\n  constructor () {\n    /**\n     * @type {Item|null}\n     */\n    this._item = null;\n    /**\n     * @type {Map<string,Item>}\n     */\n    this._map = new Map();\n    /**\n     * @type {Item|null}\n     */\n    this._start = null;\n    /**\n     * @type {Doc|null}\n     */\n    this.doc = null;\n    this._length = 0;\n    /**\n     * Event handlers\n     * @type {EventHandler<EventType,Transaction>}\n     */\n    this._eH = createEventHandler();\n    /**\n     * Deep event handlers\n     * @type {EventHandler<Array<YEvent<any>>,Transaction>}\n     */\n    this._dEH = createEventHandler();\n    /**\n     * @type {null | Array<ArraySearchMarker>}\n     */\n    this._searchMarker = null;\n  }\n\n  /**\n   * @return {AbstractType<any>|null}\n   */\n  get parent () {\n    return this._item ? /** @type {AbstractType<any>} */ (this._item.parent) : null\n  }\n\n  /**\n   * Integrate this type into the Yjs instance.\n   *\n   * * Save this struct in the os\n   * * This type is sent to other client\n   * * Observer functions are fired\n   *\n   * @param {Doc} y The Yjs instance\n   * @param {Item|null} item\n   */\n  _integrate (y, item) {\n    this.doc = y;\n    this._item = item;\n  }\n\n  /**\n   * @return {AbstractType<EventType>}\n   */\n  _copy () {\n    throw error.methodUnimplemented()\n  }\n\n  /**\n   * @return {AbstractType<EventType>}\n   */\n  clone () {\n    throw error.methodUnimplemented()\n  }\n\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} _encoder\n   */\n  _write (_encoder) { }\n\n  /**\n   * The first non-deleted item\n   */\n  get _first () {\n    let n = this._start;\n    while (n !== null && n.deleted) {\n      n = n.right;\n    }\n    return n\n  }\n\n  /**\n   * Creates YEvent and calls all type observers.\n   * Must be implemented by each type.\n   *\n   * @param {Transaction} transaction\n   * @param {Set<null|string>} _parentSubs Keys changed on this type. `null` if list was modified.\n   */\n  _callObserver (transaction, _parentSubs) {\n    if (!transaction.local && this._searchMarker) {\n      this._searchMarker.length = 0;\n    }\n  }\n\n  /**\n   * Observe all events that are created on this type.\n   *\n   * @param {function(EventType, Transaction):void} f Observer function\n   */\n  observe (f) {\n    addEventHandlerListener(this._eH, f);\n  }\n\n  /**\n   * Observe all events that are created by this type and its children.\n   *\n   * @param {function(Array<YEvent<any>>,Transaction):void} f Observer function\n   */\n  observeDeep (f) {\n    addEventHandlerListener(this._dEH, f);\n  }\n\n  /**\n   * Unregister an observer function.\n   *\n   * @param {function(EventType,Transaction):void} f Observer function\n   */\n  unobserve (f) {\n    removeEventHandlerListener(this._eH, f);\n  }\n\n  /**\n   * Unregister an observer function.\n   *\n   * @param {function(Array<YEvent<any>>,Transaction):void} f Observer function\n   */\n  unobserveDeep (f) {\n    removeEventHandlerListener(this._dEH, f);\n  }\n\n  /**\n   * @abstract\n   * @return {any}\n   */\n  toJSON () {}\n}\n\n/**\n * @param {AbstractType<any>} type\n * @param {number} start\n * @param {number} end\n * @return {Array<any>}\n *\n * @private\n * @function\n */\nconst typeListSlice = (type, start, end) => {\n  if (start < 0) {\n    start = type._length + start;\n  }\n  if (end < 0) {\n    end = type._length + end;\n  }\n  let len = end - start;\n  const cs = [];\n  let n = type._start;\n  while (n !== null && len > 0) {\n    if (n.countable && !n.deleted) {\n      const c = n.content.getContent();\n      if (c.length <= start) {\n        start -= c.length;\n      } else {\n        for (let i = start; i < c.length && len > 0; i++) {\n          cs.push(c[i]);\n          len--;\n        }\n        start = 0;\n      }\n    }\n    n = n.right;\n  }\n  return cs\n};\n\n/**\n * @param {AbstractType<any>} type\n * @return {Array<any>}\n *\n * @private\n * @function\n */\nconst typeListToArray = type => {\n  const cs = [];\n  let n = type._start;\n  while (n !== null) {\n    if (n.countable && !n.deleted) {\n      const c = n.content.getContent();\n      for (let i = 0; i < c.length; i++) {\n        cs.push(c[i]);\n      }\n    }\n    n = n.right;\n  }\n  return cs\n};\n\n/**\n * @param {AbstractType<any>} type\n * @param {Snapshot} snapshot\n * @return {Array<any>}\n *\n * @private\n * @function\n */\nconst typeListToArraySnapshot = (type, snapshot) => {\n  const cs = [];\n  let n = type._start;\n  while (n !== null) {\n    if (n.countable && isVisible(n, snapshot)) {\n      const c = n.content.getContent();\n      for (let i = 0; i < c.length; i++) {\n        cs.push(c[i]);\n      }\n    }\n    n = n.right;\n  }\n  return cs\n};\n\n/**\n * Executes a provided function on once on overy element of this YArray.\n *\n * @param {AbstractType<any>} type\n * @param {function(any,number,any):void} f A function to execute on every element of this YArray.\n *\n * @private\n * @function\n */\nconst typeListForEach = (type, f) => {\n  let index = 0;\n  let n = type._start;\n  while (n !== null) {\n    if (n.countable && !n.deleted) {\n      const c = n.content.getContent();\n      for (let i = 0; i < c.length; i++) {\n        f(c[i], index++, type);\n      }\n    }\n    n = n.right;\n  }\n};\n\n/**\n * @template C,R\n * @param {AbstractType<any>} type\n * @param {function(C,number,AbstractType<any>):R} f\n * @return {Array<R>}\n *\n * @private\n * @function\n */\nconst typeListMap = (type, f) => {\n  /**\n   * @type {Array<any>}\n   */\n  const result = [];\n  typeListForEach(type, (c, i) => {\n    result.push(f(c, i, type));\n  });\n  return result\n};\n\n/**\n * @param {AbstractType<any>} type\n * @return {IterableIterator<any>}\n *\n * @private\n * @function\n */\nconst typeListCreateIterator = type => {\n  let n = type._start;\n  /**\n   * @type {Array<any>|null}\n   */\n  let currentContent = null;\n  let currentContentIndex = 0;\n  return {\n    [Symbol.iterator] () {\n      return this\n    },\n    next: () => {\n      // find some content\n      if (currentContent === null) {\n        while (n !== null && n.deleted) {\n          n = n.right;\n        }\n        // check if we reached the end, no need to check currentContent, because it does not exist\n        if (n === null) {\n          return {\n            done: true,\n            value: undefined\n          }\n        }\n        // we found n, so we can set currentContent\n        currentContent = n.content.getContent();\n        currentContentIndex = 0;\n        n = n.right; // we used the content of n, now iterate to next\n      }\n      const value = currentContent[currentContentIndex++];\n      // check if we need to empty currentContent\n      if (currentContent.length <= currentContentIndex) {\n        currentContent = null;\n      }\n      return {\n        done: false,\n        value\n      }\n    }\n  }\n};\n\n/**\n * @param {AbstractType<any>} type\n * @param {number} index\n * @return {any}\n *\n * @private\n * @function\n */\nconst typeListGet = (type, index) => {\n  const marker = findMarker(type, index);\n  let n = type._start;\n  if (marker !== null) {\n    n = marker.p;\n    index -= marker.index;\n  }\n  for (; n !== null; n = n.right) {\n    if (!n.deleted && n.countable) {\n      if (index < n.length) {\n        return n.content.getContent()[index]\n      }\n      index -= n.length;\n    }\n  }\n};\n\n/**\n * @param {Transaction} transaction\n * @param {AbstractType<any>} parent\n * @param {Item?} referenceItem\n * @param {Array<Object<string,any>|Array<any>|boolean|number|null|string|Uint8Array>} content\n *\n * @private\n * @function\n */\nconst typeListInsertGenericsAfter = (transaction, parent, referenceItem, content) => {\n  let left = referenceItem;\n  const doc = transaction.doc;\n  const ownClientId = doc.clientID;\n  const store = doc.store;\n  const right = referenceItem === null ? parent._start : referenceItem.right;\n  /**\n   * @type {Array<Object|Array<any>|number|null>}\n   */\n  let jsonContent = [];\n  const packJsonContent = () => {\n    if (jsonContent.length > 0) {\n      left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentAny(jsonContent));\n      left.integrate(transaction, 0);\n      jsonContent = [];\n    }\n  };\n  content.forEach(c => {\n    if (c === null) {\n      jsonContent.push(c);\n    } else {\n      switch (c.constructor) {\n        case Number:\n        case Object:\n        case Boolean:\n        case Array:\n        case String:\n          jsonContent.push(c);\n          break\n        default:\n          packJsonContent();\n          switch (c.constructor) {\n            case Uint8Array:\n            case ArrayBuffer:\n              left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentBinary(new Uint8Array(/** @type {Uint8Array} */ (c))));\n              left.integrate(transaction, 0);\n              break\n            case Doc:\n              left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentDoc(/** @type {Doc} */ (c)));\n              left.integrate(transaction, 0);\n              break\n            default:\n              if (c instanceof AbstractType) {\n                left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentType(c));\n                left.integrate(transaction, 0);\n              } else {\n                throw new Error('Unexpected content type in insert operation')\n              }\n          }\n      }\n    }\n  });\n  packJsonContent();\n};\n\nconst lengthExceeded = error.create('Length exceeded!');\n\n/**\n * @param {Transaction} transaction\n * @param {AbstractType<any>} parent\n * @param {number} index\n * @param {Array<Object<string,any>|Array<any>|number|null|string|Uint8Array>} content\n *\n * @private\n * @function\n */\nconst typeListInsertGenerics = (transaction, parent, index, content) => {\n  if (index > parent._length) {\n    throw lengthExceeded\n  }\n  if (index === 0) {\n    if (parent._searchMarker) {\n      updateMarkerChanges(parent._searchMarker, index, content.length);\n    }\n    return typeListInsertGenericsAfter(transaction, parent, null, content)\n  }\n  const startIndex = index;\n  const marker = findMarker(parent, index);\n  let n = parent._start;\n  if (marker !== null) {\n    n = marker.p;\n    index -= marker.index;\n    // we need to iterate one to the left so that the algorithm works\n    if (index === 0) {\n      // @todo refactor this as it actually doesn't consider formats\n      n = n.prev; // important! get the left undeleted item so that we can actually decrease index\n      index += (n && n.countable && !n.deleted) ? n.length : 0;\n    }\n  }\n  for (; n !== null; n = n.right) {\n    if (!n.deleted && n.countable) {\n      if (index <= n.length) {\n        if (index < n.length) {\n          // insert in-between\n          getItemCleanStart(transaction, createID(n.id.client, n.id.clock + index));\n        }\n        break\n      }\n      index -= n.length;\n    }\n  }\n  if (parent._searchMarker) {\n    updateMarkerChanges(parent._searchMarker, startIndex, content.length);\n  }\n  return typeListInsertGenericsAfter(transaction, parent, n, content)\n};\n\n/**\n * Pushing content is special as we generally want to push after the last item. So we don't have to update\n * the serach marker.\n *\n * @param {Transaction} transaction\n * @param {AbstractType<any>} parent\n * @param {Array<Object<string,any>|Array<any>|number|null|string|Uint8Array>} content\n *\n * @private\n * @function\n */\nconst typeListPushGenerics = (transaction, parent, content) => {\n  // Use the marker with the highest index and iterate to the right.\n  const marker = (parent._searchMarker || []).reduce((maxMarker, currMarker) => currMarker.index > maxMarker.index ? currMarker : maxMarker, { index: 0, p: parent._start });\n  let n = marker.p;\n  if (n) {\n    while (n.right) {\n      n = n.right;\n    }\n  }\n  return typeListInsertGenericsAfter(transaction, parent, n, content)\n};\n\n/**\n * @param {Transaction} transaction\n * @param {AbstractType<any>} parent\n * @param {number} index\n * @param {number} length\n *\n * @private\n * @function\n */\nconst typeListDelete = (transaction, parent, index, length) => {\n  if (length === 0) { return }\n  const startIndex = index;\n  const startLength = length;\n  const marker = findMarker(parent, index);\n  let n = parent._start;\n  if (marker !== null) {\n    n = marker.p;\n    index -= marker.index;\n  }\n  // compute the first item to be deleted\n  for (; n !== null && index > 0; n = n.right) {\n    if (!n.deleted && n.countable) {\n      if (index < n.length) {\n        getItemCleanStart(transaction, createID(n.id.client, n.id.clock + index));\n      }\n      index -= n.length;\n    }\n  }\n  // delete all items until done\n  while (length > 0 && n !== null) {\n    if (!n.deleted) {\n      if (length < n.length) {\n        getItemCleanStart(transaction, createID(n.id.client, n.id.clock + length));\n      }\n      n.delete(transaction);\n      length -= n.length;\n    }\n    n = n.right;\n  }\n  if (length > 0) {\n    throw lengthExceeded\n  }\n  if (parent._searchMarker) {\n    updateMarkerChanges(parent._searchMarker, startIndex, -startLength + length /* in case we remove the above exception */);\n  }\n};\n\n/**\n * @param {Transaction} transaction\n * @param {AbstractType<any>} parent\n * @param {string} key\n *\n * @private\n * @function\n */\nconst typeMapDelete = (transaction, parent, key) => {\n  const c = parent._map.get(key);\n  if (c !== undefined) {\n    c.delete(transaction);\n  }\n};\n\n/**\n * @param {Transaction} transaction\n * @param {AbstractType<any>} parent\n * @param {string} key\n * @param {Object|number|null|Array<any>|string|Uint8Array|AbstractType<any>} value\n *\n * @private\n * @function\n */\nconst typeMapSet = (transaction, parent, key, value) => {\n  const left = parent._map.get(key) || null;\n  const doc = transaction.doc;\n  const ownClientId = doc.clientID;\n  let content;\n  if (value == null) {\n    content = new ContentAny([value]);\n  } else {\n    switch (value.constructor) {\n      case Number:\n      case Object:\n      case Boolean:\n      case Array:\n      case String:\n        content = new ContentAny([value]);\n        break\n      case Uint8Array:\n        content = new ContentBinary(/** @type {Uint8Array} */ (value));\n        break\n      case Doc:\n        content = new ContentDoc(/** @type {Doc} */ (value));\n        break\n      default:\n        if (value instanceof AbstractType) {\n          content = new ContentType(value);\n        } else {\n          throw new Error('Unexpected content type')\n        }\n    }\n  }\n  new Item(createID(ownClientId, getState(doc.store, ownClientId)), left, left && left.lastId, null, null, parent, key, content).integrate(transaction, 0);\n};\n\n/**\n * @param {AbstractType<any>} parent\n * @param {string} key\n * @return {Object<string,any>|number|null|Array<any>|string|Uint8Array|AbstractType<any>|undefined}\n *\n * @private\n * @function\n */\nconst typeMapGet = (parent, key) => {\n  const val = parent._map.get(key);\n  return val !== undefined && !val.deleted ? val.content.getContent()[val.length - 1] : undefined\n};\n\n/**\n * @param {AbstractType<any>} parent\n * @return {Object<string,Object<string,any>|number|null|Array<any>|string|Uint8Array|AbstractType<any>|undefined>}\n *\n * @private\n * @function\n */\nconst typeMapGetAll = (parent) => {\n  /**\n   * @type {Object<string,any>}\n   */\n  const res = {};\n  parent._map.forEach((value, key) => {\n    if (!value.deleted) {\n      res[key] = value.content.getContent()[value.length - 1];\n    }\n  });\n  return res\n};\n\n/**\n * @param {AbstractType<any>} parent\n * @param {string} key\n * @return {boolean}\n *\n * @private\n * @function\n */\nconst typeMapHas = (parent, key) => {\n  const val = parent._map.get(key);\n  return val !== undefined && !val.deleted\n};\n\n/**\n * @param {AbstractType<any>} parent\n * @param {string} key\n * @param {Snapshot} snapshot\n * @return {Object<string,any>|number|null|Array<any>|string|Uint8Array|AbstractType<any>|undefined}\n *\n * @private\n * @function\n */\nconst typeMapGetSnapshot = (parent, key, snapshot) => {\n  let v = parent._map.get(key) || null;\n  while (v !== null && (!snapshot.sv.has(v.id.client) || v.id.clock >= (snapshot.sv.get(v.id.client) || 0))) {\n    v = v.left;\n  }\n  return v !== null && isVisible(v, snapshot) ? v.content.getContent()[v.length - 1] : undefined\n};\n\n/**\n * @param {Map<string,Item>} map\n * @return {IterableIterator<Array<any>>}\n *\n * @private\n * @function\n */\nconst createMapIterator = map => iterator.iteratorFilter(map.entries(), /** @param {any} entry */ entry => !entry[1].deleted);\n\n/**\n * @module YArray\n */\n\n/**\n * Event that describes the changes on a YArray\n * @template T\n * @extends YEvent<YArray<T>>\n */\nclass YArrayEvent extends YEvent {\n  /**\n   * @param {YArray<T>} yarray The changed type\n   * @param {Transaction} transaction The transaction object\n   */\n  constructor (yarray, transaction) {\n    super(yarray, transaction);\n    this._transaction = transaction;\n  }\n}\n\n/**\n * A shared Array implementation.\n * @template T\n * @extends AbstractType<YArrayEvent<T>>\n * @implements {Iterable<T>}\n */\nclass YArray extends AbstractType {\n  constructor () {\n    super();\n    /**\n     * @type {Array<any>?}\n     * @private\n     */\n    this._prelimContent = [];\n    /**\n     * @type {Array<ArraySearchMarker>}\n     */\n    this._searchMarker = [];\n  }\n\n  /**\n   * Construct a new YArray containing the specified items.\n   * @template {Object<string,any>|Array<any>|number|null|string|Uint8Array} T\n   * @param {Array<T>} items\n   * @return {YArray<T>}\n   */\n  static from (items) {\n    /**\n     * @type {YArray<T>}\n     */\n    const a = new YArray();\n    a.push(items);\n    return a\n  }\n\n  /**\n   * Integrate this type into the Yjs instance.\n   *\n   * * Save this struct in the os\n   * * This type is sent to other client\n   * * Observer functions are fired\n   *\n   * @param {Doc} y The Yjs instance\n   * @param {Item} item\n   */\n  _integrate (y, item) {\n    super._integrate(y, item);\n    this.insert(0, /** @type {Array<any>} */ (this._prelimContent));\n    this._prelimContent = null;\n  }\n\n  /**\n   * @return {YArray<T>}\n   */\n  _copy () {\n    return new YArray()\n  }\n\n  /**\n   * @return {YArray<T>}\n   */\n  clone () {\n    /**\n     * @type {YArray<T>}\n     */\n    const arr = new YArray();\n    arr.insert(0, this.toArray().map(el =>\n      el instanceof AbstractType ? /** @type {typeof el} */ (el.clone()) : el\n    ));\n    return arr\n  }\n\n  get length () {\n    return this._prelimContent === null ? this._length : this._prelimContent.length\n  }\n\n  /**\n   * Creates YArrayEvent and calls observers.\n   *\n   * @param {Transaction} transaction\n   * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.\n   */\n  _callObserver (transaction, parentSubs) {\n    super._callObserver(transaction, parentSubs);\n    callTypeObservers(this, transaction, new YArrayEvent(this, transaction));\n  }\n\n  /**\n   * Inserts new content at an index.\n   *\n   * Important: This function expects an array of content. Not just a content\n   * object. The reason for this \"weirdness\" is that inserting several elements\n   * is very efficient when it is done as a single operation.\n   *\n   * @example\n   *  // Insert character 'a' at position 0\n   *  yarray.insert(0, ['a'])\n   *  // Insert numbers 1, 2 at position 1\n   *  yarray.insert(1, [1, 2])\n   *\n   * @param {number} index The index to insert content at.\n   * @param {Array<T>} content The array of content\n   */\n  insert (index, content) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        typeListInsertGenerics(transaction, this, index, /** @type {any} */ (content));\n      });\n    } else {\n      /** @type {Array<any>} */ (this._prelimContent).splice(index, 0, ...content);\n    }\n  }\n\n  /**\n   * Appends content to this YArray.\n   *\n   * @param {Array<T>} content Array of content to append.\n   *\n   * @todo Use the following implementation in all types.\n   */\n  push (content) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        typeListPushGenerics(transaction, this, /** @type {any} */ (content));\n      });\n    } else {\n      /** @type {Array<any>} */ (this._prelimContent).push(...content);\n    }\n  }\n\n  /**\n   * Preppends content to this YArray.\n   *\n   * @param {Array<T>} content Array of content to preppend.\n   */\n  unshift (content) {\n    this.insert(0, content);\n  }\n\n  /**\n   * Deletes elements starting from an index.\n   *\n   * @param {number} index Index at which to start deleting elements\n   * @param {number} length The number of elements to remove. Defaults to 1.\n   */\n  delete (index, length = 1) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        typeListDelete(transaction, this, index, length);\n      });\n    } else {\n      /** @type {Array<any>} */ (this._prelimContent).splice(index, length);\n    }\n  }\n\n  /**\n   * Returns the i-th element from a YArray.\n   *\n   * @param {number} index The index of the element to return from the YArray\n   * @return {T}\n   */\n  get (index) {\n    return typeListGet(this, index)\n  }\n\n  /**\n   * Transforms this YArray to a JavaScript Array.\n   *\n   * @return {Array<T>}\n   */\n  toArray () {\n    return typeListToArray(this)\n  }\n\n  /**\n   * Transforms this YArray to a JavaScript Array.\n   *\n   * @param {number} [start]\n   * @param {number} [end]\n   * @return {Array<T>}\n   */\n  slice (start = 0, end = this.length) {\n    return typeListSlice(this, start, end)\n  }\n\n  /**\n   * Transforms this Shared Type to a JSON object.\n   *\n   * @return {Array<any>}\n   */\n  toJSON () {\n    return this.map(c => c instanceof AbstractType ? c.toJSON() : c)\n  }\n\n  /**\n   * Returns an Array with the result of calling a provided function on every\n   * element of this YArray.\n   *\n   * @template M\n   * @param {function(T,number,YArray<T>):M} f Function that produces an element of the new Array\n   * @return {Array<M>} A new array with each element being the result of the\n   *                 callback function\n   */\n  map (f) {\n    return typeListMap(this, /** @type {any} */ (f))\n  }\n\n  /**\n   * Executes a provided function once on overy element of this YArray.\n   *\n   * @param {function(T,number,YArray<T>):void} f A function to execute on every element of this YArray.\n   */\n  forEach (f) {\n    typeListForEach(this, f);\n  }\n\n  /**\n   * @return {IterableIterator<T>}\n   */\n  [Symbol.iterator] () {\n    return typeListCreateIterator(this)\n  }\n\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   */\n  _write (encoder) {\n    encoder.writeTypeRef(YArrayRefID);\n  }\n}\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2} _decoder\n *\n * @private\n * @function\n */\nconst readYArray = _decoder => new YArray();\n\n/**\n * @template T\n * @extends YEvent<YMap<T>>\n * Event that describes the changes on a YMap.\n */\nclass YMapEvent extends YEvent {\n  /**\n   * @param {YMap<T>} ymap The YArray that changed.\n   * @param {Transaction} transaction\n   * @param {Set<any>} subs The keys that changed.\n   */\n  constructor (ymap, transaction, subs) {\n    super(ymap, transaction);\n    this.keysChanged = subs;\n  }\n}\n\n/**\n * @template MapType\n * A shared Map implementation.\n *\n * @extends AbstractType<YMapEvent<MapType>>\n * @implements {Iterable<MapType>}\n */\nclass YMap extends AbstractType {\n  /**\n   *\n   * @param {Iterable<readonly [string, any]>=} entries - an optional iterable to initialize the YMap\n   */\n  constructor (entries) {\n    super();\n    /**\n     * @type {Map<string,any>?}\n     * @private\n     */\n    this._prelimContent = null;\n\n    if (entries === undefined) {\n      this._prelimContent = new Map();\n    } else {\n      this._prelimContent = new Map(entries);\n    }\n  }\n\n  /**\n   * Integrate this type into the Yjs instance.\n   *\n   * * Save this struct in the os\n   * * This type is sent to other client\n   * * Observer functions are fired\n   *\n   * @param {Doc} y The Yjs instance\n   * @param {Item} item\n   */\n  _integrate (y, item) {\n    super._integrate(y, item)\n    ;/** @type {Map<string, any>} */ (this._prelimContent).forEach((value, key) => {\n      this.set(key, value);\n    });\n    this._prelimContent = null;\n  }\n\n  /**\n   * @return {YMap<MapType>}\n   */\n  _copy () {\n    return new YMap()\n  }\n\n  /**\n   * @return {YMap<MapType>}\n   */\n  clone () {\n    /**\n     * @type {YMap<MapType>}\n     */\n    const map = new YMap();\n    this.forEach((value, key) => {\n      map.set(key, value instanceof AbstractType ? /** @type {typeof value} */ (value.clone()) : value);\n    });\n    return map\n  }\n\n  /**\n   * Creates YMapEvent and calls observers.\n   *\n   * @param {Transaction} transaction\n   * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.\n   */\n  _callObserver (transaction, parentSubs) {\n    callTypeObservers(this, transaction, new YMapEvent(this, transaction, parentSubs));\n  }\n\n  /**\n   * Transforms this Shared Type to a JSON object.\n   *\n   * @return {Object<string,any>}\n   */\n  toJSON () {\n    /**\n     * @type {Object<string,MapType>}\n     */\n    const map = {};\n    this._map.forEach((item, key) => {\n      if (!item.deleted) {\n        const v = item.content.getContent()[item.length - 1];\n        map[key] = v instanceof AbstractType ? v.toJSON() : v;\n      }\n    });\n    return map\n  }\n\n  /**\n   * Returns the size of the YMap (count of key/value pairs)\n   *\n   * @return {number}\n   */\n  get size () {\n    return [...createMapIterator(this._map)].length\n  }\n\n  /**\n   * Returns the keys for each element in the YMap Type.\n   *\n   * @return {IterableIterator<string>}\n   */\n  keys () {\n    return iterator.iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => v[0])\n  }\n\n  /**\n   * Returns the values for each element in the YMap Type.\n   *\n   * @return {IterableIterator<any>}\n   */\n  values () {\n    return iterator.iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => v[1].content.getContent()[v[1].length - 1])\n  }\n\n  /**\n   * Returns an Iterator of [key, value] pairs\n   *\n   * @return {IterableIterator<any>}\n   */\n  entries () {\n    return iterator.iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => [v[0], v[1].content.getContent()[v[1].length - 1]])\n  }\n\n  /**\n   * Executes a provided function on once on every key-value pair.\n   *\n   * @param {function(MapType,string,YMap<MapType>):void} f A function to execute on every element of this YArray.\n   */\n  forEach (f) {\n    this._map.forEach((item, key) => {\n      if (!item.deleted) {\n        f(item.content.getContent()[item.length - 1], key, this);\n      }\n    });\n  }\n\n  /**\n   * Returns an Iterator of [key, value] pairs\n   *\n   * @return {IterableIterator<any>}\n   */\n  [Symbol.iterator] () {\n    return this.entries()\n  }\n\n  /**\n   * Remove a specified element from this YMap.\n   *\n   * @param {string} key The key of the element to remove.\n   */\n  delete (key) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        typeMapDelete(transaction, this, key);\n      });\n    } else {\n      /** @type {Map<string, any>} */ (this._prelimContent).delete(key);\n    }\n  }\n\n  /**\n   * Adds or updates an element with a specified key and value.\n   * @template {MapType} VAL\n   *\n   * @param {string} key The key of the element to add to this YMap\n   * @param {VAL} value The value of the element to add\n   * @return {VAL}\n   */\n  set (key, value) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        typeMapSet(transaction, this, key, /** @type {any} */ (value));\n      });\n    } else {\n      /** @type {Map<string, any>} */ (this._prelimContent).set(key, value);\n    }\n    return value\n  }\n\n  /**\n   * Returns a specified element from this YMap.\n   *\n   * @param {string} key\n   * @return {MapType|undefined}\n   */\n  get (key) {\n    return /** @type {any} */ (typeMapGet(this, key))\n  }\n\n  /**\n   * Returns a boolean indicating whether the specified key exists or not.\n   *\n   * @param {string} key The key to test.\n   * @return {boolean}\n   */\n  has (key) {\n    return typeMapHas(this, key)\n  }\n\n  /**\n   * Removes all elements from this YMap.\n   */\n  clear () {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        this.forEach(function (_value, key, map) {\n          typeMapDelete(transaction, map, key);\n        });\n      });\n    } else {\n      /** @type {Map<string, any>} */ (this._prelimContent).clear();\n    }\n  }\n\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   */\n  _write (encoder) {\n    encoder.writeTypeRef(YMapRefID);\n  }\n}\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2} _decoder\n *\n * @private\n * @function\n */\nconst readYMap = _decoder => new YMap();\n\n/**\n * @param {any} a\n * @param {any} b\n * @return {boolean}\n */\nconst equalAttrs = (a, b) => a === b || (typeof a === 'object' && typeof b === 'object' && a && b && object.equalFlat(a, b));\n\nclass ItemTextListPosition {\n  /**\n   * @param {Item|null} left\n   * @param {Item|null} right\n   * @param {number} index\n   * @param {Map<string,any>} currentAttributes\n   */\n  constructor (left, right, index, currentAttributes) {\n    this.left = left;\n    this.right = right;\n    this.index = index;\n    this.currentAttributes = currentAttributes;\n  }\n\n  /**\n   * Only call this if you know that this.right is defined\n   */\n  forward () {\n    if (this.right === null) {\n      error.unexpectedCase();\n    }\n    switch (this.right.content.constructor) {\n      case ContentFormat:\n        if (!this.right.deleted) {\n          updateCurrentAttributes(this.currentAttributes, /** @type {ContentFormat} */ (this.right.content));\n        }\n        break\n      default:\n        if (!this.right.deleted) {\n          this.index += this.right.length;\n        }\n        break\n    }\n    this.left = this.right;\n    this.right = this.right.right;\n  }\n}\n\n/**\n * @param {Transaction} transaction\n * @param {ItemTextListPosition} pos\n * @param {number} count steps to move forward\n * @return {ItemTextListPosition}\n *\n * @private\n * @function\n */\nconst findNextPosition = (transaction, pos, count) => {\n  while (pos.right !== null && count > 0) {\n    switch (pos.right.content.constructor) {\n      case ContentFormat:\n        if (!pos.right.deleted) {\n          updateCurrentAttributes(pos.currentAttributes, /** @type {ContentFormat} */ (pos.right.content));\n        }\n        break\n      default:\n        if (!pos.right.deleted) {\n          if (count < pos.right.length) {\n            // split right\n            getItemCleanStart(transaction, createID(pos.right.id.client, pos.right.id.clock + count));\n          }\n          pos.index += pos.right.length;\n          count -= pos.right.length;\n        }\n        break\n    }\n    pos.left = pos.right;\n    pos.right = pos.right.right;\n    // pos.forward() - we don't forward because that would halve the performance because we already do the checks above\n  }\n  return pos\n};\n\n/**\n * @param {Transaction} transaction\n * @param {AbstractType<any>} parent\n * @param {number} index\n * @return {ItemTextListPosition}\n *\n * @private\n * @function\n */\nconst findPosition = (transaction, parent, index) => {\n  const currentAttributes = new Map();\n  const marker = findMarker(parent, index);\n  if (marker) {\n    const pos = new ItemTextListPosition(marker.p.left, marker.p, marker.index, currentAttributes);\n    return findNextPosition(transaction, pos, index - marker.index)\n  } else {\n    const pos = new ItemTextListPosition(null, parent._start, 0, currentAttributes);\n    return findNextPosition(transaction, pos, index)\n  }\n};\n\n/**\n * Negate applied formats\n *\n * @param {Transaction} transaction\n * @param {AbstractType<any>} parent\n * @param {ItemTextListPosition} currPos\n * @param {Map<string,any>} negatedAttributes\n *\n * @private\n * @function\n */\nconst insertNegatedAttributes = (transaction, parent, currPos, negatedAttributes) => {\n  // check if we really need to remove attributes\n  while (\n    currPos.right !== null && (\n      currPos.right.deleted === true || (\n        currPos.right.content.constructor === ContentFormat &&\n        equalAttrs(negatedAttributes.get(/** @type {ContentFormat} */ (currPos.right.content).key), /** @type {ContentFormat} */ (currPos.right.content).value)\n      )\n    )\n  ) {\n    if (!currPos.right.deleted) {\n      negatedAttributes.delete(/** @type {ContentFormat} */ (currPos.right.content).key);\n    }\n    currPos.forward();\n  }\n  const doc = transaction.doc;\n  const ownClientId = doc.clientID;\n  negatedAttributes.forEach((val, key) => {\n    const left = currPos.left;\n    const right = currPos.right;\n    const nextFormat = new Item(createID(ownClientId, getState(doc.store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentFormat(key, val));\n    nextFormat.integrate(transaction, 0);\n    currPos.right = nextFormat;\n    currPos.forward();\n  });\n};\n\n/**\n * @param {Map<string,any>} currentAttributes\n * @param {ContentFormat} format\n *\n * @private\n * @function\n */\nconst updateCurrentAttributes = (currentAttributes, format) => {\n  const { key, value } = format;\n  if (value === null) {\n    currentAttributes.delete(key);\n  } else {\n    currentAttributes.set(key, value);\n  }\n};\n\n/**\n * @param {ItemTextListPosition} currPos\n * @param {Object<string,any>} attributes\n *\n * @private\n * @function\n */\nconst minimizeAttributeChanges = (currPos, attributes) => {\n  // go right while attributes[right.key] === right.value (or right is deleted)\n  while (true) {\n    if (currPos.right === null) {\n      break\n    } else if (currPos.right.deleted || (currPos.right.content.constructor === ContentFormat && equalAttrs(attributes[(/** @type {ContentFormat} */ (currPos.right.content)).key] || null, /** @type {ContentFormat} */ (currPos.right.content).value))) ; else {\n      break\n    }\n    currPos.forward();\n  }\n};\n\n/**\n * @param {Transaction} transaction\n * @param {AbstractType<any>} parent\n * @param {ItemTextListPosition} currPos\n * @param {Object<string,any>} attributes\n * @return {Map<string,any>}\n *\n * @private\n * @function\n **/\nconst insertAttributes = (transaction, parent, currPos, attributes) => {\n  const doc = transaction.doc;\n  const ownClientId = doc.clientID;\n  const negatedAttributes = new Map();\n  // insert format-start items\n  for (const key in attributes) {\n    const val = attributes[key];\n    const currentVal = currPos.currentAttributes.get(key) || null;\n    if (!equalAttrs(currentVal, val)) {\n      // save negated attribute (set null if currentVal undefined)\n      negatedAttributes.set(key, currentVal);\n      const { left, right } = currPos;\n      currPos.right = new Item(createID(ownClientId, getState(doc.store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentFormat(key, val));\n      currPos.right.integrate(transaction, 0);\n      currPos.forward();\n    }\n  }\n  return negatedAttributes\n};\n\n/**\n * @param {Transaction} transaction\n * @param {AbstractType<any>} parent\n * @param {ItemTextListPosition} currPos\n * @param {string|object|AbstractType<any>} text\n * @param {Object<string,any>} attributes\n *\n * @private\n * @function\n **/\nconst insertText = (transaction, parent, currPos, text, attributes) => {\n  currPos.currentAttributes.forEach((_val, key) => {\n    if (attributes[key] === undefined) {\n      attributes[key] = null;\n    }\n  });\n  const doc = transaction.doc;\n  const ownClientId = doc.clientID;\n  minimizeAttributeChanges(currPos, attributes);\n  const negatedAttributes = insertAttributes(transaction, parent, currPos, attributes);\n  // insert content\n  const content = text.constructor === String ? new ContentString(/** @type {string} */ (text)) : (text instanceof AbstractType ? new ContentType(text) : new ContentEmbed(text));\n  let { left, right, index } = currPos;\n  if (parent._searchMarker) {\n    updateMarkerChanges(parent._searchMarker, currPos.index, content.getLength());\n  }\n  right = new Item(createID(ownClientId, getState(doc.store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, content);\n  right.integrate(transaction, 0);\n  currPos.right = right;\n  currPos.index = index;\n  currPos.forward();\n  insertNegatedAttributes(transaction, parent, currPos, negatedAttributes);\n};\n\n/**\n * @param {Transaction} transaction\n * @param {AbstractType<any>} parent\n * @param {ItemTextListPosition} currPos\n * @param {number} length\n * @param {Object<string,any>} attributes\n *\n * @private\n * @function\n */\nconst formatText = (transaction, parent, currPos, length, attributes) => {\n  const doc = transaction.doc;\n  const ownClientId = doc.clientID;\n  minimizeAttributeChanges(currPos, attributes);\n  const negatedAttributes = insertAttributes(transaction, parent, currPos, attributes);\n  // iterate until first non-format or null is found\n  // delete all formats with attributes[format.key] != null\n  // also check the attributes after the first non-format as we do not want to insert redundant negated attributes there\n  // eslint-disable-next-line no-labels\n  iterationLoop: while (\n    currPos.right !== null &&\n    (length > 0 ||\n      (\n        negatedAttributes.size > 0 &&\n        (currPos.right.deleted || currPos.right.content.constructor === ContentFormat)\n      )\n    )\n  ) {\n    if (!currPos.right.deleted) {\n      switch (currPos.right.content.constructor) {\n        case ContentFormat: {\n          const { key, value } = /** @type {ContentFormat} */ (currPos.right.content);\n          const attr = attributes[key];\n          if (attr !== undefined) {\n            if (equalAttrs(attr, value)) {\n              negatedAttributes.delete(key);\n            } else {\n              if (length === 0) {\n                // no need to further extend negatedAttributes\n                // eslint-disable-next-line no-labels\n                break iterationLoop\n              }\n              negatedAttributes.set(key, value);\n            }\n            currPos.right.delete(transaction);\n          } else {\n            currPos.currentAttributes.set(key, value);\n          }\n          break\n        }\n        default:\n          if (length < currPos.right.length) {\n            getItemCleanStart(transaction, createID(currPos.right.id.client, currPos.right.id.clock + length));\n          }\n          length -= currPos.right.length;\n          break\n      }\n    }\n    currPos.forward();\n  }\n  // Quill just assumes that the editor starts with a newline and that it always\n  // ends with a newline. We only insert that newline when a new newline is\n  // inserted - i.e when length is bigger than type.length\n  if (length > 0) {\n    let newlines = '';\n    for (; length > 0; length--) {\n      newlines += '\\n';\n    }\n    currPos.right = new Item(createID(ownClientId, getState(doc.store, ownClientId)), currPos.left, currPos.left && currPos.left.lastId, currPos.right, currPos.right && currPos.right.id, parent, null, new ContentString(newlines));\n    currPos.right.integrate(transaction, 0);\n    currPos.forward();\n  }\n  insertNegatedAttributes(transaction, parent, currPos, negatedAttributes);\n};\n\n/**\n * Call this function after string content has been deleted in order to\n * clean up formatting Items.\n *\n * @param {Transaction} transaction\n * @param {Item} start\n * @param {Item|null} curr exclusive end, automatically iterates to the next Content Item\n * @param {Map<string,any>} startAttributes\n * @param {Map<string,any>} currAttributes\n * @return {number} The amount of formatting Items deleted.\n *\n * @function\n */\nconst cleanupFormattingGap = (transaction, start, curr, startAttributes, currAttributes) => {\n  /**\n   * @type {Item|null}\n   */\n  let end = start;\n  /**\n   * @type {Map<string,ContentFormat>}\n   */\n  const endFormats = map.create();\n  while (end && (!end.countable || end.deleted)) {\n    if (!end.deleted && end.content.constructor === ContentFormat) {\n      const cf = /** @type {ContentFormat} */ (end.content);\n      endFormats.set(cf.key, cf);\n    }\n    end = end.right;\n  }\n  let cleanups = 0;\n  let reachedCurr = false;\n  while (start !== end) {\n    if (curr === start) {\n      reachedCurr = true;\n    }\n    if (!start.deleted) {\n      const content = start.content;\n      switch (content.constructor) {\n        case ContentFormat: {\n          const { key, value } = /** @type {ContentFormat} */ (content);\n          const startAttrValue = startAttributes.get(key) || null;\n          if (endFormats.get(key) !== content || startAttrValue === value) {\n            // Either this format is overwritten or it is not necessary because the attribute already existed.\n            start.delete(transaction);\n            cleanups++;\n            if (!reachedCurr && (currAttributes.get(key) || null) === value && startAttrValue !== value) {\n              if (startAttrValue === null) {\n                currAttributes.delete(key);\n              } else {\n                currAttributes.set(key, startAttrValue);\n              }\n            }\n          }\n          if (!reachedCurr && !start.deleted) {\n            updateCurrentAttributes(currAttributes, /** @type {ContentFormat} */ (content));\n          }\n          break\n        }\n      }\n    }\n    start = /** @type {Item} */ (start.right);\n  }\n  return cleanups\n};\n\n/**\n * @param {Transaction} transaction\n * @param {Item | null} item\n */\nconst cleanupContextlessFormattingGap = (transaction, item) => {\n  // iterate until item.right is null or content\n  while (item && item.right && (item.right.deleted || !item.right.countable)) {\n    item = item.right;\n  }\n  const attrs = new Set();\n  // iterate back until a content item is found\n  while (item && (item.deleted || !item.countable)) {\n    if (!item.deleted && item.content.constructor === ContentFormat) {\n      const key = /** @type {ContentFormat} */ (item.content).key;\n      if (attrs.has(key)) {\n        item.delete(transaction);\n      } else {\n        attrs.add(key);\n      }\n    }\n    item = item.left;\n  }\n};\n\n/**\n * This function is experimental and subject to change / be removed.\n *\n * Ideally, we don't need this function at all. Formatting attributes should be cleaned up\n * automatically after each change. This function iterates twice over the complete YText type\n * and removes unnecessary formatting attributes. This is also helpful for testing.\n *\n * This function won't be exported anymore as soon as there is confidence that the YText type works as intended.\n *\n * @param {YText} type\n * @return {number} How many formatting attributes have been cleaned up.\n */\nconst cleanupYTextFormatting = type => {\n  let res = 0;\n  transact(/** @type {Doc} */ (type.doc), transaction => {\n    let start = /** @type {Item} */ (type._start);\n    let end = type._start;\n    let startAttributes = map.create();\n    const currentAttributes = map.copy(startAttributes);\n    while (end) {\n      if (end.deleted === false) {\n        switch (end.content.constructor) {\n          case ContentFormat:\n            updateCurrentAttributes(currentAttributes, /** @type {ContentFormat} */ (end.content));\n            break\n          default:\n            res += cleanupFormattingGap(transaction, start, end, startAttributes, currentAttributes);\n            startAttributes = map.copy(currentAttributes);\n            start = end;\n            break\n        }\n      }\n      end = end.right;\n    }\n  });\n  return res\n};\n\n/**\n * This will be called by the transction once the event handlers are called to potentially cleanup\n * formatting attributes.\n *\n * @param {Transaction} transaction\n */\nconst cleanupYTextAfterTransaction = transaction => {\n  /**\n   * @type {Set<YText>}\n   */\n  const needFullCleanup = new Set();\n  // check if another formatting item was inserted\n  const doc = transaction.doc;\n  for (const [client, afterClock] of transaction.afterState.entries()) {\n    const clock = transaction.beforeState.get(client) || 0;\n    if (afterClock === clock) {\n      continue\n    }\n    iterateStructs(transaction, /** @type {Array<Item|GC>} */ (doc.store.clients.get(client)), clock, afterClock, item => {\n      if (\n        !item.deleted && /** @type {Item} */ (item).content.constructor === ContentFormat && item.constructor !== GC\n      ) {\n        needFullCleanup.add(/** @type {any} */ (item).parent);\n      }\n    });\n  }\n  // cleanup in a new transaction\n  transact(doc, (t) => {\n    iterateDeletedStructs(transaction, transaction.deleteSet, item => {\n      if (item instanceof GC || !(/** @type {YText} */ (item.parent)._hasFormatting) || needFullCleanup.has(/** @type {YText} */ (item.parent))) {\n        return\n      }\n      const parent = /** @type {YText} */ (item.parent);\n      if (item.content.constructor === ContentFormat) {\n        needFullCleanup.add(parent);\n      } else {\n        // If no formatting attribute was inserted or deleted, we can make due with contextless\n        // formatting cleanups.\n        // Contextless: it is not necessary to compute currentAttributes for the affected position.\n        cleanupContextlessFormattingGap(t, item);\n      }\n    });\n    // If a formatting item was inserted, we simply clean the whole type.\n    // We need to compute currentAttributes for the current position anyway.\n    for (const yText of needFullCleanup) {\n      cleanupYTextFormatting(yText);\n    }\n  });\n};\n\n/**\n * @param {Transaction} transaction\n * @param {ItemTextListPosition} currPos\n * @param {number} length\n * @return {ItemTextListPosition}\n *\n * @private\n * @function\n */\nconst deleteText = (transaction, currPos, length) => {\n  const startLength = length;\n  const startAttrs = map.copy(currPos.currentAttributes);\n  const start = currPos.right;\n  while (length > 0 && currPos.right !== null) {\n    if (currPos.right.deleted === false) {\n      switch (currPos.right.content.constructor) {\n        case ContentType:\n        case ContentEmbed:\n        case ContentString:\n          if (length < currPos.right.length) {\n            getItemCleanStart(transaction, createID(currPos.right.id.client, currPos.right.id.clock + length));\n          }\n          length -= currPos.right.length;\n          currPos.right.delete(transaction);\n          break\n      }\n    }\n    currPos.forward();\n  }\n  if (start) {\n    cleanupFormattingGap(transaction, start, currPos.right, startAttrs, currPos.currentAttributes);\n  }\n  const parent = /** @type {AbstractType<any>} */ (/** @type {Item} */ (currPos.left || currPos.right).parent);\n  if (parent._searchMarker) {\n    updateMarkerChanges(parent._searchMarker, currPos.index, -startLength + length);\n  }\n  return currPos\n};\n\n/**\n * The Quill Delta format represents changes on a text document with\n * formatting information. For mor information visit {@link https://quilljs.com/docs/delta/|Quill Delta}\n *\n * @example\n *   {\n *     ops: [\n *       { insert: 'Gandalf', attributes: { bold: true } },\n *       { insert: ' the ' },\n *       { insert: 'Grey', attributes: { color: '#cccccc' } }\n *     ]\n *   }\n *\n */\n\n/**\n  * Attributes that can be assigned to a selection of text.\n  *\n  * @example\n  *   {\n  *     bold: true,\n  *     font-size: '40px'\n  *   }\n  *\n  * @typedef {Object} TextAttributes\n  */\n\n/**\n * @extends YEvent<YText>\n * Event that describes the changes on a YText type.\n */\nclass YTextEvent extends YEvent {\n  /**\n   * @param {YText} ytext\n   * @param {Transaction} transaction\n   * @param {Set<any>} subs The keys that changed\n   */\n  constructor (ytext, transaction, subs) {\n    super(ytext, transaction);\n    /**\n     * Whether the children changed.\n     * @type {Boolean}\n     * @private\n     */\n    this.childListChanged = false;\n    /**\n     * Set of all changed attributes.\n     * @type {Set<string>}\n     */\n    this.keysChanged = new Set();\n    subs.forEach((sub) => {\n      if (sub === null) {\n        this.childListChanged = true;\n      } else {\n        this.keysChanged.add(sub);\n      }\n    });\n  }\n\n  /**\n   * @type {{added:Set<Item>,deleted:Set<Item>,keys:Map<string,{action:'add'|'update'|'delete',oldValue:any}>,delta:Array<{insert?:Array<any>|string, delete?:number, retain?:number}>}}\n   */\n  get changes () {\n    if (this._changes === null) {\n      /**\n       * @type {{added:Set<Item>,deleted:Set<Item>,keys:Map<string,{action:'add'|'update'|'delete',oldValue:any}>,delta:Array<{insert?:Array<any>|string|AbstractType<any>|object, delete?:number, retain?:number}>}}\n       */\n      const changes = {\n        keys: this.keys,\n        delta: this.delta,\n        added: new Set(),\n        deleted: new Set()\n      };\n      this._changes = changes;\n    }\n    return /** @type {any} */ (this._changes)\n  }\n\n  /**\n   * Compute the changes in the delta format.\n   * A {@link https://quilljs.com/docs/delta/|Quill Delta}) that represents the changes on the document.\n   *\n   * @type {Array<{insert?:string|object|AbstractType<any>, delete?:number, retain?:number, attributes?: Object<string,any>}>}\n   *\n   * @public\n   */\n  get delta () {\n    if (this._delta === null) {\n      const y = /** @type {Doc} */ (this.target.doc);\n      /**\n       * @type {Array<{insert?:string|object|AbstractType<any>, delete?:number, retain?:number, attributes?: Object<string,any>}>}\n       */\n      const delta = [];\n      transact(y, transaction => {\n        const currentAttributes = new Map(); // saves all current attributes for insert\n        const oldAttributes = new Map();\n        let item = this.target._start;\n        /**\n         * @type {string?}\n         */\n        let action = null;\n        /**\n         * @type {Object<string,any>}\n         */\n        const attributes = {}; // counts added or removed new attributes for retain\n        /**\n         * @type {string|object}\n         */\n        let insert = '';\n        let retain = 0;\n        let deleteLen = 0;\n        const addOp = () => {\n          if (action !== null) {\n            /**\n             * @type {any}\n             */\n            let op = null;\n            switch (action) {\n              case 'delete':\n                if (deleteLen > 0) {\n                  op = { delete: deleteLen };\n                }\n                deleteLen = 0;\n                break\n              case 'insert':\n                if (typeof insert === 'object' || insert.length > 0) {\n                  op = { insert };\n                  if (currentAttributes.size > 0) {\n                    op.attributes = {};\n                    currentAttributes.forEach((value, key) => {\n                      if (value !== null) {\n                        op.attributes[key] = value;\n                      }\n                    });\n                  }\n                }\n                insert = '';\n                break\n              case 'retain':\n                if (retain > 0) {\n                  op = { retain };\n                  if (!object.isEmpty(attributes)) {\n                    op.attributes = object.assign({}, attributes);\n                  }\n                }\n                retain = 0;\n                break\n            }\n            if (op) delta.push(op);\n            action = null;\n          }\n        };\n        while (item !== null) {\n          switch (item.content.constructor) {\n            case ContentType:\n            case ContentEmbed:\n              if (this.adds(item)) {\n                if (!this.deletes(item)) {\n                  addOp();\n                  action = 'insert';\n                  insert = item.content.getContent()[0];\n                  addOp();\n                }\n              } else if (this.deletes(item)) {\n                if (action !== 'delete') {\n                  addOp();\n                  action = 'delete';\n                }\n                deleteLen += 1;\n              } else if (!item.deleted) {\n                if (action !== 'retain') {\n                  addOp();\n                  action = 'retain';\n                }\n                retain += 1;\n              }\n              break\n            case ContentString:\n              if (this.adds(item)) {\n                if (!this.deletes(item)) {\n                  if (action !== 'insert') {\n                    addOp();\n                    action = 'insert';\n                  }\n                  insert += /** @type {ContentString} */ (item.content).str;\n                }\n              } else if (this.deletes(item)) {\n                if (action !== 'delete') {\n                  addOp();\n                  action = 'delete';\n                }\n                deleteLen += item.length;\n              } else if (!item.deleted) {\n                if (action !== 'retain') {\n                  addOp();\n                  action = 'retain';\n                }\n                retain += item.length;\n              }\n              break\n            case ContentFormat: {\n              const { key, value } = /** @type {ContentFormat} */ (item.content);\n              if (this.adds(item)) {\n                if (!this.deletes(item)) {\n                  const curVal = currentAttributes.get(key) || null;\n                  if (!equalAttrs(curVal, value)) {\n                    if (action === 'retain') {\n                      addOp();\n                    }\n                    if (equalAttrs(value, (oldAttributes.get(key) || null))) {\n                      delete attributes[key];\n                    } else {\n                      attributes[key] = value;\n                    }\n                  } else if (value !== null) {\n                    item.delete(transaction);\n                  }\n                }\n              } else if (this.deletes(item)) {\n                oldAttributes.set(key, value);\n                const curVal = currentAttributes.get(key) || null;\n                if (!equalAttrs(curVal, value)) {\n                  if (action === 'retain') {\n                    addOp();\n                  }\n                  attributes[key] = curVal;\n                }\n              } else if (!item.deleted) {\n                oldAttributes.set(key, value);\n                const attr = attributes[key];\n                if (attr !== undefined) {\n                  if (!equalAttrs(attr, value)) {\n                    if (action === 'retain') {\n                      addOp();\n                    }\n                    if (value === null) {\n                      delete attributes[key];\n                    } else {\n                      attributes[key] = value;\n                    }\n                  } else if (attr !== null) { // this will be cleaned up automatically by the contextless cleanup function\n                    item.delete(transaction);\n                  }\n                }\n              }\n              if (!item.deleted) {\n                if (action === 'insert') {\n                  addOp();\n                }\n                updateCurrentAttributes(currentAttributes, /** @type {ContentFormat} */ (item.content));\n              }\n              break\n            }\n          }\n          item = item.right;\n        }\n        addOp();\n        while (delta.length > 0) {\n          const lastOp = delta[delta.length - 1];\n          if (lastOp.retain !== undefined && lastOp.attributes === undefined) {\n            // retain delta's if they don't assign attributes\n            delta.pop();\n          } else {\n            break\n          }\n        }\n      });\n      this._delta = delta;\n    }\n    return /** @type {any} */ (this._delta)\n  }\n}\n\n/**\n * Type that represents text with formatting information.\n *\n * This type replaces y-richtext as this implementation is able to handle\n * block formats (format information on a paragraph), embeds (complex elements\n * like pictures and videos), and text formats (**bold**, *italic*).\n *\n * @extends AbstractType<YTextEvent>\n */\nclass YText extends AbstractType {\n  /**\n   * @param {String} [string] The initial value of the YText.\n   */\n  constructor (string) {\n    super();\n    /**\n     * Array of pending operations on this type\n     * @type {Array<function():void>?}\n     */\n    this._pending = string !== undefined ? [() => this.insert(0, string)] : [];\n    /**\n     * @type {Array<ArraySearchMarker>|null}\n     */\n    this._searchMarker = [];\n    /**\n     * Whether this YText contains formatting attributes.\n     * This flag is updated when a formatting item is integrated (see ContentFormat.integrate)\n     */\n    this._hasFormatting = false;\n  }\n\n  /**\n   * Number of characters of this text type.\n   *\n   * @type {number}\n   */\n  get length () {\n    return this._length\n  }\n\n  /**\n   * @param {Doc} y\n   * @param {Item} item\n   */\n  _integrate (y, item) {\n    super._integrate(y, item);\n    try {\n      /** @type {Array<function>} */ (this._pending).forEach(f => f());\n    } catch (e) {\n      console.error(e);\n    }\n    this._pending = null;\n  }\n\n  _copy () {\n    return new YText()\n  }\n\n  /**\n   * @return {YText}\n   */\n  clone () {\n    const text = new YText();\n    text.applyDelta(this.toDelta());\n    return text\n  }\n\n  /**\n   * Creates YTextEvent and calls observers.\n   *\n   * @param {Transaction} transaction\n   * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.\n   */\n  _callObserver (transaction, parentSubs) {\n    super._callObserver(transaction, parentSubs);\n    const event = new YTextEvent(this, transaction, parentSubs);\n    callTypeObservers(this, transaction, event);\n    // If a remote change happened, we try to cleanup potential formatting duplicates.\n    if (!transaction.local && this._hasFormatting) {\n      transaction._needFormattingCleanup = true;\n    }\n  }\n\n  /**\n   * Returns the unformatted string representation of this YText type.\n   *\n   * @public\n   */\n  toString () {\n    let str = '';\n    /**\n     * @type {Item|null}\n     */\n    let n = this._start;\n    while (n !== null) {\n      if (!n.deleted && n.countable && n.content.constructor === ContentString) {\n        str += /** @type {ContentString} */ (n.content).str;\n      }\n      n = n.right;\n    }\n    return str\n  }\n\n  /**\n   * Returns the unformatted string representation of this YText type.\n   *\n   * @return {string}\n   * @public\n   */\n  toJSON () {\n    return this.toString()\n  }\n\n  /**\n   * Apply a {@link Delta} on this shared YText type.\n   *\n   * @param {any} delta The changes to apply on this element.\n   * @param {object}  opts\n   * @param {boolean} [opts.sanitize] Sanitize input delta. Removes ending newlines if set to true.\n   *\n   *\n   * @public\n   */\n  applyDelta (delta, { sanitize = true } = {}) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        const currPos = new ItemTextListPosition(null, this._start, 0, new Map());\n        for (let i = 0; i < delta.length; i++) {\n          const op = delta[i];\n          if (op.insert !== undefined) {\n            // Quill assumes that the content starts with an empty paragraph.\n            // Yjs/Y.Text assumes that it starts empty. We always hide that\n            // there is a newline at the end of the content.\n            // If we omit this step, clients will see a different number of\n            // paragraphs, but nothing bad will happen.\n            const ins = (!sanitize && typeof op.insert === 'string' && i === delta.length - 1 && currPos.right === null && op.insert.slice(-1) === '\\n') ? op.insert.slice(0, -1) : op.insert;\n            if (typeof ins !== 'string' || ins.length > 0) {\n              insertText(transaction, this, currPos, ins, op.attributes || {});\n            }\n          } else if (op.retain !== undefined) {\n            formatText(transaction, this, currPos, op.retain, op.attributes || {});\n          } else if (op.delete !== undefined) {\n            deleteText(transaction, currPos, op.delete);\n          }\n        }\n      });\n    } else {\n      /** @type {Array<function>} */ (this._pending).push(() => this.applyDelta(delta));\n    }\n  }\n\n  /**\n   * Returns the Delta representation of this YText type.\n   *\n   * @param {Snapshot} [snapshot]\n   * @param {Snapshot} [prevSnapshot]\n   * @param {function('removed' | 'added', ID):any} [computeYChange]\n   * @return {any} The Delta representation of this type.\n   *\n   * @public\n   */\n  toDelta (snapshot, prevSnapshot, computeYChange) {\n    /**\n     * @type{Array<any>}\n     */\n    const ops = [];\n    const currentAttributes = new Map();\n    const doc = /** @type {Doc} */ (this.doc);\n    let str = '';\n    let n = this._start;\n    function packStr () {\n      if (str.length > 0) {\n        // pack str with attributes to ops\n        /**\n         * @type {Object<string,any>}\n         */\n        const attributes = {};\n        let addAttributes = false;\n        currentAttributes.forEach((value, key) => {\n          addAttributes = true;\n          attributes[key] = value;\n        });\n        /**\n         * @type {Object<string,any>}\n         */\n        const op = { insert: str };\n        if (addAttributes) {\n          op.attributes = attributes;\n        }\n        ops.push(op);\n        str = '';\n      }\n    }\n    const computeDelta = () => {\n      while (n !== null) {\n        if (isVisible(n, snapshot) || (prevSnapshot !== undefined && isVisible(n, prevSnapshot))) {\n          switch (n.content.constructor) {\n            case ContentString: {\n              const cur = currentAttributes.get('ychange');\n              if (snapshot !== undefined && !isVisible(n, snapshot)) {\n                if (cur === undefined || cur.user !== n.id.client || cur.type !== 'removed') {\n                  packStr();\n                  currentAttributes.set('ychange', computeYChange ? computeYChange('removed', n.id) : { type: 'removed' });\n                }\n              } else if (prevSnapshot !== undefined && !isVisible(n, prevSnapshot)) {\n                if (cur === undefined || cur.user !== n.id.client || cur.type !== 'added') {\n                  packStr();\n                  currentAttributes.set('ychange', computeYChange ? computeYChange('added', n.id) : { type: 'added' });\n                }\n              } else if (cur !== undefined) {\n                packStr();\n                currentAttributes.delete('ychange');\n              }\n              str += /** @type {ContentString} */ (n.content).str;\n              break\n            }\n            case ContentType:\n            case ContentEmbed: {\n              packStr();\n              /**\n               * @type {Object<string,any>}\n               */\n              const op = {\n                insert: n.content.getContent()[0]\n              };\n              if (currentAttributes.size > 0) {\n                const attrs = /** @type {Object<string,any>} */ ({});\n                op.attributes = attrs;\n                currentAttributes.forEach((value, key) => {\n                  attrs[key] = value;\n                });\n              }\n              ops.push(op);\n              break\n            }\n            case ContentFormat:\n              if (isVisible(n, snapshot)) {\n                packStr();\n                updateCurrentAttributes(currentAttributes, /** @type {ContentFormat} */ (n.content));\n              }\n              break\n          }\n        }\n        n = n.right;\n      }\n      packStr();\n    };\n    if (snapshot || prevSnapshot) {\n      // snapshots are merged again after the transaction, so we need to keep the\n      // transaction alive until we are done\n      transact(doc, transaction => {\n        if (snapshot) {\n          splitSnapshotAffectedStructs(transaction, snapshot);\n        }\n        if (prevSnapshot) {\n          splitSnapshotAffectedStructs(transaction, prevSnapshot);\n        }\n        computeDelta();\n      }, 'cleanup');\n    } else {\n      computeDelta();\n    }\n    return ops\n  }\n\n  /**\n   * Insert text at a given index.\n   *\n   * @param {number} index The index at which to start inserting.\n   * @param {String} text The text to insert at the specified position.\n   * @param {TextAttributes} [attributes] Optionally define some formatting\n   *                                    information to apply on the inserted\n   *                                    Text.\n   * @public\n   */\n  insert (index, text, attributes) {\n    if (text.length <= 0) {\n      return\n    }\n    const y = this.doc;\n    if (y !== null) {\n      transact(y, transaction => {\n        const pos = findPosition(transaction, this, index);\n        if (!attributes) {\n          attributes = {};\n          // @ts-ignore\n          pos.currentAttributes.forEach((v, k) => { attributes[k] = v; });\n        }\n        insertText(transaction, this, pos, text, attributes);\n      });\n    } else {\n      /** @type {Array<function>} */ (this._pending).push(() => this.insert(index, text, attributes));\n    }\n  }\n\n  /**\n   * Inserts an embed at a index.\n   *\n   * @param {number} index The index to insert the embed at.\n   * @param {Object | AbstractType<any>} embed The Object that represents the embed.\n   * @param {TextAttributes} attributes Attribute information to apply on the\n   *                                    embed\n   *\n   * @public\n   */\n  insertEmbed (index, embed, attributes = {}) {\n    const y = this.doc;\n    if (y !== null) {\n      transact(y, transaction => {\n        const pos = findPosition(transaction, this, index);\n        insertText(transaction, this, pos, embed, attributes);\n      });\n    } else {\n      /** @type {Array<function>} */ (this._pending).push(() => this.insertEmbed(index, embed, attributes));\n    }\n  }\n\n  /**\n   * Deletes text starting from an index.\n   *\n   * @param {number} index Index at which to start deleting.\n   * @param {number} length The number of characters to remove. Defaults to 1.\n   *\n   * @public\n   */\n  delete (index, length) {\n    if (length === 0) {\n      return\n    }\n    const y = this.doc;\n    if (y !== null) {\n      transact(y, transaction => {\n        deleteText(transaction, findPosition(transaction, this, index), length);\n      });\n    } else {\n      /** @type {Array<function>} */ (this._pending).push(() => this.delete(index, length));\n    }\n  }\n\n  /**\n   * Assigns properties to a range of text.\n   *\n   * @param {number} index The position where to start formatting.\n   * @param {number} length The amount of characters to assign properties to.\n   * @param {TextAttributes} attributes Attribute information to apply on the\n   *                                    text.\n   *\n   * @public\n   */\n  format (index, length, attributes) {\n    if (length === 0) {\n      return\n    }\n    const y = this.doc;\n    if (y !== null) {\n      transact(y, transaction => {\n        const pos = findPosition(transaction, this, index);\n        if (pos.right === null) {\n          return\n        }\n        formatText(transaction, this, pos, length, attributes);\n      });\n    } else {\n      /** @type {Array<function>} */ (this._pending).push(() => this.format(index, length, attributes));\n    }\n  }\n\n  /**\n   * Removes an attribute.\n   *\n   * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.\n   *\n   * @param {String} attributeName The attribute name that is to be removed.\n   *\n   * @public\n   */\n  removeAttribute (attributeName) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        typeMapDelete(transaction, this, attributeName);\n      });\n    } else {\n      /** @type {Array<function>} */ (this._pending).push(() => this.removeAttribute(attributeName));\n    }\n  }\n\n  /**\n   * Sets or updates an attribute.\n   *\n   * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.\n   *\n   * @param {String} attributeName The attribute name that is to be set.\n   * @param {any} attributeValue The attribute value that is to be set.\n   *\n   * @public\n   */\n  setAttribute (attributeName, attributeValue) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        typeMapSet(transaction, this, attributeName, attributeValue);\n      });\n    } else {\n      /** @type {Array<function>} */ (this._pending).push(() => this.setAttribute(attributeName, attributeValue));\n    }\n  }\n\n  /**\n   * Returns an attribute value that belongs to the attribute name.\n   *\n   * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.\n   *\n   * @param {String} attributeName The attribute name that identifies the\n   *                               queried value.\n   * @return {any} The queried attribute value.\n   *\n   * @public\n   */\n  getAttribute (attributeName) {\n    return /** @type {any} */ (typeMapGet(this, attributeName))\n  }\n\n  /**\n   * Returns all attribute name/value pairs in a JSON Object.\n   *\n   * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.\n   *\n   * @return {Object<string, any>} A JSON Object that describes the attributes.\n   *\n   * @public\n   */\n  getAttributes () {\n    return typeMapGetAll(this)\n  }\n\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   */\n  _write (encoder) {\n    encoder.writeTypeRef(YTextRefID);\n  }\n}\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2} _decoder\n * @return {YText}\n *\n * @private\n * @function\n */\nconst readYText = _decoder => new YText();\n\n/**\n * @module YXml\n */\n\n/**\n * Define the elements to which a set of CSS queries apply.\n * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors|CSS_Selectors}\n *\n * @example\n *   query = '.classSelector'\n *   query = 'nodeSelector'\n *   query = '#idSelector'\n *\n * @typedef {string} CSS_Selector\n */\n\n/**\n * Dom filter function.\n *\n * @callback domFilter\n * @param {string} nodeName The nodeName of the element\n * @param {Map} attributes The map of attributes.\n * @return {boolean} Whether to include the Dom node in the YXmlElement.\n */\n\n/**\n * Represents a subset of the nodes of a YXmlElement / YXmlFragment and a\n * position within them.\n *\n * Can be created with {@link YXmlFragment#createTreeWalker}\n *\n * @public\n * @implements {Iterable<YXmlElement|YXmlText|YXmlElement|YXmlHook>}\n */\nclass YXmlTreeWalker {\n  /**\n   * @param {YXmlFragment | YXmlElement} root\n   * @param {function(AbstractType<any>):boolean} [f]\n   */\n  constructor (root, f = () => true) {\n    this._filter = f;\n    this._root = root;\n    /**\n     * @type {Item}\n     */\n    this._currentNode = /** @type {Item} */ (root._start);\n    this._firstCall = true;\n  }\n\n  [Symbol.iterator] () {\n    return this\n  }\n\n  /**\n   * Get the next node.\n   *\n   * @return {IteratorResult<YXmlElement|YXmlText|YXmlHook>} The next node.\n   *\n   * @public\n   */\n  next () {\n    /**\n     * @type {Item|null}\n     */\n    let n = this._currentNode;\n    let type = n && n.content && /** @type {any} */ (n.content).type;\n    if (n !== null && (!this._firstCall || n.deleted || !this._filter(type))) { // if first call, we check if we can use the first item\n      do {\n        type = /** @type {any} */ (n.content).type;\n        if (!n.deleted && (type.constructor === YXmlElement || type.constructor === YXmlFragment) && type._start !== null) {\n          // walk down in the tree\n          n = type._start;\n        } else {\n          // walk right or up in the tree\n          while (n !== null) {\n            if (n.right !== null) {\n              n = n.right;\n              break\n            } else if (n.parent === this._root) {\n              n = null;\n            } else {\n              n = /** @type {AbstractType<any>} */ (n.parent)._item;\n            }\n          }\n        }\n      } while (n !== null && (n.deleted || !this._filter(/** @type {ContentType} */ (n.content).type)))\n    }\n    this._firstCall = false;\n    if (n === null) {\n      // @ts-ignore\n      return { value: undefined, done: true }\n    }\n    this._currentNode = n;\n    return { value: /** @type {any} */ (n.content).type, done: false }\n  }\n}\n\n/**\n * Represents a list of {@link YXmlElement}.and {@link YXmlText} types.\n * A YxmlFragment is similar to a {@link YXmlElement}, but it does not have a\n * nodeName and it does not have attributes. Though it can be bound to a DOM\n * element - in this case the attributes and the nodeName are not shared.\n *\n * @public\n * @extends AbstractType<YXmlEvent>\n */\nclass YXmlFragment extends AbstractType {\n  constructor () {\n    super();\n    /**\n     * @type {Array<any>|null}\n     */\n    this._prelimContent = [];\n  }\n\n  /**\n   * @type {YXmlElement|YXmlText|null}\n   */\n  get firstChild () {\n    const first = this._first;\n    return first ? first.content.getContent()[0] : null\n  }\n\n  /**\n   * Integrate this type into the Yjs instance.\n   *\n   * * Save this struct in the os\n   * * This type is sent to other client\n   * * Observer functions are fired\n   *\n   * @param {Doc} y The Yjs instance\n   * @param {Item} item\n   */\n  _integrate (y, item) {\n    super._integrate(y, item);\n    this.insert(0, /** @type {Array<any>} */ (this._prelimContent));\n    this._prelimContent = null;\n  }\n\n  _copy () {\n    return new YXmlFragment()\n  }\n\n  /**\n   * @return {YXmlFragment}\n   */\n  clone () {\n    const el = new YXmlFragment();\n    // @ts-ignore\n    el.insert(0, this.toArray().map(item => item instanceof AbstractType ? item.clone() : item));\n    return el\n  }\n\n  get length () {\n    return this._prelimContent === null ? this._length : this._prelimContent.length\n  }\n\n  /**\n   * Create a subtree of childNodes.\n   *\n   * @example\n   * const walker = elem.createTreeWalker(dom => dom.nodeName === 'div')\n   * for (let node in walker) {\n   *   // `node` is a div node\n   *   nop(node)\n   * }\n   *\n   * @param {function(AbstractType<any>):boolean} filter Function that is called on each child element and\n   *                          returns a Boolean indicating whether the child\n   *                          is to be included in the subtree.\n   * @return {YXmlTreeWalker} A subtree and a position within it.\n   *\n   * @public\n   */\n  createTreeWalker (filter) {\n    return new YXmlTreeWalker(this, filter)\n  }\n\n  /**\n   * Returns the first YXmlElement that matches the query.\n   * Similar to DOM's {@link querySelector}.\n   *\n   * Query support:\n   *   - tagname\n   * TODO:\n   *   - id\n   *   - attribute\n   *\n   * @param {CSS_Selector} query The query on the children.\n   * @return {YXmlElement|YXmlText|YXmlHook|null} The first element that matches the query or null.\n   *\n   * @public\n   */\n  querySelector (query) {\n    query = query.toUpperCase();\n    // @ts-ignore\n    const iterator = new YXmlTreeWalker(this, element => element.nodeName && element.nodeName.toUpperCase() === query);\n    const next = iterator.next();\n    if (next.done) {\n      return null\n    } else {\n      return next.value\n    }\n  }\n\n  /**\n   * Returns all YXmlElements that match the query.\n   * Similar to Dom's {@link querySelectorAll}.\n   *\n   * @todo Does not yet support all queries. Currently only query by tagName.\n   *\n   * @param {CSS_Selector} query The query on the children\n   * @return {Array<YXmlElement|YXmlText|YXmlHook|null>} The elements that match this query.\n   *\n   * @public\n   */\n  querySelectorAll (query) {\n    query = query.toUpperCase();\n    // @ts-ignore\n    return array.from(new YXmlTreeWalker(this, element => element.nodeName && element.nodeName.toUpperCase() === query))\n  }\n\n  /**\n   * Creates YXmlEvent and calls observers.\n   *\n   * @param {Transaction} transaction\n   * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.\n   */\n  _callObserver (transaction, parentSubs) {\n    callTypeObservers(this, transaction, new YXmlEvent(this, parentSubs, transaction));\n  }\n\n  /**\n   * Get the string representation of all the children of this YXmlFragment.\n   *\n   * @return {string} The string representation of all children.\n   */\n  toString () {\n    return typeListMap(this, xml => xml.toString()).join('')\n  }\n\n  /**\n   * @return {string}\n   */\n  toJSON () {\n    return this.toString()\n  }\n\n  /**\n   * Creates a Dom Element that mirrors this YXmlElement.\n   *\n   * @param {Document} [_document=document] The document object (you must define\n   *                                        this when calling this method in\n   *                                        nodejs)\n   * @param {Object<string, any>} [hooks={}] Optional property to customize how hooks\n   *                                             are presented in the DOM\n   * @param {any} [binding] You should not set this property. This is\n   *                               used if DomBinding wants to create a\n   *                               association to the created DOM type.\n   * @return {Node} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}\n   *\n   * @public\n   */\n  toDOM (_document = document, hooks = {}, binding) {\n    const fragment = _document.createDocumentFragment();\n    if (binding !== undefined) {\n      binding._createAssociation(fragment, this);\n    }\n    typeListForEach(this, xmlType => {\n      fragment.insertBefore(xmlType.toDOM(_document, hooks, binding), null);\n    });\n    return fragment\n  }\n\n  /**\n   * Inserts new content at an index.\n   *\n   * @example\n   *  // Insert character 'a' at position 0\n   *  xml.insert(0, [new Y.XmlText('text')])\n   *\n   * @param {number} index The index to insert content at\n   * @param {Array<YXmlElement|YXmlText>} content The array of content\n   */\n  insert (index, content) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        typeListInsertGenerics(transaction, this, index, content);\n      });\n    } else {\n      // @ts-ignore _prelimContent is defined because this is not yet integrated\n      this._prelimContent.splice(index, 0, ...content);\n    }\n  }\n\n  /**\n   * Inserts new content at an index.\n   *\n   * @example\n   *  // Insert character 'a' at position 0\n   *  xml.insert(0, [new Y.XmlText('text')])\n   *\n   * @param {null|Item|YXmlElement|YXmlText} ref The index to insert content at\n   * @param {Array<YXmlElement|YXmlText>} content The array of content\n   */\n  insertAfter (ref, content) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        const refItem = (ref && ref instanceof AbstractType) ? ref._item : ref;\n        typeListInsertGenericsAfter(transaction, this, refItem, content);\n      });\n    } else {\n      const pc = /** @type {Array<any>} */ (this._prelimContent);\n      const index = ref === null ? 0 : pc.findIndex(el => el === ref) + 1;\n      if (index === 0 && ref !== null) {\n        throw error.create('Reference item not found')\n      }\n      pc.splice(index, 0, ...content);\n    }\n  }\n\n  /**\n   * Deletes elements starting from an index.\n   *\n   * @param {number} index Index at which to start deleting elements\n   * @param {number} [length=1] The number of elements to remove. Defaults to 1.\n   */\n  delete (index, length = 1) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        typeListDelete(transaction, this, index, length);\n      });\n    } else {\n      // @ts-ignore _prelimContent is defined because this is not yet integrated\n      this._prelimContent.splice(index, length);\n    }\n  }\n\n  /**\n   * Transforms this YArray to a JavaScript Array.\n   *\n   * @return {Array<YXmlElement|YXmlText|YXmlHook>}\n   */\n  toArray () {\n    return typeListToArray(this)\n  }\n\n  /**\n   * Appends content to this YArray.\n   *\n   * @param {Array<YXmlElement|YXmlText>} content Array of content to append.\n   */\n  push (content) {\n    this.insert(this.length, content);\n  }\n\n  /**\n   * Preppends content to this YArray.\n   *\n   * @param {Array<YXmlElement|YXmlText>} content Array of content to preppend.\n   */\n  unshift (content) {\n    this.insert(0, content);\n  }\n\n  /**\n   * Returns the i-th element from a YArray.\n   *\n   * @param {number} index The index of the element to return from the YArray\n   * @return {YXmlElement|YXmlText}\n   */\n  get (index) {\n    return typeListGet(this, index)\n  }\n\n  /**\n   * Transforms this YArray to a JavaScript Array.\n   *\n   * @param {number} [start]\n   * @param {number} [end]\n   * @return {Array<YXmlElement|YXmlText>}\n   */\n  slice (start = 0, end = this.length) {\n    return typeListSlice(this, start, end)\n  }\n\n  /**\n   * Executes a provided function on once on overy child element.\n   *\n   * @param {function(YXmlElement|YXmlText,number, typeof self):void} f A function to execute on every element of this YArray.\n   */\n  forEach (f) {\n    typeListForEach(this, f);\n  }\n\n  /**\n   * Transform the properties of this type to binary and write it to an\n   * BinaryEncoder.\n   *\n   * This is called when this Item is sent to a remote peer.\n   *\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder The encoder to write data to.\n   */\n  _write (encoder) {\n    encoder.writeTypeRef(YXmlFragmentRefID);\n  }\n}\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2} _decoder\n * @return {YXmlFragment}\n *\n * @private\n * @function\n */\nconst readYXmlFragment = _decoder => new YXmlFragment();\n\n/**\n * @typedef {Object|number|null|Array<any>|string|Uint8Array|AbstractType<any>} ValueTypes\n */\n\n/**\n * An YXmlElement imitates the behavior of a\n * {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}.\n *\n * * An YXmlElement has attributes (key value pairs)\n * * An YXmlElement has childElements that must inherit from YXmlElement\n *\n * @template {{ [key: string]: ValueTypes }} [KV={ [key: string]: string }]\n */\nclass YXmlElement extends YXmlFragment {\n  constructor (nodeName = 'UNDEFINED') {\n    super();\n    this.nodeName = nodeName;\n    /**\n     * @type {Map<string, any>|null}\n     */\n    this._prelimAttrs = new Map();\n  }\n\n  /**\n   * @type {YXmlElement|YXmlText|null}\n   */\n  get nextSibling () {\n    const n = this._item ? this._item.next : null;\n    return n ? /** @type {YXmlElement|YXmlText} */ (/** @type {ContentType} */ (n.content).type) : null\n  }\n\n  /**\n   * @type {YXmlElement|YXmlText|null}\n   */\n  get prevSibling () {\n    const n = this._item ? this._item.prev : null;\n    return n ? /** @type {YXmlElement|YXmlText} */ (/** @type {ContentType} */ (n.content).type) : null\n  }\n\n  /**\n   * Integrate this type into the Yjs instance.\n   *\n   * * Save this struct in the os\n   * * This type is sent to other client\n   * * Observer functions are fired\n   *\n   * @param {Doc} y The Yjs instance\n   * @param {Item} item\n   */\n  _integrate (y, item) {\n    super._integrate(y, item)\n    ;(/** @type {Map<string, any>} */ (this._prelimAttrs)).forEach((value, key) => {\n      this.setAttribute(key, value);\n    });\n    this._prelimAttrs = null;\n  }\n\n  /**\n   * Creates an Item with the same effect as this Item (without position effect)\n   *\n   * @return {YXmlElement}\n   */\n  _copy () {\n    return new YXmlElement(this.nodeName)\n  }\n\n  /**\n   * @return {YXmlElement<KV>}\n   */\n  clone () {\n    /**\n     * @type {YXmlElement<KV>}\n     */\n    const el = new YXmlElement(this.nodeName);\n    const attrs = this.getAttributes();\n    object.forEach(attrs, (value, key) => {\n      if (typeof value === 'string') {\n        el.setAttribute(key, value);\n      }\n    });\n    // @ts-ignore\n    el.insert(0, this.toArray().map(item => item instanceof AbstractType ? item.clone() : item));\n    return el\n  }\n\n  /**\n   * Returns the XML serialization of this YXmlElement.\n   * The attributes are ordered by attribute-name, so you can easily use this\n   * method to compare YXmlElements\n   *\n   * @return {string} The string representation of this type.\n   *\n   * @public\n   */\n  toString () {\n    const attrs = this.getAttributes();\n    const stringBuilder = [];\n    const keys = [];\n    for (const key in attrs) {\n      keys.push(key);\n    }\n    keys.sort();\n    const keysLen = keys.length;\n    for (let i = 0; i < keysLen; i++) {\n      const key = keys[i];\n      stringBuilder.push(key + '=\"' + attrs[key] + '\"');\n    }\n    const nodeName = this.nodeName.toLocaleLowerCase();\n    const attrsString = stringBuilder.length > 0 ? ' ' + stringBuilder.join(' ') : '';\n    return `<${nodeName}${attrsString}>${super.toString()}</${nodeName}>`\n  }\n\n  /**\n   * Removes an attribute from this YXmlElement.\n   *\n   * @param {string} attributeName The attribute name that is to be removed.\n   *\n   * @public\n   */\n  removeAttribute (attributeName) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        typeMapDelete(transaction, this, attributeName);\n      });\n    } else {\n      /** @type {Map<string,any>} */ (this._prelimAttrs).delete(attributeName);\n    }\n  }\n\n  /**\n   * Sets or updates an attribute.\n   *\n   * @template {keyof KV & string} KEY\n   *\n   * @param {KEY} attributeName The attribute name that is to be set.\n   * @param {KV[KEY]} attributeValue The attribute value that is to be set.\n   *\n   * @public\n   */\n  setAttribute (attributeName, attributeValue) {\n    if (this.doc !== null) {\n      transact(this.doc, transaction => {\n        typeMapSet(transaction, this, attributeName, attributeValue);\n      });\n    } else {\n      /** @type {Map<string, any>} */ (this._prelimAttrs).set(attributeName, attributeValue);\n    }\n  }\n\n  /**\n   * Returns an attribute value that belongs to the attribute name.\n   *\n   * @template {keyof KV & string} KEY\n   *\n   * @param {KEY} attributeName The attribute name that identifies the\n   *                               queried value.\n   * @return {KV[KEY]|undefined} The queried attribute value.\n   *\n   * @public\n   */\n  getAttribute (attributeName) {\n    return /** @type {any} */ (typeMapGet(this, attributeName))\n  }\n\n  /**\n   * Returns whether an attribute exists\n   *\n   * @param {string} attributeName The attribute name to check for existence.\n   * @return {boolean} whether the attribute exists.\n   *\n   * @public\n   */\n  hasAttribute (attributeName) {\n    return /** @type {any} */ (typeMapHas(this, attributeName))\n  }\n\n  /**\n   * Returns all attribute name/value pairs in a JSON Object.\n   *\n   * @return {{ [Key in Extract<keyof KV,string>]?: KV[Key]}} A JSON Object that describes the attributes.\n   *\n   * @public\n   */\n  getAttributes () {\n    return /** @type {any} */ (typeMapGetAll(this))\n  }\n\n  /**\n   * Creates a Dom Element that mirrors this YXmlElement.\n   *\n   * @param {Document} [_document=document] The document object (you must define\n   *                                        this when calling this method in\n   *                                        nodejs)\n   * @param {Object<string, any>} [hooks={}] Optional property to customize how hooks\n   *                                             are presented in the DOM\n   * @param {any} [binding] You should not set this property. This is\n   *                               used if DomBinding wants to create a\n   *                               association to the created DOM type.\n   * @return {Node} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}\n   *\n   * @public\n   */\n  toDOM (_document = document, hooks = {}, binding) {\n    const dom = _document.createElement(this.nodeName);\n    const attrs = this.getAttributes();\n    for (const key in attrs) {\n      const value = attrs[key];\n      if (typeof value === 'string') {\n        dom.setAttribute(key, value);\n      }\n    }\n    typeListForEach(this, yxml => {\n      dom.appendChild(yxml.toDOM(_document, hooks, binding));\n    });\n    if (binding !== undefined) {\n      binding._createAssociation(dom, this);\n    }\n    return dom\n  }\n\n  /**\n   * Transform the properties of this type to binary and write it to an\n   * BinaryEncoder.\n   *\n   * This is called when this Item is sent to a remote peer.\n   *\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder The encoder to write data to.\n   */\n  _write (encoder) {\n    encoder.writeTypeRef(YXmlElementRefID);\n    encoder.writeKey(this.nodeName);\n  }\n}\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n * @return {YXmlElement}\n *\n * @function\n */\nconst readYXmlElement = decoder => new YXmlElement(decoder.readKey());\n\n/**\n * @extends YEvent<YXmlElement|YXmlText|YXmlFragment>\n * An Event that describes changes on a YXml Element or Yxml Fragment\n */\nclass YXmlEvent extends YEvent {\n  /**\n   * @param {YXmlElement|YXmlText|YXmlFragment} target The target on which the event is created.\n   * @param {Set<string|null>} subs The set of changed attributes. `null` is included if the\n   *                   child list changed.\n   * @param {Transaction} transaction The transaction instance with wich the\n   *                                  change was created.\n   */\n  constructor (target, subs, transaction) {\n    super(target, transaction);\n    /**\n     * Whether the children changed.\n     * @type {Boolean}\n     * @private\n     */\n    this.childListChanged = false;\n    /**\n     * Set of all changed attributes.\n     * @type {Set<string>}\n     */\n    this.attributesChanged = new Set();\n    subs.forEach((sub) => {\n      if (sub === null) {\n        this.childListChanged = true;\n      } else {\n        this.attributesChanged.add(sub);\n      }\n    });\n  }\n}\n\n/**\n * You can manage binding to a custom type with YXmlHook.\n *\n * @extends {YMap<any>}\n */\nclass YXmlHook extends YMap {\n  /**\n   * @param {string} hookName nodeName of the Dom Node.\n   */\n  constructor (hookName) {\n    super();\n    /**\n     * @type {string}\n     */\n    this.hookName = hookName;\n  }\n\n  /**\n   * Creates an Item with the same effect as this Item (without position effect)\n   */\n  _copy () {\n    return new YXmlHook(this.hookName)\n  }\n\n  /**\n   * @return {YXmlHook}\n   */\n  clone () {\n    const el = new YXmlHook(this.hookName);\n    this.forEach((value, key) => {\n      el.set(key, value);\n    });\n    return el\n  }\n\n  /**\n   * Creates a Dom Element that mirrors this YXmlElement.\n   *\n   * @param {Document} [_document=document] The document object (you must define\n   *                                        this when calling this method in\n   *                                        nodejs)\n   * @param {Object.<string, any>} [hooks] Optional property to customize how hooks\n   *                                             are presented in the DOM\n   * @param {any} [binding] You should not set this property. This is\n   *                               used if DomBinding wants to create a\n   *                               association to the created DOM type\n   * @return {Element} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}\n   *\n   * @public\n   */\n  toDOM (_document = document, hooks = {}, binding) {\n    const hook = hooks[this.hookName];\n    let dom;\n    if (hook !== undefined) {\n      dom = hook.createDom(this);\n    } else {\n      dom = document.createElement(this.hookName);\n    }\n    dom.setAttribute('data-yjs-hook', this.hookName);\n    if (binding !== undefined) {\n      binding._createAssociation(dom, this);\n    }\n    return dom\n  }\n\n  /**\n   * Transform the properties of this type to binary and write it to an\n   * BinaryEncoder.\n   *\n   * This is called when this Item is sent to a remote peer.\n   *\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder The encoder to write data to.\n   */\n  _write (encoder) {\n    encoder.writeTypeRef(YXmlHookRefID);\n    encoder.writeKey(this.hookName);\n  }\n}\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n * @return {YXmlHook}\n *\n * @private\n * @function\n */\nconst readYXmlHook = decoder =>\n  new YXmlHook(decoder.readKey());\n\n/**\n * Represents text in a Dom Element. In the future this type will also handle\n * simple formatting information like bold and italic.\n */\nclass YXmlText extends YText {\n  /**\n   * @type {YXmlElement|YXmlText|null}\n   */\n  get nextSibling () {\n    const n = this._item ? this._item.next : null;\n    return n ? /** @type {YXmlElement|YXmlText} */ (/** @type {ContentType} */ (n.content).type) : null\n  }\n\n  /**\n   * @type {YXmlElement|YXmlText|null}\n   */\n  get prevSibling () {\n    const n = this._item ? this._item.prev : null;\n    return n ? /** @type {YXmlElement|YXmlText} */ (/** @type {ContentType} */ (n.content).type) : null\n  }\n\n  _copy () {\n    return new YXmlText()\n  }\n\n  /**\n   * @return {YXmlText}\n   */\n  clone () {\n    const text = new YXmlText();\n    text.applyDelta(this.toDelta());\n    return text\n  }\n\n  /**\n   * Creates a Dom Element that mirrors this YXmlText.\n   *\n   * @param {Document} [_document=document] The document object (you must define\n   *                                        this when calling this method in\n   *                                        nodejs)\n   * @param {Object<string, any>} [hooks] Optional property to customize how hooks\n   *                                             are presented in the DOM\n   * @param {any} [binding] You should not set this property. This is\n   *                               used if DomBinding wants to create a\n   *                               association to the created DOM type.\n   * @return {Text} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}\n   *\n   * @public\n   */\n  toDOM (_document = document, hooks, binding) {\n    const dom = _document.createTextNode(this.toString());\n    if (binding !== undefined) {\n      binding._createAssociation(dom, this);\n    }\n    return dom\n  }\n\n  toString () {\n    // @ts-ignore\n    return this.toDelta().map(delta => {\n      const nestedNodes = [];\n      for (const nodeName in delta.attributes) {\n        const attrs = [];\n        for (const key in delta.attributes[nodeName]) {\n          attrs.push({ key, value: delta.attributes[nodeName][key] });\n        }\n        // sort attributes to get a unique order\n        attrs.sort((a, b) => a.key < b.key ? -1 : 1);\n        nestedNodes.push({ nodeName, attrs });\n      }\n      // sort node order to get a unique order\n      nestedNodes.sort((a, b) => a.nodeName < b.nodeName ? -1 : 1);\n      // now convert to dom string\n      let str = '';\n      for (let i = 0; i < nestedNodes.length; i++) {\n        const node = nestedNodes[i];\n        str += `<${node.nodeName}`;\n        for (let j = 0; j < node.attrs.length; j++) {\n          const attr = node.attrs[j];\n          str += ` ${attr.key}=\"${attr.value}\"`;\n        }\n        str += '>';\n      }\n      str += delta.insert;\n      for (let i = nestedNodes.length - 1; i >= 0; i--) {\n        str += `</${nestedNodes[i].nodeName}>`;\n      }\n      return str\n    }).join('')\n  }\n\n  /**\n   * @return {string}\n   */\n  toJSON () {\n    return this.toString()\n  }\n\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   */\n  _write (encoder) {\n    encoder.writeTypeRef(YXmlTextRefID);\n  }\n}\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n * @return {YXmlText}\n *\n * @private\n * @function\n */\nconst readYXmlText = decoder => new YXmlText();\n\nclass AbstractStruct {\n  /**\n   * @param {ID} id\n   * @param {number} length\n   */\n  constructor (id, length) {\n    this.id = id;\n    this.length = length;\n  }\n\n  /**\n   * @type {boolean}\n   */\n  get deleted () {\n    throw error.methodUnimplemented()\n  }\n\n  /**\n   * Merge this struct with the item to the right.\n   * This method is already assuming that `this.id.clock + this.length === this.id.clock`.\n   * Also this method does *not* remove right from StructStore!\n   * @param {AbstractStruct} right\n   * @return {boolean} wether this merged with right\n   */\n  mergeWith (right) {\n    return false\n  }\n\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder The encoder to write data to.\n   * @param {number} offset\n   * @param {number} encodingRef\n   */\n  write (encoder, offset, encodingRef) {\n    throw error.methodUnimplemented()\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {number} offset\n   */\n  integrate (transaction, offset) {\n    throw error.methodUnimplemented()\n  }\n}\n\nconst structGCRefNumber = 0;\n\n/**\n * @private\n */\nclass GC extends AbstractStruct {\n  get deleted () {\n    return true\n  }\n\n  delete () {}\n\n  /**\n   * @param {GC} right\n   * @return {boolean}\n   */\n  mergeWith (right) {\n    if (this.constructor !== right.constructor) {\n      return false\n    }\n    this.length += right.length;\n    return true\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {number} offset\n   */\n  integrate (transaction, offset) {\n    if (offset > 0) {\n      this.id.clock += offset;\n      this.length -= offset;\n    }\n    addStruct(transaction.doc.store, this);\n  }\n\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   * @param {number} offset\n   */\n  write (encoder, offset) {\n    encoder.writeInfo(structGCRefNumber);\n    encoder.writeLen(this.length - offset);\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {StructStore} store\n   * @return {null | number}\n   */\n  getMissing (transaction, store) {\n    return null\n  }\n}\n\nclass ContentBinary {\n  /**\n   * @param {Uint8Array} content\n   */\n  constructor (content) {\n    this.content = content;\n  }\n\n  /**\n   * @return {number}\n   */\n  getLength () {\n    return 1\n  }\n\n  /**\n   * @return {Array<any>}\n   */\n  getContent () {\n    return [this.content]\n  }\n\n  /**\n   * @return {boolean}\n   */\n  isCountable () {\n    return true\n  }\n\n  /**\n   * @return {ContentBinary}\n   */\n  copy () {\n    return new ContentBinary(this.content)\n  }\n\n  /**\n   * @param {number} offset\n   * @return {ContentBinary}\n   */\n  splice (offset) {\n    throw error.methodUnimplemented()\n  }\n\n  /**\n   * @param {ContentBinary} right\n   * @return {boolean}\n   */\n  mergeWith (right) {\n    return false\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {Item} item\n   */\n  integrate (transaction, item) {}\n  /**\n   * @param {Transaction} transaction\n   */\n  delete (transaction) {}\n  /**\n   * @param {StructStore} store\n   */\n  gc (store) {}\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   * @param {number} offset\n   */\n  write (encoder, offset) {\n    encoder.writeBuf(this.content);\n  }\n\n  /**\n   * @return {number}\n   */\n  getRef () {\n    return 3\n  }\n}\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2 } decoder\n * @return {ContentBinary}\n */\nconst readContentBinary = decoder => new ContentBinary(decoder.readBuf());\n\nclass ContentDeleted {\n  /**\n   * @param {number} len\n   */\n  constructor (len) {\n    this.len = len;\n  }\n\n  /**\n   * @return {number}\n   */\n  getLength () {\n    return this.len\n  }\n\n  /**\n   * @return {Array<any>}\n   */\n  getContent () {\n    return []\n  }\n\n  /**\n   * @return {boolean}\n   */\n  isCountable () {\n    return false\n  }\n\n  /**\n   * @return {ContentDeleted}\n   */\n  copy () {\n    return new ContentDeleted(this.len)\n  }\n\n  /**\n   * @param {number} offset\n   * @return {ContentDeleted}\n   */\n  splice (offset) {\n    const right = new ContentDeleted(this.len - offset);\n    this.len = offset;\n    return right\n  }\n\n  /**\n   * @param {ContentDeleted} right\n   * @return {boolean}\n   */\n  mergeWith (right) {\n    this.len += right.len;\n    return true\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {Item} item\n   */\n  integrate (transaction, item) {\n    addToDeleteSet(transaction.deleteSet, item.id.client, item.id.clock, this.len);\n    item.markDeleted();\n  }\n\n  /**\n   * @param {Transaction} transaction\n   */\n  delete (transaction) {}\n  /**\n   * @param {StructStore} store\n   */\n  gc (store) {}\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   * @param {number} offset\n   */\n  write (encoder, offset) {\n    encoder.writeLen(this.len - offset);\n  }\n\n  /**\n   * @return {number}\n   */\n  getRef () {\n    return 1\n  }\n}\n\n/**\n * @private\n *\n * @param {UpdateDecoderV1 | UpdateDecoderV2 } decoder\n * @return {ContentDeleted}\n */\nconst readContentDeleted = decoder => new ContentDeleted(decoder.readLen());\n\n/**\n * @param {string} guid\n * @param {Object<string, any>} opts\n */\nconst createDocFromOpts = (guid, opts) => new Doc({ guid, ...opts, shouldLoad: opts.shouldLoad || opts.autoLoad || false });\n\n/**\n * @private\n */\nclass ContentDoc {\n  /**\n   * @param {Doc} doc\n   */\n  constructor (doc) {\n    if (doc._item) {\n      console.error('This document was already integrated as a sub-document. You should create a second instance instead with the same guid.');\n    }\n    /**\n     * @type {Doc}\n     */\n    this.doc = doc;\n    /**\n     * @type {any}\n     */\n    const opts = {};\n    this.opts = opts;\n    if (!doc.gc) {\n      opts.gc = false;\n    }\n    if (doc.autoLoad) {\n      opts.autoLoad = true;\n    }\n    if (doc.meta !== null) {\n      opts.meta = doc.meta;\n    }\n  }\n\n  /**\n   * @return {number}\n   */\n  getLength () {\n    return 1\n  }\n\n  /**\n   * @return {Array<any>}\n   */\n  getContent () {\n    return [this.doc]\n  }\n\n  /**\n   * @return {boolean}\n   */\n  isCountable () {\n    return true\n  }\n\n  /**\n   * @return {ContentDoc}\n   */\n  copy () {\n    return new ContentDoc(createDocFromOpts(this.doc.guid, this.opts))\n  }\n\n  /**\n   * @param {number} offset\n   * @return {ContentDoc}\n   */\n  splice (offset) {\n    throw error.methodUnimplemented()\n  }\n\n  /**\n   * @param {ContentDoc} right\n   * @return {boolean}\n   */\n  mergeWith (right) {\n    return false\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {Item} item\n   */\n  integrate (transaction, item) {\n    // this needs to be reflected in doc.destroy as well\n    this.doc._item = item;\n    transaction.subdocsAdded.add(this.doc);\n    if (this.doc.shouldLoad) {\n      transaction.subdocsLoaded.add(this.doc);\n    }\n  }\n\n  /**\n   * @param {Transaction} transaction\n   */\n  delete (transaction) {\n    if (transaction.subdocsAdded.has(this.doc)) {\n      transaction.subdocsAdded.delete(this.doc);\n    } else {\n      transaction.subdocsRemoved.add(this.doc);\n    }\n  }\n\n  /**\n   * @param {StructStore} store\n   */\n  gc (store) { }\n\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   * @param {number} offset\n   */\n  write (encoder, offset) {\n    encoder.writeString(this.doc.guid);\n    encoder.writeAny(this.opts);\n  }\n\n  /**\n   * @return {number}\n   */\n  getRef () {\n    return 9\n  }\n}\n\n/**\n * @private\n *\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n * @return {ContentDoc}\n */\nconst readContentDoc = decoder => new ContentDoc(createDocFromOpts(decoder.readString(), decoder.readAny()));\n\n/**\n * @private\n */\nclass ContentEmbed {\n  /**\n   * @param {Object} embed\n   */\n  constructor (embed) {\n    this.embed = embed;\n  }\n\n  /**\n   * @return {number}\n   */\n  getLength () {\n    return 1\n  }\n\n  /**\n   * @return {Array<any>}\n   */\n  getContent () {\n    return [this.embed]\n  }\n\n  /**\n   * @return {boolean}\n   */\n  isCountable () {\n    return true\n  }\n\n  /**\n   * @return {ContentEmbed}\n   */\n  copy () {\n    return new ContentEmbed(this.embed)\n  }\n\n  /**\n   * @param {number} offset\n   * @return {ContentEmbed}\n   */\n  splice (offset) {\n    throw error.methodUnimplemented()\n  }\n\n  /**\n   * @param {ContentEmbed} right\n   * @return {boolean}\n   */\n  mergeWith (right) {\n    return false\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {Item} item\n   */\n  integrate (transaction, item) {}\n  /**\n   * @param {Transaction} transaction\n   */\n  delete (transaction) {}\n  /**\n   * @param {StructStore} store\n   */\n  gc (store) {}\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   * @param {number} offset\n   */\n  write (encoder, offset) {\n    encoder.writeJSON(this.embed);\n  }\n\n  /**\n   * @return {number}\n   */\n  getRef () {\n    return 5\n  }\n}\n\n/**\n * @private\n *\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n * @return {ContentEmbed}\n */\nconst readContentEmbed = decoder => new ContentEmbed(decoder.readJSON());\n\n/**\n * @private\n */\nclass ContentFormat {\n  /**\n   * @param {string} key\n   * @param {Object} value\n   */\n  constructor (key, value) {\n    this.key = key;\n    this.value = value;\n  }\n\n  /**\n   * @return {number}\n   */\n  getLength () {\n    return 1\n  }\n\n  /**\n   * @return {Array<any>}\n   */\n  getContent () {\n    return []\n  }\n\n  /**\n   * @return {boolean}\n   */\n  isCountable () {\n    return false\n  }\n\n  /**\n   * @return {ContentFormat}\n   */\n  copy () {\n    return new ContentFormat(this.key, this.value)\n  }\n\n  /**\n   * @param {number} _offset\n   * @return {ContentFormat}\n   */\n  splice (_offset) {\n    throw error.methodUnimplemented()\n  }\n\n  /**\n   * @param {ContentFormat} _right\n   * @return {boolean}\n   */\n  mergeWith (_right) {\n    return false\n  }\n\n  /**\n   * @param {Transaction} _transaction\n   * @param {Item} item\n   */\n  integrate (_transaction, item) {\n    // @todo searchmarker are currently unsupported for rich text documents\n    const p = /** @type {YText} */ (item.parent);\n    p._searchMarker = null;\n    p._hasFormatting = true;\n  }\n\n  /**\n   * @param {Transaction} transaction\n   */\n  delete (transaction) {}\n  /**\n   * @param {StructStore} store\n   */\n  gc (store) {}\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   * @param {number} offset\n   */\n  write (encoder, offset) {\n    encoder.writeKey(this.key);\n    encoder.writeJSON(this.value);\n  }\n\n  /**\n   * @return {number}\n   */\n  getRef () {\n    return 6\n  }\n}\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n * @return {ContentFormat}\n */\nconst readContentFormat = decoder => new ContentFormat(decoder.readKey(), decoder.readJSON());\n\n/**\n * @private\n */\nclass ContentJSON {\n  /**\n   * @param {Array<any>} arr\n   */\n  constructor (arr) {\n    /**\n     * @type {Array<any>}\n     */\n    this.arr = arr;\n  }\n\n  /**\n   * @return {number}\n   */\n  getLength () {\n    return this.arr.length\n  }\n\n  /**\n   * @return {Array<any>}\n   */\n  getContent () {\n    return this.arr\n  }\n\n  /**\n   * @return {boolean}\n   */\n  isCountable () {\n    return true\n  }\n\n  /**\n   * @return {ContentJSON}\n   */\n  copy () {\n    return new ContentJSON(this.arr)\n  }\n\n  /**\n   * @param {number} offset\n   * @return {ContentJSON}\n   */\n  splice (offset) {\n    const right = new ContentJSON(this.arr.slice(offset));\n    this.arr = this.arr.slice(0, offset);\n    return right\n  }\n\n  /**\n   * @param {ContentJSON} right\n   * @return {boolean}\n   */\n  mergeWith (right) {\n    this.arr = this.arr.concat(right.arr);\n    return true\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {Item} item\n   */\n  integrate (transaction, item) {}\n  /**\n   * @param {Transaction} transaction\n   */\n  delete (transaction) {}\n  /**\n   * @param {StructStore} store\n   */\n  gc (store) {}\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   * @param {number} offset\n   */\n  write (encoder, offset) {\n    const len = this.arr.length;\n    encoder.writeLen(len - offset);\n    for (let i = offset; i < len; i++) {\n      const c = this.arr[i];\n      encoder.writeString(c === undefined ? 'undefined' : JSON.stringify(c));\n    }\n  }\n\n  /**\n   * @return {number}\n   */\n  getRef () {\n    return 2\n  }\n}\n\n/**\n * @private\n *\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n * @return {ContentJSON}\n */\nconst readContentJSON = decoder => {\n  const len = decoder.readLen();\n  const cs = [];\n  for (let i = 0; i < len; i++) {\n    const c = decoder.readString();\n    if (c === 'undefined') {\n      cs.push(undefined);\n    } else {\n      cs.push(JSON.parse(c));\n    }\n  }\n  return new ContentJSON(cs)\n};\n\nclass ContentAny {\n  /**\n   * @param {Array<any>} arr\n   */\n  constructor (arr) {\n    /**\n     * @type {Array<any>}\n     */\n    this.arr = arr;\n  }\n\n  /**\n   * @return {number}\n   */\n  getLength () {\n    return this.arr.length\n  }\n\n  /**\n   * @return {Array<any>}\n   */\n  getContent () {\n    return this.arr\n  }\n\n  /**\n   * @return {boolean}\n   */\n  isCountable () {\n    return true\n  }\n\n  /**\n   * @return {ContentAny}\n   */\n  copy () {\n    return new ContentAny(this.arr)\n  }\n\n  /**\n   * @param {number} offset\n   * @return {ContentAny}\n   */\n  splice (offset) {\n    const right = new ContentAny(this.arr.slice(offset));\n    this.arr = this.arr.slice(0, offset);\n    return right\n  }\n\n  /**\n   * @param {ContentAny} right\n   * @return {boolean}\n   */\n  mergeWith (right) {\n    this.arr = this.arr.concat(right.arr);\n    return true\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {Item} item\n   */\n  integrate (transaction, item) {}\n  /**\n   * @param {Transaction} transaction\n   */\n  delete (transaction) {}\n  /**\n   * @param {StructStore} store\n   */\n  gc (store) {}\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   * @param {number} offset\n   */\n  write (encoder, offset) {\n    const len = this.arr.length;\n    encoder.writeLen(len - offset);\n    for (let i = offset; i < len; i++) {\n      const c = this.arr[i];\n      encoder.writeAny(c);\n    }\n  }\n\n  /**\n   * @return {number}\n   */\n  getRef () {\n    return 8\n  }\n}\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n * @return {ContentAny}\n */\nconst readContentAny = decoder => {\n  const len = decoder.readLen();\n  const cs = [];\n  for (let i = 0; i < len; i++) {\n    cs.push(decoder.readAny());\n  }\n  return new ContentAny(cs)\n};\n\n/**\n * @private\n */\nclass ContentString {\n  /**\n   * @param {string} str\n   */\n  constructor (str) {\n    /**\n     * @type {string}\n     */\n    this.str = str;\n  }\n\n  /**\n   * @return {number}\n   */\n  getLength () {\n    return this.str.length\n  }\n\n  /**\n   * @return {Array<any>}\n   */\n  getContent () {\n    return this.str.split('')\n  }\n\n  /**\n   * @return {boolean}\n   */\n  isCountable () {\n    return true\n  }\n\n  /**\n   * @return {ContentString}\n   */\n  copy () {\n    return new ContentString(this.str)\n  }\n\n  /**\n   * @param {number} offset\n   * @return {ContentString}\n   */\n  splice (offset) {\n    const right = new ContentString(this.str.slice(offset));\n    this.str = this.str.slice(0, offset);\n\n    // Prevent encoding invalid documents because of splitting of surrogate pairs: https://github.com/yjs/yjs/issues/248\n    const firstCharCode = this.str.charCodeAt(offset - 1);\n    if (firstCharCode >= 0xD800 && firstCharCode <= 0xDBFF) {\n      // Last character of the left split is the start of a surrogate utf16/ucs2 pair.\n      // We don't support splitting of surrogate pairs because this may lead to invalid documents.\n      // Replace the invalid character with a unicode replacement character (� / U+FFFD)\n      this.str = this.str.slice(0, offset - 1) + '�';\n      // replace right as well\n      right.str = '�' + right.str.slice(1);\n    }\n    return right\n  }\n\n  /**\n   * @param {ContentString} right\n   * @return {boolean}\n   */\n  mergeWith (right) {\n    this.str += right.str;\n    return true\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {Item} item\n   */\n  integrate (transaction, item) {}\n  /**\n   * @param {Transaction} transaction\n   */\n  delete (transaction) {}\n  /**\n   * @param {StructStore} store\n   */\n  gc (store) {}\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   * @param {number} offset\n   */\n  write (encoder, offset) {\n    encoder.writeString(offset === 0 ? this.str : this.str.slice(offset));\n  }\n\n  /**\n   * @return {number}\n   */\n  getRef () {\n    return 4\n  }\n}\n\n/**\n * @private\n *\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n * @return {ContentString}\n */\nconst readContentString = decoder => new ContentString(decoder.readString());\n\n/**\n * @type {Array<function(UpdateDecoderV1 | UpdateDecoderV2):AbstractType<any>>}\n * @private\n */\nconst typeRefs = [\n  readYArray,\n  readYMap,\n  readYText,\n  readYXmlElement,\n  readYXmlFragment,\n  readYXmlHook,\n  readYXmlText\n];\n\nconst YArrayRefID = 0;\nconst YMapRefID = 1;\nconst YTextRefID = 2;\nconst YXmlElementRefID = 3;\nconst YXmlFragmentRefID = 4;\nconst YXmlHookRefID = 5;\nconst YXmlTextRefID = 6;\n\n/**\n * @private\n */\nclass ContentType {\n  /**\n   * @param {AbstractType<any>} type\n   */\n  constructor (type) {\n    /**\n     * @type {AbstractType<any>}\n     */\n    this.type = type;\n  }\n\n  /**\n   * @return {number}\n   */\n  getLength () {\n    return 1\n  }\n\n  /**\n   * @return {Array<any>}\n   */\n  getContent () {\n    return [this.type]\n  }\n\n  /**\n   * @return {boolean}\n   */\n  isCountable () {\n    return true\n  }\n\n  /**\n   * @return {ContentType}\n   */\n  copy () {\n    return new ContentType(this.type._copy())\n  }\n\n  /**\n   * @param {number} offset\n   * @return {ContentType}\n   */\n  splice (offset) {\n    throw error.methodUnimplemented()\n  }\n\n  /**\n   * @param {ContentType} right\n   * @return {boolean}\n   */\n  mergeWith (right) {\n    return false\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {Item} item\n   */\n  integrate (transaction, item) {\n    this.type._integrate(transaction.doc, item);\n  }\n\n  /**\n   * @param {Transaction} transaction\n   */\n  delete (transaction) {\n    let item = this.type._start;\n    while (item !== null) {\n      if (!item.deleted) {\n        item.delete(transaction);\n      } else if (item.id.clock < (transaction.beforeState.get(item.id.client) || 0)) {\n        // This will be gc'd later and we want to merge it if possible\n        // We try to merge all deleted items after each transaction,\n        // but we have no knowledge about that this needs to be merged\n        // since it is not in transaction.ds. Hence we add it to transaction._mergeStructs\n        transaction._mergeStructs.push(item);\n      }\n      item = item.right;\n    }\n    this.type._map.forEach(item => {\n      if (!item.deleted) {\n        item.delete(transaction);\n      } else if (item.id.clock < (transaction.beforeState.get(item.id.client) || 0)) {\n        // same as above\n        transaction._mergeStructs.push(item);\n      }\n    });\n    transaction.changed.delete(this.type);\n  }\n\n  /**\n   * @param {StructStore} store\n   */\n  gc (store) {\n    let item = this.type._start;\n    while (item !== null) {\n      item.gc(store, true);\n      item = item.right;\n    }\n    this.type._start = null;\n    this.type._map.forEach(/** @param {Item | null} item */ (item) => {\n      while (item !== null) {\n        item.gc(store, true);\n        item = item.left;\n      }\n    });\n    this.type._map = new Map();\n  }\n\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   * @param {number} offset\n   */\n  write (encoder, offset) {\n    this.type._write(encoder);\n  }\n\n  /**\n   * @return {number}\n   */\n  getRef () {\n    return 7\n  }\n}\n\n/**\n * @private\n *\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n * @return {ContentType}\n */\nconst readContentType = decoder => new ContentType(typeRefs[decoder.readTypeRef()](decoder));\n\n/**\n * @todo This should return several items\n *\n * @param {StructStore} store\n * @param {ID} id\n * @return {{item:Item, diff:number}}\n */\nconst followRedone = (store, id) => {\n  /**\n   * @type {ID|null}\n   */\n  let nextID = id;\n  let diff = 0;\n  let item;\n  do {\n    if (diff > 0) {\n      nextID = createID(nextID.client, nextID.clock + diff);\n    }\n    item = getItem(store, nextID);\n    diff = nextID.clock - item.id.clock;\n    nextID = item.redone;\n  } while (nextID !== null && item instanceof Item)\n  return {\n    item, diff\n  }\n};\n\n/**\n * Make sure that neither item nor any of its parents is ever deleted.\n *\n * This property does not persist when storing it into a database or when\n * sending it to other peers\n *\n * @param {Item|null} item\n * @param {boolean} keep\n */\nconst keepItem = (item, keep) => {\n  while (item !== null && item.keep !== keep) {\n    item.keep = keep;\n    item = /** @type {AbstractType<any>} */ (item.parent)._item;\n  }\n};\n\n/**\n * Split leftItem into two items\n * @param {Transaction} transaction\n * @param {Item} leftItem\n * @param {number} diff\n * @return {Item}\n *\n * @function\n * @private\n */\nconst splitItem = (transaction, leftItem, diff) => {\n  // create rightItem\n  const { client, clock } = leftItem.id;\n  const rightItem = new Item(\n    createID(client, clock + diff),\n    leftItem,\n    createID(client, clock + diff - 1),\n    leftItem.right,\n    leftItem.rightOrigin,\n    leftItem.parent,\n    leftItem.parentSub,\n    leftItem.content.splice(diff)\n  );\n  if (leftItem.deleted) {\n    rightItem.markDeleted();\n  }\n  if (leftItem.keep) {\n    rightItem.keep = true;\n  }\n  if (leftItem.redone !== null) {\n    rightItem.redone = createID(leftItem.redone.client, leftItem.redone.clock + diff);\n  }\n  // update left (do not set leftItem.rightOrigin as it will lead to problems when syncing)\n  leftItem.right = rightItem;\n  // update right\n  if (rightItem.right !== null) {\n    rightItem.right.left = rightItem;\n  }\n  // right is more specific.\n  transaction._mergeStructs.push(rightItem);\n  // update parent._map\n  if (rightItem.parentSub !== null && rightItem.right === null) {\n    /** @type {AbstractType<any>} */ (rightItem.parent)._map.set(rightItem.parentSub, rightItem);\n  }\n  leftItem.length = diff;\n  return rightItem\n};\n\n/**\n * @param {Array<StackItem>} stack\n * @param {ID} id\n */\nconst isDeletedByUndoStack = (stack, id) => array.some(stack, /** @param {StackItem} s */ s => isDeleted(s.deletions, id));\n\n/**\n * Redoes the effect of this operation.\n *\n * @param {Transaction} transaction The Yjs instance.\n * @param {Item} item\n * @param {Set<Item>} redoitems\n * @param {DeleteSet} itemsToDelete\n * @param {boolean} ignoreRemoteMapChanges\n * @param {import('../utils/UndoManager.js').UndoManager} um\n *\n * @return {Item|null}\n *\n * @private\n */\nconst redoItem = (transaction, item, redoitems, itemsToDelete, ignoreRemoteMapChanges, um) => {\n  const doc = transaction.doc;\n  const store = doc.store;\n  const ownClientID = doc.clientID;\n  const redone = item.redone;\n  if (redone !== null) {\n    return getItemCleanStart(transaction, redone)\n  }\n  let parentItem = /** @type {AbstractType<any>} */ (item.parent)._item;\n  /**\n   * @type {Item|null}\n   */\n  let left = null;\n  /**\n   * @type {Item|null}\n   */\n  let right;\n  // make sure that parent is redone\n  if (parentItem !== null && parentItem.deleted === true) {\n    // try to undo parent if it will be undone anyway\n    if (parentItem.redone === null && (!redoitems.has(parentItem) || redoItem(transaction, parentItem, redoitems, itemsToDelete, ignoreRemoteMapChanges, um) === null)) {\n      return null\n    }\n    while (parentItem.redone !== null) {\n      parentItem = getItemCleanStart(transaction, parentItem.redone);\n    }\n  }\n  const parentType = parentItem === null ? /** @type {AbstractType<any>} */ (item.parent) : /** @type {ContentType} */ (parentItem.content).type;\n\n  if (item.parentSub === null) {\n    // Is an array item. Insert at the old position\n    left = item.left;\n    right = item;\n    // find next cloned_redo items\n    while (left !== null) {\n      /**\n       * @type {Item|null}\n       */\n      let leftTrace = left;\n      // trace redone until parent matches\n      while (leftTrace !== null && /** @type {AbstractType<any>} */ (leftTrace.parent)._item !== parentItem) {\n        leftTrace = leftTrace.redone === null ? null : getItemCleanStart(transaction, leftTrace.redone);\n      }\n      if (leftTrace !== null && /** @type {AbstractType<any>} */ (leftTrace.parent)._item === parentItem) {\n        left = leftTrace;\n        break\n      }\n      left = left.left;\n    }\n    while (right !== null) {\n      /**\n       * @type {Item|null}\n       */\n      let rightTrace = right;\n      // trace redone until parent matches\n      while (rightTrace !== null && /** @type {AbstractType<any>} */ (rightTrace.parent)._item !== parentItem) {\n        rightTrace = rightTrace.redone === null ? null : getItemCleanStart(transaction, rightTrace.redone);\n      }\n      if (rightTrace !== null && /** @type {AbstractType<any>} */ (rightTrace.parent)._item === parentItem) {\n        right = rightTrace;\n        break\n      }\n      right = right.right;\n    }\n  } else {\n    right = null;\n    if (item.right && !ignoreRemoteMapChanges) {\n      left = item;\n      // Iterate right while right is in itemsToDelete\n      // If it is intended to delete right while item is redone, we can expect that item should replace right.\n      while (left !== null && left.right !== null && (left.right.redone || isDeleted(itemsToDelete, left.right.id) || isDeletedByUndoStack(um.undoStack, left.right.id) || isDeletedByUndoStack(um.redoStack, left.right.id))) {\n        left = left.right;\n        // follow redone\n        while (left.redone) left = getItemCleanStart(transaction, left.redone);\n      }\n      if (left && left.right !== null) {\n        // It is not possible to redo this item because it conflicts with a\n        // change from another client\n        return null\n      }\n    } else {\n      left = parentType._map.get(item.parentSub) || null;\n    }\n  }\n  const nextClock = getState(store, ownClientID);\n  const nextId = createID(ownClientID, nextClock);\n  const redoneItem = new Item(\n    nextId,\n    left, left && left.lastId,\n    right, right && right.id,\n    parentType,\n    item.parentSub,\n    item.content.copy()\n  );\n  item.redone = nextId;\n  keepItem(redoneItem, true);\n  redoneItem.integrate(transaction, 0);\n  return redoneItem\n};\n\n/**\n * Abstract class that represents any content.\n */\nclass Item extends AbstractStruct {\n  /**\n   * @param {ID} id\n   * @param {Item | null} left\n   * @param {ID | null} origin\n   * @param {Item | null} right\n   * @param {ID | null} rightOrigin\n   * @param {AbstractType<any>|ID|null} parent Is a type if integrated, is null if it is possible to copy parent from left or right, is ID before integration to search for it.\n   * @param {string | null} parentSub\n   * @param {AbstractContent} content\n   */\n  constructor (id, left, origin, right, rightOrigin, parent, parentSub, content) {\n    super(id, content.getLength());\n    /**\n     * The item that was originally to the left of this item.\n     * @type {ID | null}\n     */\n    this.origin = origin;\n    /**\n     * The item that is currently to the left of this item.\n     * @type {Item | null}\n     */\n    this.left = left;\n    /**\n     * The item that is currently to the right of this item.\n     * @type {Item | null}\n     */\n    this.right = right;\n    /**\n     * The item that was originally to the right of this item.\n     * @type {ID | null}\n     */\n    this.rightOrigin = rightOrigin;\n    /**\n     * @type {AbstractType<any>|ID|null}\n     */\n    this.parent = parent;\n    /**\n     * If the parent refers to this item with some kind of key (e.g. YMap, the\n     * key is specified here. The key is then used to refer to the list in which\n     * to insert this item. If `parentSub = null` type._start is the list in\n     * which to insert to. Otherwise it is `parent._map`.\n     * @type {String | null}\n     */\n    this.parentSub = parentSub;\n    /**\n     * If this type's effect is redone this type refers to the type that undid\n     * this operation.\n     * @type {ID | null}\n     */\n    this.redone = null;\n    /**\n     * @type {AbstractContent}\n     */\n    this.content = content;\n    /**\n     * bit1: keep\n     * bit2: countable\n     * bit3: deleted\n     * bit4: mark - mark node as fast-search-marker\n     * @type {number} byte\n     */\n    this.info = this.content.isCountable() ? binary.BIT2 : 0;\n  }\n\n  /**\n   * This is used to mark the item as an indexed fast-search marker\n   *\n   * @type {boolean}\n   */\n  set marker (isMarked) {\n    if (((this.info & binary.BIT4) > 0) !== isMarked) {\n      this.info ^= binary.BIT4;\n    }\n  }\n\n  get marker () {\n    return (this.info & binary.BIT4) > 0\n  }\n\n  /**\n   * If true, do not garbage collect this Item.\n   */\n  get keep () {\n    return (this.info & binary.BIT1) > 0\n  }\n\n  set keep (doKeep) {\n    if (this.keep !== doKeep) {\n      this.info ^= binary.BIT1;\n    }\n  }\n\n  get countable () {\n    return (this.info & binary.BIT2) > 0\n  }\n\n  /**\n   * Whether this item was deleted or not.\n   * @type {Boolean}\n   */\n  get deleted () {\n    return (this.info & binary.BIT3) > 0\n  }\n\n  set deleted (doDelete) {\n    if (this.deleted !== doDelete) {\n      this.info ^= binary.BIT3;\n    }\n  }\n\n  markDeleted () {\n    this.info |= binary.BIT3;\n  }\n\n  /**\n   * Return the creator clientID of the missing op or define missing items and return null.\n   *\n   * @param {Transaction} transaction\n   * @param {StructStore} store\n   * @return {null | number}\n   */\n  getMissing (transaction, store) {\n    if (this.origin && this.origin.client !== this.id.client && this.origin.clock >= getState(store, this.origin.client)) {\n      return this.origin.client\n    }\n    if (this.rightOrigin && this.rightOrigin.client !== this.id.client && this.rightOrigin.clock >= getState(store, this.rightOrigin.client)) {\n      return this.rightOrigin.client\n    }\n    if (this.parent && this.parent.constructor === ID && this.id.client !== this.parent.client && this.parent.clock >= getState(store, this.parent.client)) {\n      return this.parent.client\n    }\n\n    // We have all missing ids, now find the items\n\n    if (this.origin) {\n      this.left = getItemCleanEnd(transaction, store, this.origin);\n      this.origin = this.left.lastId;\n    }\n    if (this.rightOrigin) {\n      this.right = getItemCleanStart(transaction, this.rightOrigin);\n      this.rightOrigin = this.right.id;\n    }\n    if ((this.left && this.left.constructor === GC) || (this.right && this.right.constructor === GC)) {\n      this.parent = null;\n    }\n    // only set parent if this shouldn't be garbage collected\n    if (!this.parent) {\n      if (this.left && this.left.constructor === Item) {\n        this.parent = this.left.parent;\n        this.parentSub = this.left.parentSub;\n      }\n      if (this.right && this.right.constructor === Item) {\n        this.parent = this.right.parent;\n        this.parentSub = this.right.parentSub;\n      }\n    } else if (this.parent.constructor === ID) {\n      const parentItem = getItem(store, this.parent);\n      if (parentItem.constructor === GC) {\n        this.parent = null;\n      } else {\n        this.parent = /** @type {ContentType} */ (parentItem.content).type;\n      }\n    }\n    return null\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {number} offset\n   */\n  integrate (transaction, offset) {\n    if (offset > 0) {\n      this.id.clock += offset;\n      this.left = getItemCleanEnd(transaction, transaction.doc.store, createID(this.id.client, this.id.clock - 1));\n      this.origin = this.left.lastId;\n      this.content = this.content.splice(offset);\n      this.length -= offset;\n    }\n\n    if (this.parent) {\n      if ((!this.left && (!this.right || this.right.left !== null)) || (this.left && this.left.right !== this.right)) {\n        /**\n         * @type {Item|null}\n         */\n        let left = this.left;\n\n        /**\n         * @type {Item|null}\n         */\n        let o;\n        // set o to the first conflicting item\n        if (left !== null) {\n          o = left.right;\n        } else if (this.parentSub !== null) {\n          o = /** @type {AbstractType<any>} */ (this.parent)._map.get(this.parentSub) || null;\n          while (o !== null && o.left !== null) {\n            o = o.left;\n          }\n        } else {\n          o = /** @type {AbstractType<any>} */ (this.parent)._start;\n        }\n        // TODO: use something like DeleteSet here (a tree implementation would be best)\n        // @todo use global set definitions\n        /**\n         * @type {Set<Item>}\n         */\n        const conflictingItems = new Set();\n        /**\n         * @type {Set<Item>}\n         */\n        const itemsBeforeOrigin = new Set();\n        // Let c in conflictingItems, b in itemsBeforeOrigin\n        // ***{origin}bbbb{this}{c,b}{c,b}{o}***\n        // Note that conflictingItems is a subset of itemsBeforeOrigin\n        while (o !== null && o !== this.right) {\n          itemsBeforeOrigin.add(o);\n          conflictingItems.add(o);\n          if (compareIDs(this.origin, o.origin)) {\n            // case 1\n            if (o.id.client < this.id.client) {\n              left = o;\n              conflictingItems.clear();\n            } else if (compareIDs(this.rightOrigin, o.rightOrigin)) {\n              // this and o are conflicting and point to the same integration points. The id decides which item comes first.\n              // Since this is to the left of o, we can break here\n              break\n            } // else, o might be integrated before an item that this conflicts with. If so, we will find it in the next iterations\n          } else if (o.origin !== null && itemsBeforeOrigin.has(getItem(transaction.doc.store, o.origin))) { // use getItem instead of getItemCleanEnd because we don't want / need to split items.\n            // case 2\n            if (!conflictingItems.has(getItem(transaction.doc.store, o.origin))) {\n              left = o;\n              conflictingItems.clear();\n            }\n          } else {\n            break\n          }\n          o = o.right;\n        }\n        this.left = left;\n      }\n      // reconnect left/right + update parent map/start if necessary\n      if (this.left !== null) {\n        const right = this.left.right;\n        this.right = right;\n        this.left.right = this;\n      } else {\n        let r;\n        if (this.parentSub !== null) {\n          r = /** @type {AbstractType<any>} */ (this.parent)._map.get(this.parentSub) || null;\n          while (r !== null && r.left !== null) {\n            r = r.left;\n          }\n        } else {\n          r = /** @type {AbstractType<any>} */ (this.parent)._start\n          ;/** @type {AbstractType<any>} */ (this.parent)._start = this;\n        }\n        this.right = r;\n      }\n      if (this.right !== null) {\n        this.right.left = this;\n      } else if (this.parentSub !== null) {\n        // set as current parent value if right === null and this is parentSub\n        /** @type {AbstractType<any>} */ (this.parent)._map.set(this.parentSub, this);\n        if (this.left !== null) {\n          // this is the current attribute value of parent. delete right\n          this.left.delete(transaction);\n        }\n      }\n      // adjust length of parent\n      if (this.parentSub === null && this.countable && !this.deleted) {\n        /** @type {AbstractType<any>} */ (this.parent)._length += this.length;\n      }\n      addStruct(transaction.doc.store, this);\n      this.content.integrate(transaction, this);\n      // add parent to transaction.changed\n      addChangedTypeToTransaction(transaction, /** @type {AbstractType<any>} */ (this.parent), this.parentSub);\n      if ((/** @type {AbstractType<any>} */ (this.parent)._item !== null && /** @type {AbstractType<any>} */ (this.parent)._item.deleted) || (this.parentSub !== null && this.right !== null)) {\n        // delete if parent is deleted or if this is not the current attribute value of parent\n        this.delete(transaction);\n      }\n    } else {\n      // parent is not defined. Integrate GC struct instead\n      new GC(this.id, this.length).integrate(transaction, 0);\n    }\n  }\n\n  /**\n   * Returns the next non-deleted item\n   */\n  get next () {\n    let n = this.right;\n    while (n !== null && n.deleted) {\n      n = n.right;\n    }\n    return n\n  }\n\n  /**\n   * Returns the previous non-deleted item\n   */\n  get prev () {\n    let n = this.left;\n    while (n !== null && n.deleted) {\n      n = n.left;\n    }\n    return n\n  }\n\n  /**\n   * Computes the last content address of this Item.\n   */\n  get lastId () {\n    // allocating ids is pretty costly because of the amount of ids created, so we try to reuse whenever possible\n    return this.length === 1 ? this.id : createID(this.id.client, this.id.clock + this.length - 1)\n  }\n\n  /**\n   * Try to merge two items\n   *\n   * @param {Item} right\n   * @return {boolean}\n   */\n  mergeWith (right) {\n    if (\n      this.constructor === right.constructor &&\n      compareIDs(right.origin, this.lastId) &&\n      this.right === right &&\n      compareIDs(this.rightOrigin, right.rightOrigin) &&\n      this.id.client === right.id.client &&\n      this.id.clock + this.length === right.id.clock &&\n      this.deleted === right.deleted &&\n      this.redone === null &&\n      right.redone === null &&\n      this.content.constructor === right.content.constructor &&\n      this.content.mergeWith(right.content)\n    ) {\n      const searchMarker = /** @type {AbstractType<any>} */ (this.parent)._searchMarker;\n      if (searchMarker) {\n        searchMarker.forEach(marker => {\n          if (marker.p === right) {\n            // right is going to be \"forgotten\" so we need to update the marker\n            marker.p = this;\n            // adjust marker index\n            if (!this.deleted && this.countable) {\n              marker.index -= this.length;\n            }\n          }\n        });\n      }\n      if (right.keep) {\n        this.keep = true;\n      }\n      this.right = right.right;\n      if (this.right !== null) {\n        this.right.left = this;\n      }\n      this.length += right.length;\n      return true\n    }\n    return false\n  }\n\n  /**\n   * Mark this Item as deleted.\n   *\n   * @param {Transaction} transaction\n   */\n  delete (transaction) {\n    if (!this.deleted) {\n      const parent = /** @type {AbstractType<any>} */ (this.parent);\n      // adjust the length of parent\n      if (this.countable && this.parentSub === null) {\n        parent._length -= this.length;\n      }\n      this.markDeleted();\n      addToDeleteSet(transaction.deleteSet, this.id.client, this.id.clock, this.length);\n      addChangedTypeToTransaction(transaction, parent, this.parentSub);\n      this.content.delete(transaction);\n    }\n  }\n\n  /**\n   * @param {StructStore} store\n   * @param {boolean} parentGCd\n   */\n  gc (store, parentGCd) {\n    if (!this.deleted) {\n      throw error.unexpectedCase()\n    }\n    this.content.gc(store);\n    if (parentGCd) {\n      replaceStruct(store, this, new GC(this.id, this.length));\n    } else {\n      this.content = new ContentDeleted(this.length);\n    }\n  }\n\n  /**\n   * Transform the properties of this type to binary and write it to an\n   * BinaryEncoder.\n   *\n   * This is called when this Item is sent to a remote peer.\n   *\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder The encoder to write data to.\n   * @param {number} offset\n   */\n  write (encoder, offset) {\n    const origin = offset > 0 ? createID(this.id.client, this.id.clock + offset - 1) : this.origin;\n    const rightOrigin = this.rightOrigin;\n    const parentSub = this.parentSub;\n    const info = (this.content.getRef() & binary.BITS5) |\n      (origin === null ? 0 : binary.BIT8) | // origin is defined\n      (rightOrigin === null ? 0 : binary.BIT7) | // right origin is defined\n      (parentSub === null ? 0 : binary.BIT6); // parentSub is non-null\n    encoder.writeInfo(info);\n    if (origin !== null) {\n      encoder.writeLeftID(origin);\n    }\n    if (rightOrigin !== null) {\n      encoder.writeRightID(rightOrigin);\n    }\n    if (origin === null && rightOrigin === null) {\n      const parent = /** @type {AbstractType<any>} */ (this.parent);\n      if (parent._item !== undefined) {\n        const parentItem = parent._item;\n        if (parentItem === null) {\n          // parent type on y._map\n          // find the correct key\n          const ykey = findRootTypeKey(parent);\n          encoder.writeParentInfo(true); // write parentYKey\n          encoder.writeString(ykey);\n        } else {\n          encoder.writeParentInfo(false); // write parent id\n          encoder.writeLeftID(parentItem.id);\n        }\n      } else if (parent.constructor === String) { // this edge case was added by differential updates\n        encoder.writeParentInfo(true); // write parentYKey\n        encoder.writeString(parent);\n      } else if (parent.constructor === ID) {\n        encoder.writeParentInfo(false); // write parent id\n        encoder.writeLeftID(parent);\n      } else {\n        error.unexpectedCase();\n      }\n      if (parentSub !== null) {\n        encoder.writeString(parentSub);\n      }\n    }\n    this.content.write(encoder, offset);\n  }\n}\n\n/**\n * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder\n * @param {number} info\n */\nconst readItemContent = (decoder, info) => contentRefs[info & binary.BITS5](decoder);\n\n/**\n * A lookup map for reading Item content.\n *\n * @type {Array<function(UpdateDecoderV1 | UpdateDecoderV2):AbstractContent>}\n */\nconst contentRefs = [\n  () => { error.unexpectedCase(); }, // GC is not ItemContent\n  readContentDeleted, // 1\n  readContentJSON, // 2\n  readContentBinary, // 3\n  readContentString, // 4\n  readContentEmbed, // 5\n  readContentFormat, // 6\n  readContentType, // 7\n  readContentAny, // 8\n  readContentDoc, // 9\n  () => { error.unexpectedCase(); } // 10 - Skip is not ItemContent\n];\n\nconst structSkipRefNumber = 10;\n\n/**\n * @private\n */\nclass Skip extends AbstractStruct {\n  get deleted () {\n    return true\n  }\n\n  delete () {}\n\n  /**\n   * @param {Skip} right\n   * @return {boolean}\n   */\n  mergeWith (right) {\n    if (this.constructor !== right.constructor) {\n      return false\n    }\n    this.length += right.length;\n    return true\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {number} offset\n   */\n  integrate (transaction, offset) {\n    // skip structs cannot be integrated\n    error.unexpectedCase();\n  }\n\n  /**\n   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder\n   * @param {number} offset\n   */\n  write (encoder, offset) {\n    encoder.writeInfo(structSkipRefNumber);\n    // write as VarUint because Skips can't make use of predictable length-encoding\n    encoding.writeVarUint(encoder.restEncoder, this.length - offset);\n  }\n\n  /**\n   * @param {Transaction} transaction\n   * @param {StructStore} store\n   * @return {null | number}\n   */\n  getMissing (transaction, store) {\n    return null\n  }\n}\n\n/** eslint-env browser */\n\nconst glo = /** @type {any} */ (typeof globalThis !== 'undefined'\n  ? globalThis\n  : typeof window !== 'undefined'\n    ? window\n    // @ts-ignore\n    : typeof global !== 'undefined' ? global : {});\n\nconst importIdentifier = '__ $YJS$ __';\n\nif (glo[importIdentifier] === true) {\n  /**\n   * Dear reader of this message. Please take this seriously.\n   *\n   * If you see this message, make sure that you only import one version of Yjs. In many cases,\n   * your package manager installs two versions of Yjs that are used by different packages within your project.\n   * Another reason for this message is that some parts of your project use the commonjs version of Yjs\n   * and others use the EcmaScript version of Yjs.\n   *\n   * This often leads to issues that are hard to debug. We often need to perform constructor checks,\n   * e.g. `struct instanceof GC`. If you imported different versions of Yjs, it is impossible for us to\n   * do the constructor checks anymore - which might break the CRDT algorithm.\n   *\n   * https://github.com/yjs/yjs/issues/438\n   */\n  console.error('Yjs was already imported. This breaks constructor checks and will lead to issues! - https://github.com/yjs/yjs/issues/438');\n}\nglo[importIdentifier] = true;\n\nexport { AbsolutePosition, AbstractConnector, AbstractStruct, AbstractType, YArray as Array, ContentAny, ContentBinary, ContentDeleted, ContentEmbed, ContentFormat, ContentJSON, ContentString, ContentType, Doc, GC, ID, Item, YMap as Map, PermanentUserData, RelativePosition, Snapshot, YText as Text, Transaction, UndoManager, UpdateEncoderV1, YXmlElement as XmlElement, YXmlFragment as XmlFragment, YXmlHook as XmlHook, YXmlText as XmlText, YArrayEvent, YEvent, YMapEvent, YTextEvent, YXmlEvent, applyUpdate, applyUpdateV2, cleanupYTextFormatting, compareIDs, compareRelativePositions, convertUpdateFormatV1ToV2, convertUpdateFormatV2ToV1, createAbsolutePositionFromRelativePosition, createDeleteSet, createDeleteSetFromStructStore, createDocFromSnapshot, createID, createRelativePositionFromJSON, createRelativePositionFromTypeIndex, createSnapshot, decodeRelativePosition, decodeSnapshot, decodeSnapshotV2, decodeStateVector, decodeUpdate, decodeUpdateV2, diffUpdate, diffUpdateV2, emptySnapshot, encodeRelativePosition, encodeSnapshot, encodeSnapshotV2, encodeStateAsUpdate, encodeStateAsUpdateV2, encodeStateVector, encodeStateVectorFromUpdate, encodeStateVectorFromUpdateV2, equalDeleteSets, equalSnapshots, findIndexSS, findRootTypeKey, getItem, getState, getTypeChildren, isDeleted, isParentOf, iterateDeletedStructs, logType, logUpdate, logUpdateV2, mergeUpdates, mergeUpdatesV2, obfuscateUpdate, obfuscateUpdateV2, parseUpdateMeta, parseUpdateMetaV2, readUpdate, readUpdateV2, relativePositionToJSON, snapshot, snapshotContainsUpdate, transact, tryGc, typeListToArraySnapshot, typeMapGetSnapshot };\n//# sourceMappingURL=yjs.mjs.map\n","/**\n * External dependencies\n */\n// @ts-ignore\nimport * as Y from 'yjs';\n\n/** @typedef {import('./types').ObjectType} ObjectType */\n/** @typedef {import('./types').ObjectID} ObjectID */\n/** @typedef {import('./types').ObjectConfig} ObjectConfig */\n/** @typedef {import('./types').CRDTDoc} CRDTDoc */\n/** @typedef {import('./types').ConnectDoc} ConnectDoc */\n/** @typedef {import('./types').SyncProvider} SyncProvider */\n\n/**\n * Create a sync provider.\n *\n * @param {ConnectDoc} connectLocal  Connect the document to a local database.\n * @param {ConnectDoc} connectRemote Connect the document to a remote sync connection.\n * @return {SyncProvider} Sync provider.\n */\nexport const createSyncProvider = ( connectLocal, connectRemote ) => {\n\t/**\n\t * @type {Record<string,ObjectConfig>}\n\t */\n\tconst config = {};\n\n\t/**\n\t * @type {Record<string,Record<string,()=>void>>}\n\t */\n\tconst listeners = {};\n\n\t/**\n\t * @type {Record<string,Record<string,CRDTDoc>>}\n\t */\n\tconst docs = {};\n\n\t/**\n\t * Registers an object type.\n\t *\n\t * @param {ObjectType}   objectType   Object type to register.\n\t * @param {ObjectConfig} objectConfig Object config.\n\t */\n\tfunction register( objectType, objectConfig ) {\n\t\tconfig[ objectType ] = objectConfig;\n\t}\n\n\t/**\n\t * Fetch data from local database or remote source.\n\t *\n\t * @param {ObjectType} objectType    Object type to load.\n\t * @param {ObjectID}   objectId      Object ID to load.\n\t * @param {Function}   handleChanges Callback to call when data changes.\n\t */\n\tasync function bootstrap( objectType, objectId, handleChanges ) {\n\t\tconst doc = new Y.Doc();\n\t\tdocs[ objectType ] = docs[ objectType ] || {};\n\t\tdocs[ objectType ][ objectId ] = doc;\n\n\t\tconst updateHandler = () => {\n\t\t\tconst data = config[ objectType ].fromCRDTDoc( doc );\n\t\t\thandleChanges( data );\n\t\t};\n\t\tdoc.on( 'update', updateHandler );\n\n\t\t// connect to locally saved database.\n\t\tconst destroyLocalConnection = await connectLocal(\n\t\t\tobjectId,\n\t\t\tobjectType,\n\t\t\tdoc\n\t\t);\n\n\t\t// Once the database syncing is done, start the remote syncing\n\t\tif ( connectRemote ) {\n\t\t\tawait connectRemote( objectId, objectType, doc );\n\t\t}\n\n\t\tconst loadRemotely = config[ objectType ].fetch;\n\t\tif ( loadRemotely ) {\n\t\t\tloadRemotely( objectId ).then( ( data ) => {\n\t\t\t\tdoc.transact( () => {\n\t\t\t\t\tconfig[ objectType ].applyChangesToDoc( doc, data );\n\t\t\t\t} );\n\t\t\t} );\n\t\t}\n\n\t\tlisteners[ objectType ] = listeners[ objectType ] || {};\n\t\tlisteners[ objectType ][ objectId ] = () => {\n\t\t\tdestroyLocalConnection();\n\t\t\tdoc.off( 'update', updateHandler );\n\t\t};\n\t}\n\n\t/**\n\t * Fetch data from local database or remote source.\n\t *\n\t * @param {ObjectType} objectType Object type to load.\n\t * @param {ObjectID}   objectId   Object ID to load.\n\t * @param {any}        data       Updates to make.\n\t */\n\tasync function update( objectType, objectId, data ) {\n\t\tconst doc = docs[ objectType ][ objectId ];\n\t\tif ( ! doc ) {\n\t\t\tthrow 'Error doc ' + objectType + ' ' + objectId + ' not found';\n\t\t}\n\t\tdoc.transact( () => {\n\t\t\tconfig[ objectType ].applyChangesToDoc( doc, data );\n\t\t} );\n\t}\n\n\t/**\n\t * Stop updating a document and discard it.\n\t *\n\t * @param {ObjectType} objectType Object type to load.\n\t * @param {ObjectID}   objectId   Object ID to load.\n\t */\n\tasync function discard( objectType, objectId ) {\n\t\tif ( listeners?.[ objectType ]?.[ objectId ] ) {\n\t\t\tlisteners[ objectType ][ objectId ]();\n\t\t}\n\t}\n\n\treturn {\n\t\tregister,\n\t\tbootstrap,\n\t\tupdate,\n\t\tdiscard,\n\t};\n};\n","/* eslint-env browser */\n\n/**\n * Helpers to work with IndexedDB.\n *\n * @module indexeddb\n */\n\nimport * as promise from './promise.js'\nimport * as error from './error.js'\n\n/* c8 ignore start */\n\n/**\n * IDB Request to Promise transformer\n *\n * @param {IDBRequest} request\n * @return {Promise<any>}\n */\nexport const rtop = request => promise.create((resolve, reject) => {\n  // @ts-ignore\n  request.onerror = event => reject(new Error(event.target.error))\n  // @ts-ignore\n  request.onsuccess = event => resolve(event.target.result)\n})\n\n/**\n * @param {string} name\n * @param {function(IDBDatabase):any} initDB Called when the database is first created\n * @return {Promise<IDBDatabase>}\n */\nexport const openDB = (name, initDB) => promise.create((resolve, reject) => {\n  const request = indexedDB.open(name)\n  /**\n   * @param {any} event\n   */\n  request.onupgradeneeded = event => initDB(event.target.result)\n  /**\n   * @param {any} event\n   */\n  request.onerror = event => reject(error.create(event.target.error))\n  /**\n   * @param {any} event\n   */\n  request.onsuccess = event => {\n    /**\n     * @type {IDBDatabase}\n     */\n    const db = event.target.result\n    db.onversionchange = () => { db.close() }\n    if (typeof addEventListener !== 'undefined') {\n      addEventListener('unload', () => db.close())\n    }\n    resolve(db)\n  }\n})\n\n/**\n * @param {string} name\n */\nexport const deleteDB = name => rtop(indexedDB.deleteDatabase(name))\n\n/**\n * @param {IDBDatabase} db\n * @param {Array<Array<string>|Array<string|IDBObjectStoreParameters|undefined>>} definitions\n */\nexport const createStores = (db, definitions) => definitions.forEach(d =>\n  // @ts-ignore\n  db.createObjectStore.apply(db, d)\n)\n\n/**\n * @param {IDBDatabase} db\n * @param {Array<string>} stores\n * @param {\"readwrite\"|\"readonly\"} [access]\n * @return {Array<IDBObjectStore>}\n */\nexport const transact = (db, stores, access = 'readwrite') => {\n  const transaction = db.transaction(stores, access)\n  return stores.map(store => getStore(transaction, store))\n}\n\n/**\n * @param {IDBObjectStore} store\n * @param {IDBKeyRange} [range]\n * @return {Promise<number>}\n */\nexport const count = (store, range) =>\n  rtop(store.count(range))\n\n/**\n * @param {IDBObjectStore} store\n * @param {String | number | ArrayBuffer | Date | Array<any> } key\n * @return {Promise<String | number | ArrayBuffer | Date | Array<any>>}\n */\nexport const get = (store, key) =>\n  rtop(store.get(key))\n\n/**\n * @param {IDBObjectStore} store\n * @param {String | number | ArrayBuffer | Date | IDBKeyRange | Array<any> } key\n */\nexport const del = (store, key) =>\n  rtop(store.delete(key))\n\n/**\n * @param {IDBObjectStore} store\n * @param {String | number | ArrayBuffer | Date | boolean} item\n * @param {String | number | ArrayBuffer | Date | Array<any>} [key]\n */\nexport const put = (store, item, key) =>\n  rtop(store.put(item, key))\n\n/**\n * @param {IDBObjectStore} store\n * @param {String | number | ArrayBuffer | Date | boolean}  item\n * @param {String | number | ArrayBuffer | Date | Array<any>}  key\n * @return {Promise<any>}\n */\nexport const add = (store, item, key) =>\n  rtop(store.add(item, key))\n\n/**\n * @param {IDBObjectStore} store\n * @param {String | number | ArrayBuffer | Date}  item\n * @return {Promise<number>} Returns the generated key\n */\nexport const addAutoKey = (store, item) =>\n  rtop(store.add(item))\n\n/**\n * @param {IDBObjectStore} store\n * @param {IDBKeyRange} [range]\n * @param {number} [limit]\n * @return {Promise<Array<any>>}\n */\nexport const getAll = (store, range, limit) =>\n  rtop(store.getAll(range, limit))\n\n/**\n * @param {IDBObjectStore} store\n * @param {IDBKeyRange} [range]\n * @param {number} [limit]\n * @return {Promise<Array<any>>}\n */\nexport const getAllKeys = (store, range, limit) =>\n  rtop(store.getAllKeys(range, limit))\n\n/**\n * @param {IDBObjectStore} store\n * @param {IDBKeyRange|null} query\n * @param {'next'|'prev'|'nextunique'|'prevunique'} direction\n * @return {Promise<any>}\n */\nexport const queryFirst = (store, query, direction) => {\n  /**\n   * @type {any}\n   */\n  let first = null\n  return iterateKeys(store, query, key => {\n    first = key\n    return false\n  }, direction).then(() => first)\n}\n\n/**\n * @param {IDBObjectStore} store\n * @param {IDBKeyRange?} [range]\n * @return {Promise<any>}\n */\nexport const getLastKey = (store, range = null) => queryFirst(store, range, 'prev')\n\n/**\n * @param {IDBObjectStore} store\n * @param {IDBKeyRange?} [range]\n * @return {Promise<any>}\n */\nexport const getFirstKey = (store, range = null) => queryFirst(store, range, 'next')\n\n/**\n * @typedef KeyValuePair\n * @type {Object}\n * @property {any} k key\n * @property {any} v Value\n */\n\n/**\n * @param {IDBObjectStore} store\n * @param {IDBKeyRange} [range]\n * @param {number} [limit]\n * @return {Promise<Array<KeyValuePair>>}\n */\nexport const getAllKeysValues = (store, range, limit) =>\n  // @ts-ignore\n  promise.all([getAllKeys(store, range, limit), getAll(store, range, limit)]).then(([ks, vs]) => ks.map((k, i) => ({ k, v: vs[i] })))\n\n/**\n * @param {any} request\n * @param {function(IDBCursorWithValue):void|boolean|Promise<void|boolean>} f\n * @return {Promise<void>}\n */\nconst iterateOnRequest = (request, f) => promise.create((resolve, reject) => {\n  request.onerror = reject\n  /**\n   * @param {any} event\n   */\n  request.onsuccess = async event => {\n    const cursor = event.target.result\n    if (cursor === null || (await f(cursor)) === false) {\n      return resolve()\n    }\n    cursor.continue()\n  }\n})\n\n/**\n * Iterate on keys and values\n * @param {IDBObjectStore} store\n * @param {IDBKeyRange|null} keyrange\n * @param {function(any,any):void|boolean|Promise<void|boolean>} f Callback that receives (value, key)\n * @param {'next'|'prev'|'nextunique'|'prevunique'} direction\n */\nexport const iterate = (store, keyrange, f, direction = 'next') =>\n  iterateOnRequest(store.openCursor(keyrange, direction), cursor => f(cursor.value, cursor.key))\n\n/**\n * Iterate on the keys (no values)\n *\n * @param {IDBObjectStore} store\n * @param {IDBKeyRange|null} keyrange\n * @param {function(any):void|boolean|Promise<void|boolean>} f callback that receives the key\n * @param {'next'|'prev'|'nextunique'|'prevunique'} direction\n */\nexport const iterateKeys = (store, keyrange, f, direction = 'next') =>\n  iterateOnRequest(store.openKeyCursor(keyrange, direction), cursor => f(cursor.key))\n\n/**\n * Open store from transaction\n * @param {IDBTransaction} t\n * @param {String} store\n * @returns {IDBObjectStore}\n */\nexport const getStore = (t, store) => t.objectStore(store)\n\n/**\n * @param {any} lower\n * @param {any} upper\n * @param {boolean} lowerOpen\n * @param {boolean} upperOpen\n */\nexport const createIDBKeyRangeBound = (lower, upper, lowerOpen, upperOpen) => IDBKeyRange.bound(lower, upper, lowerOpen, upperOpen)\n\n/**\n * @param {any} upper\n * @param {boolean} upperOpen\n */\nexport const createIDBKeyRangeUpperBound = (upper, upperOpen) => IDBKeyRange.upperBound(upper, upperOpen)\n\n/**\n * @param {any} lower\n * @param {boolean} lowerOpen\n */\nexport const createIDBKeyRangeLowerBound = (lower, lowerOpen) => IDBKeyRange.lowerBound(lower, lowerOpen)\n\n/* c8 ignore stop */\n","import * as Y from 'yjs'\nimport * as idb from 'lib0/indexeddb'\nimport * as promise from 'lib0/promise'\nimport { Observable } from 'lib0/observable'\n\nconst customStoreName = 'custom'\nconst updatesStoreName = 'updates'\n\nexport const PREFERRED_TRIM_SIZE = 500\n\n/**\n * @param {IndexeddbPersistence} idbPersistence\n * @param {function(IDBObjectStore):void} [beforeApplyUpdatesCallback]\n * @param {function(IDBObjectStore):void} [afterApplyUpdatesCallback]\n */\nexport const fetchUpdates = (idbPersistence, beforeApplyUpdatesCallback = () => {}, afterApplyUpdatesCallback = () => {}) => {\n  const [updatesStore] = idb.transact(/** @type {IDBDatabase} */ (idbPersistence.db), [updatesStoreName]) // , 'readonly')\n  return idb.getAll(updatesStore, idb.createIDBKeyRangeLowerBound(idbPersistence._dbref, false)).then(updates => {\n    if (!idbPersistence._destroyed) {\n      beforeApplyUpdatesCallback(updatesStore)\n      Y.transact(idbPersistence.doc, () => {\n        updates.forEach(val => Y.applyUpdate(idbPersistence.doc, val))\n      }, idbPersistence, false)\n      afterApplyUpdatesCallback(updatesStore)\n    }\n  })\n    .then(() => idb.getLastKey(updatesStore).then(lastKey => { idbPersistence._dbref = lastKey + 1 }))\n    .then(() => idb.count(updatesStore).then(cnt => { idbPersistence._dbsize = cnt }))\n    .then(() => updatesStore)\n}\n\n/**\n * @param {IndexeddbPersistence} idbPersistence\n * @param {boolean} forceStore\n */\nexport const storeState = (idbPersistence, forceStore = true) =>\n  fetchUpdates(idbPersistence)\n    .then(updatesStore => {\n      if (forceStore || idbPersistence._dbsize >= PREFERRED_TRIM_SIZE) {\n        idb.addAutoKey(updatesStore, Y.encodeStateAsUpdate(idbPersistence.doc))\n          .then(() => idb.del(updatesStore, idb.createIDBKeyRangeUpperBound(idbPersistence._dbref, true)))\n          .then(() => idb.count(updatesStore).then(cnt => { idbPersistence._dbsize = cnt }))\n      }\n    })\n\n/**\n * @param {string} name\n */\nexport const clearDocument = name => idb.deleteDB(name)\n\n/**\n * @extends Observable<string>\n */\nexport class IndexeddbPersistence extends Observable {\n  /**\n   * @param {string} name\n   * @param {Y.Doc} doc\n   */\n  constructor (name, doc) {\n    super()\n    this.doc = doc\n    this.name = name\n    this._dbref = 0\n    this._dbsize = 0\n    this._destroyed = false\n    /**\n     * @type {IDBDatabase|null}\n     */\n    this.db = null\n    this.synced = false\n    this._db = idb.openDB(name, db =>\n      idb.createStores(db, [\n        ['updates', { autoIncrement: true }],\n        ['custom']\n      ])\n    )\n    /**\n     * @type {Promise<IndexeddbPersistence>}\n     */\n    this.whenSynced = promise.create(resolve => this.on('synced', () => resolve(this)))\n\n    this._db.then(db => {\n      this.db = db\n      /**\n       * @param {IDBObjectStore} updatesStore\n       */\n      const beforeApplyUpdatesCallback = (updatesStore) => idb.addAutoKey(updatesStore, Y.encodeStateAsUpdate(doc))\n      const afterApplyUpdatesCallback = () => {\n        if (this._destroyed) return this\n        this.synced = true\n        this.emit('synced', [this])\n      }\n      fetchUpdates(this, beforeApplyUpdatesCallback, afterApplyUpdatesCallback)\n    })\n    /**\n     * Timeout in ms untill data is merged and persisted in idb.\n     */\n    this._storeTimeout = 1000\n    /**\n     * @type {any}\n     */\n    this._storeTimeoutId = null\n    /**\n     * @param {Uint8Array} update\n     * @param {any} origin\n     */\n    this._storeUpdate = (update, origin) => {\n      if (this.db && origin !== this) {\n        const [updatesStore] = idb.transact(/** @type {IDBDatabase} */ (this.db), [updatesStoreName])\n        idb.addAutoKey(updatesStore, update)\n        if (++this._dbsize >= PREFERRED_TRIM_SIZE) {\n          // debounce store call\n          if (this._storeTimeoutId !== null) {\n            clearTimeout(this._storeTimeoutId)\n          }\n          this._storeTimeoutId = setTimeout(() => {\n            storeState(this, false)\n            this._storeTimeoutId = null\n          }, this._storeTimeout)\n        }\n      }\n    }\n    doc.on('update', this._storeUpdate)\n    this.destroy = this.destroy.bind(this)\n    doc.on('destroy', this.destroy)\n  }\n\n  destroy () {\n    if (this._storeTimeoutId) {\n      clearTimeout(this._storeTimeoutId)\n    }\n    this.doc.off('update', this._storeUpdate)\n    this.doc.off('destroy', this.destroy)\n    this._destroyed = true\n    return this._db.then(db => {\n      db.close()\n    })\n  }\n\n  /**\n   * Destroys this instance and removes all data from indexeddb.\n   *\n   * @return {Promise<void>}\n   */\n  clearData () {\n    return this.destroy().then(() => {\n      idb.deleteDB(this.name)\n    })\n  }\n\n  /**\n   * @param {String | number | ArrayBuffer | Date} key\n   * @return {Promise<String | number | ArrayBuffer | Date | any>}\n   */\n  get (key) {\n    return this._db.then(db => {\n      const [custom] = idb.transact(db, [customStoreName], 'readonly')\n      return idb.get(custom, key)\n    })\n  }\n\n  /**\n   * @param {String | number | ArrayBuffer | Date} key\n   * @param {String | number | ArrayBuffer | Date} value\n   * @return {Promise<String | number | ArrayBuffer | Date>}\n   */\n  set (key, value) {\n    return this._db.then(db => {\n      const [custom] = idb.transact(db, [customStoreName])\n      return idb.put(custom, value, key)\n    })\n  }\n\n  /**\n   * @param {String | number | ArrayBuffer | Date} key\n   * @return {Promise<undefined>}\n   */\n  del (key) {\n    return this._db.then(db => {\n      const [custom] = idb.transact(db, [customStoreName])\n      return idb.del(custom, key)\n    })\n  }\n}\n","/**\n * External dependencies\n */\n// @ts-ignore\nimport { IndexeddbPersistence } from 'y-indexeddb';\n\n/** @typedef {import('./types').ObjectType} ObjectType */\n/** @typedef {import('./types').ObjectID} ObjectID */\n/** @typedef {import('./types').CRDTDoc} CRDTDoc */\n/** @typedef {import('./types').ConnectDoc} ConnectDoc */\n/** @typedef {import('./types').SyncProvider} SyncProvider */\n\n/**\n * Connect function to the IndexedDB persistence provider.\n *\n * @param {ObjectID}   objectId   The object ID.\n * @param {ObjectType} objectType The object type.\n * @param {CRDTDoc}    doc        The CRDT document.\n *\n * @return {Promise<() => void>} Promise that resolves when the connection is established.\n */\nexport function connectIndexDb( objectId, objectType, doc ) {\n\tconst roomName = `${ objectType }-${ objectId }`;\n\tconst provider = new IndexeddbPersistence( roomName, doc );\n\n\treturn new Promise( ( resolve ) => {\n\t\tprovider.on( 'synced', () => {\n\t\t\tresolve( () => provider.destroy() );\n\t\t} );\n\t} );\n}\n","/* eslint-env browser */\n\n/**\n * Tiny websocket connection handler.\n *\n * Implements exponential backoff reconnects, ping/pong, and a nice event system using [lib0/observable].\n *\n * @module websocket\n */\n\nimport { Observable } from './observable.js'\nimport * as time from './time.js'\nimport * as math from './math.js'\n\nconst reconnectTimeoutBase = 1200\nconst maxReconnectTimeout = 2500\n// @todo - this should depend on awareness.outdatedTime\nconst messageReconnectTimeout = 30000\n\n/**\n * @param {WebsocketClient} wsclient\n */\nconst setupWS = (wsclient) => {\n  if (wsclient.shouldConnect && wsclient.ws === null) {\n    const websocket = new WebSocket(wsclient.url)\n    const binaryType = wsclient.binaryType\n    /**\n     * @type {any}\n     */\n    let pingTimeout = null\n    if (binaryType) {\n      websocket.binaryType = binaryType\n    }\n    wsclient.ws = websocket\n    wsclient.connecting = true\n    wsclient.connected = false\n    websocket.onmessage = event => {\n      wsclient.lastMessageReceived = time.getUnixTime()\n      const data = event.data\n      const message = typeof data === 'string' ? JSON.parse(data) : data\n      if (message && message.type === 'pong') {\n        clearTimeout(pingTimeout)\n        pingTimeout = setTimeout(sendPing, messageReconnectTimeout / 2)\n      }\n      wsclient.emit('message', [message, wsclient])\n    }\n    /**\n     * @param {any} error\n     */\n    const onclose = error => {\n      if (wsclient.ws !== null) {\n        wsclient.ws = null\n        wsclient.connecting = false\n        if (wsclient.connected) {\n          wsclient.connected = false\n          wsclient.emit('disconnect', [{ type: 'disconnect', error }, wsclient])\n        } else {\n          wsclient.unsuccessfulReconnects++\n        }\n        // Start with no reconnect timeout and increase timeout by\n        // log10(wsUnsuccessfulReconnects).\n        // The idea is to increase reconnect timeout slowly and have no reconnect\n        // timeout at the beginning (log(1) = 0)\n        setTimeout(setupWS, math.min(math.log10(wsclient.unsuccessfulReconnects + 1) * reconnectTimeoutBase, maxReconnectTimeout), wsclient)\n      }\n      clearTimeout(pingTimeout)\n    }\n    const sendPing = () => {\n      if (wsclient.ws === websocket) {\n        wsclient.send({\n          type: 'ping'\n        })\n      }\n    }\n    websocket.onclose = () => onclose(null)\n    websocket.onerror = error => onclose(error)\n    websocket.onopen = () => {\n      wsclient.lastMessageReceived = time.getUnixTime()\n      wsclient.connecting = false\n      wsclient.connected = true\n      wsclient.unsuccessfulReconnects = 0\n      wsclient.emit('connect', [{ type: 'connect' }, wsclient])\n      // set ping\n      pingTimeout = setTimeout(sendPing, messageReconnectTimeout / 2)\n    }\n  }\n}\n\n/**\n * @extends Observable<string>\n */\nexport class WebsocketClient extends Observable {\n  /**\n   * @param {string} url\n   * @param {object} opts\n   * @param {'arraybuffer' | 'blob' | null} [opts.binaryType] Set `ws.binaryType`\n   */\n  constructor (url, { binaryType } = {}) {\n    super()\n    this.url = url\n    /**\n     * @type {WebSocket?}\n     */\n    this.ws = null\n    this.binaryType = binaryType || null\n    this.connected = false\n    this.connecting = false\n    this.unsuccessfulReconnects = 0\n    this.lastMessageReceived = 0\n    /**\n     * Whether to connect to other peers or not\n     * @type {boolean}\n     */\n    this.shouldConnect = true\n    this._checkInterval = setInterval(() => {\n      if (this.connected && messageReconnectTimeout < time.getUnixTime() - this.lastMessageReceived) {\n        // no message received in a long time - not even your own awareness\n        // updates (which are updated every 15 seconds)\n        /** @type {WebSocket} */ (this.ws).close()\n      }\n    }, messageReconnectTimeout / 2)\n    setupWS(this)\n  }\n\n  /**\n   * @param {any} message\n   */\n  send (message) {\n    if (this.ws) {\n      this.ws.send(JSON.stringify(message))\n    }\n  }\n\n  destroy () {\n    clearInterval(this._checkInterval)\n    this.disconnect()\n    super.destroy()\n  }\n\n  disconnect () {\n    this.shouldConnect = false\n    if (this.ws !== null) {\n      this.ws.close()\n    }\n  }\n\n  connect () {\n    this.shouldConnect = true\n    if (!this.connected && this.ws === null) {\n      setupWS(this)\n    }\n  }\n}\n","/* eslint-env browser */\n\n/**\n * Helpers for cross-tab communication using broadcastchannel with LocalStorage fallback.\n *\n * ```js\n * // In browser window A:\n * broadcastchannel.subscribe('my events', data => console.log(data))\n * broadcastchannel.publish('my events', 'Hello world!') // => A: 'Hello world!' fires synchronously in same tab\n *\n * // In browser window B:\n * broadcastchannel.publish('my events', 'hello from tab B') // => A: 'hello from tab B'\n * ```\n *\n * @module broadcastchannel\n */\n\n// @todo before next major: use Uint8Array instead as buffer object\n\nimport * as map from './map.js'\nimport * as set from './set.js'\nimport * as buffer from './buffer.js'\nimport * as storage from './storage.js'\n\n/**\n * @typedef {Object} Channel\n * @property {Set<function(any, any):any>} Channel.subs\n * @property {any} Channel.bc\n */\n\n/**\n * @type {Map<string, Channel>}\n */\nconst channels = new Map()\n\n/* c8 ignore start */\nclass LocalStoragePolyfill {\n  /**\n   * @param {string} room\n   */\n  constructor (room) {\n    this.room = room\n    /**\n     * @type {null|function({data:ArrayBuffer}):void}\n     */\n    this.onmessage = null\n    /**\n     * @param {any} e\n     */\n    this._onChange = e => e.key === room && this.onmessage !== null && this.onmessage({ data: buffer.fromBase64(e.newValue || '') })\n    storage.onChange(this._onChange)\n  }\n\n  /**\n   * @param {ArrayBuffer} buf\n   */\n  postMessage (buf) {\n    storage.varStorage.setItem(this.room, buffer.toBase64(buffer.createUint8ArrayFromArrayBuffer(buf)))\n  }\n\n  close () {\n    storage.offChange(this._onChange)\n  }\n}\n/* c8 ignore stop */\n\n// Use BroadcastChannel or Polyfill\n/* c8 ignore next */\nconst BC = typeof BroadcastChannel === 'undefined' ? LocalStoragePolyfill : BroadcastChannel\n\n/**\n * @param {string} room\n * @return {Channel}\n */\nconst getChannel = room =>\n  map.setIfUndefined(channels, room, () => {\n    const subs = set.create()\n    const bc = new BC(room)\n    /**\n     * @param {{data:ArrayBuffer}} e\n     */\n    /* c8 ignore next */\n    bc.onmessage = e => subs.forEach(sub => sub(e.data, 'broadcastchannel'))\n    return {\n      bc, subs\n    }\n  })\n\n/**\n * Subscribe to global `publish` events.\n *\n * @function\n * @param {string} room\n * @param {function(any, any):any} f\n */\nexport const subscribe = (room, f) => {\n  getChannel(room).subs.add(f)\n  return f\n}\n\n/**\n * Unsubscribe from `publish` global events.\n *\n * @function\n * @param {string} room\n * @param {function(any, any):any} f\n */\nexport const unsubscribe = (room, f) => {\n  const channel = getChannel(room)\n  const unsubscribed = channel.subs.delete(f)\n  if (unsubscribed && channel.subs.size === 0) {\n    channel.bc.close()\n    channels.delete(room)\n  }\n  return unsubscribed\n}\n\n/**\n * Publish data to all subscribers (including subscribers on this tab)\n *\n * @function\n * @param {string} room\n * @param {any} data\n * @param {any} [origin]\n */\nexport const publish = (room, data, origin = null) => {\n  const c = getChannel(room)\n  c.bc.postMessage(data)\n  c.subs.forEach(sub => sub(data, origin))\n}\n","/**\n * @module sync-protocol\n */\n\nimport * as encoding from 'lib0/encoding'\nimport * as decoding from 'lib0/decoding'\nimport * as Y from 'yjs'\n\n/**\n * @typedef {Map<number, number>} StateMap\n */\n\n/**\n * Core Yjs defines two message types:\n * • YjsSyncStep1: Includes the State Set of the sending client. When received, the client should reply with YjsSyncStep2.\n * • YjsSyncStep2: Includes all missing structs and the complete delete set. When received, the client is assured that it\n *   received all information from the remote client.\n *\n * In a peer-to-peer network, you may want to introduce a SyncDone message type. Both parties should initiate the connection\n * with SyncStep1. When a client received SyncStep2, it should reply with SyncDone. When the local client received both\n * SyncStep2 and SyncDone, it is assured that it is synced to the remote client.\n *\n * In a client-server model, you want to handle this differently: The client should initiate the connection with SyncStep1.\n * When the server receives SyncStep1, it should reply with SyncStep2 immediately followed by SyncStep1. The client replies\n * with SyncStep2 when it receives SyncStep1. Optionally the server may send a SyncDone after it received SyncStep2, so the\n * client knows that the sync is finished.  There are two reasons for this more elaborated sync model: 1. This protocol can\n * easily be implemented on top of http and websockets. 2. The server shoul only reply to requests, and not initiate them.\n * Therefore it is necesarry that the client initiates the sync.\n *\n * Construction of a message:\n * [messageType : varUint, message definition..]\n *\n * Note: A message does not include information about the room name. This must to be handled by the upper layer protocol!\n *\n * stringify[messageType] stringifies a message definition (messageType is already read from the bufffer)\n */\n\nexport const messageYjsSyncStep1 = 0\nexport const messageYjsSyncStep2 = 1\nexport const messageYjsUpdate = 2\n\n/**\n * Create a sync step 1 message based on the state of the current shared document.\n *\n * @param {encoding.Encoder} encoder\n * @param {Y.Doc} doc\n */\nexport const writeSyncStep1 = (encoder, doc) => {\n  encoding.writeVarUint(encoder, messageYjsSyncStep1)\n  const sv = Y.encodeStateVector(doc)\n  encoding.writeVarUint8Array(encoder, sv)\n}\n\n/**\n * @param {encoding.Encoder} encoder\n * @param {Y.Doc} doc\n * @param {Uint8Array} [encodedStateVector]\n */\nexport const writeSyncStep2 = (encoder, doc, encodedStateVector) => {\n  encoding.writeVarUint(encoder, messageYjsSyncStep2)\n  encoding.writeVarUint8Array(encoder, Y.encodeStateAsUpdate(doc, encodedStateVector))\n}\n\n/**\n * Read SyncStep1 message and reply with SyncStep2.\n *\n * @param {decoding.Decoder} decoder The reply to the received message\n * @param {encoding.Encoder} encoder The received message\n * @param {Y.Doc} doc\n */\nexport const readSyncStep1 = (decoder, encoder, doc) =>\n  writeSyncStep2(encoder, doc, decoding.readVarUint8Array(decoder))\n\n/**\n * Read and apply Structs and then DeleteStore to a y instance.\n *\n * @param {decoding.Decoder} decoder\n * @param {Y.Doc} doc\n * @param {any} transactionOrigin\n */\nexport const readSyncStep2 = (decoder, doc, transactionOrigin) => {\n  try {\n    Y.applyUpdate(doc, decoding.readVarUint8Array(decoder), transactionOrigin)\n  } catch (error) {\n    // This catches errors that are thrown by event handlers\n    console.error('Caught error while handling a Yjs update', error)\n  }\n}\n\n/**\n * @param {encoding.Encoder} encoder\n * @param {Uint8Array} update\n */\nexport const writeUpdate = (encoder, update) => {\n  encoding.writeVarUint(encoder, messageYjsUpdate)\n  encoding.writeVarUint8Array(encoder, update)\n}\n\n/**\n * Read and apply Structs and then DeleteStore to a y instance.\n *\n * @param {decoding.Decoder} decoder\n * @param {Y.Doc} doc\n * @param {any} transactionOrigin\n */\nexport const readUpdate = readSyncStep2\n\n/**\n * @param {decoding.Decoder} decoder A message received from another client\n * @param {encoding.Encoder} encoder The reply message. Will not be sent if empty.\n * @param {Y.Doc} doc\n * @param {any} transactionOrigin\n */\nexport const readSyncMessage = (decoder, encoder, doc, transactionOrigin) => {\n  const messageType = decoding.readVarUint(decoder)\n  switch (messageType) {\n    case messageYjsSyncStep1:\n      readSyncStep1(decoder, encoder, doc)\n      break\n    case messageYjsSyncStep2:\n      readSyncStep2(decoder, doc, transactionOrigin)\n      break\n    case messageYjsUpdate:\n      readUpdate(decoder, doc, transactionOrigin)\n      break\n    default:\n      throw new Error('Unknown message type')\n  }\n  return messageType\n}\n","/**\n * @module awareness-protocol\n */\n\nimport * as encoding from 'lib0/encoding'\nimport * as decoding from 'lib0/decoding'\nimport * as time from 'lib0/time'\nimport * as math from 'lib0/math'\nimport { Observable } from 'lib0/observable'\nimport * as f from 'lib0/function'\nimport * as Y from 'yjs' // eslint-disable-line\n\nexport const outdatedTimeout = 30000\n\n/**\n * @typedef {Object} MetaClientState\n * @property {number} MetaClientState.clock\n * @property {number} MetaClientState.lastUpdated unix timestamp\n */\n\n/**\n * The Awareness class implements a simple shared state protocol that can be used for non-persistent data like awareness information\n * (cursor, username, status, ..). Each client can update its own local state and listen to state changes of\n * remote clients. Every client may set a state of a remote peer to `null` to mark the client as offline.\n *\n * Each client is identified by a unique client id (something we borrow from `doc.clientID`). A client can override\n * its own state by propagating a message with an increasing timestamp (`clock`). If such a message is received, it is\n * applied if the known state of that client is older than the new state (`clock < newClock`). If a client thinks that\n * a remote client is offline, it may propagate a message with\n * `{ clock: currentClientClock, state: null, client: remoteClient }`. If such a\n * message is received, and the known clock of that client equals the received clock, it will override the state with `null`.\n *\n * Before a client disconnects, it should propagate a `null` state with an updated clock.\n *\n * Awareness states must be updated every 30 seconds. Otherwise the Awareness instance will delete the client state.\n *\n * @extends {Observable<string>}\n */\nexport class Awareness extends Observable {\n  /**\n   * @param {Y.Doc} doc\n   */\n  constructor (doc) {\n    super()\n    this.doc = doc\n    /**\n     * @type {number}\n     */\n    this.clientID = doc.clientID\n    /**\n     * Maps from client id to client state\n     * @type {Map<number, Object<string, any>>}\n     */\n    this.states = new Map()\n    /**\n     * @type {Map<number, MetaClientState>}\n     */\n    this.meta = new Map()\n    this._checkInterval = /** @type {any} */ (setInterval(() => {\n      const now = time.getUnixTime()\n      if (this.getLocalState() !== null && (outdatedTimeout / 2 <= now - /** @type {{lastUpdated:number}} */ (this.meta.get(this.clientID)).lastUpdated)) {\n        // renew local clock\n        this.setLocalState(this.getLocalState())\n      }\n      /**\n       * @type {Array<number>}\n       */\n      const remove = []\n      this.meta.forEach((meta, clientid) => {\n        if (clientid !== this.clientID && outdatedTimeout <= now - meta.lastUpdated && this.states.has(clientid)) {\n          remove.push(clientid)\n        }\n      })\n      if (remove.length > 0) {\n        removeAwarenessStates(this, remove, 'timeout')\n      }\n    }, math.floor(outdatedTimeout / 10)))\n    doc.on('destroy', () => {\n      this.destroy()\n    })\n    this.setLocalState({})\n  }\n\n  destroy () {\n    this.emit('destroy', [this])\n    this.setLocalState(null)\n    super.destroy()\n    clearInterval(this._checkInterval)\n  }\n\n  /**\n   * @return {Object<string,any>|null}\n   */\n  getLocalState () {\n    return this.states.get(this.clientID) || null\n  }\n\n  /**\n   * @param {Object<string,any>|null} state\n   */\n  setLocalState (state) {\n    const clientID = this.clientID\n    const currLocalMeta = this.meta.get(clientID)\n    const clock = currLocalMeta === undefined ? 0 : currLocalMeta.clock + 1\n    const prevState = this.states.get(clientID)\n    if (state === null) {\n      this.states.delete(clientID)\n    } else {\n      this.states.set(clientID, state)\n    }\n    this.meta.set(clientID, {\n      clock,\n      lastUpdated: time.getUnixTime()\n    })\n    const added = []\n    const updated = []\n    const filteredUpdated = []\n    const removed = []\n    if (state === null) {\n      removed.push(clientID)\n    } else if (prevState == null) {\n      if (state != null) {\n        added.push(clientID)\n      }\n    } else {\n      updated.push(clientID)\n      if (!f.equalityDeep(prevState, state)) {\n        filteredUpdated.push(clientID)\n      }\n    }\n    if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {\n      this.emit('change', [{ added, updated: filteredUpdated, removed }, 'local'])\n    }\n    this.emit('update', [{ added, updated, removed }, 'local'])\n  }\n\n  /**\n   * @param {string} field\n   * @param {any} value\n   */\n  setLocalStateField (field, value) {\n    const state = this.getLocalState()\n    if (state !== null) {\n      this.setLocalState({\n        ...state,\n        [field]: value\n      })\n    }\n  }\n\n  /**\n   * @return {Map<number,Object<string,any>>}\n   */\n  getStates () {\n    return this.states\n  }\n}\n\n/**\n * Mark (remote) clients as inactive and remove them from the list of active peers.\n * This change will be propagated to remote clients.\n *\n * @param {Awareness} awareness\n * @param {Array<number>} clients\n * @param {any} origin\n */\nexport const removeAwarenessStates = (awareness, clients, origin) => {\n  const removed = []\n  for (let i = 0; i < clients.length; i++) {\n    const clientID = clients[i]\n    if (awareness.states.has(clientID)) {\n      awareness.states.delete(clientID)\n      if (clientID === awareness.clientID) {\n        const curMeta = /** @type {MetaClientState} */ (awareness.meta.get(clientID))\n        awareness.meta.set(clientID, {\n          clock: curMeta.clock + 1,\n          lastUpdated: time.getUnixTime()\n        })\n      }\n      removed.push(clientID)\n    }\n  }\n  if (removed.length > 0) {\n    awareness.emit('change', [{ added: [], updated: [], removed }, origin])\n    awareness.emit('update', [{ added: [], updated: [], removed }, origin])\n  }\n}\n\n/**\n * @param {Awareness} awareness\n * @param {Array<number>} clients\n * @return {Uint8Array}\n */\nexport const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => {\n  const len = clients.length\n  const encoder = encoding.createEncoder()\n  encoding.writeVarUint(encoder, len)\n  for (let i = 0; i < len; i++) {\n    const clientID = clients[i]\n    const state = states.get(clientID) || null\n    const clock = /** @type {MetaClientState} */ (awareness.meta.get(clientID)).clock\n    encoding.writeVarUint(encoder, clientID)\n    encoding.writeVarUint(encoder, clock)\n    encoding.writeVarString(encoder, JSON.stringify(state))\n  }\n  return encoding.toUint8Array(encoder)\n}\n\n/**\n * Modify the content of an awareness update before re-encoding it to an awareness update.\n *\n * This might be useful when you have a central server that wants to ensure that clients\n * cant hijack somebody elses identity.\n *\n * @param {Uint8Array} update\n * @param {function(any):any} modify\n * @return {Uint8Array}\n */\nexport const modifyAwarenessUpdate = (update, modify) => {\n  const decoder = decoding.createDecoder(update)\n  const encoder = encoding.createEncoder()\n  const len = decoding.readVarUint(decoder)\n  encoding.writeVarUint(encoder, len)\n  for (let i = 0; i < len; i++) {\n    const clientID = decoding.readVarUint(decoder)\n    const clock = decoding.readVarUint(decoder)\n    const state = JSON.parse(decoding.readVarString(decoder))\n    const modifiedState = modify(state)\n    encoding.writeVarUint(encoder, clientID)\n    encoding.writeVarUint(encoder, clock)\n    encoding.writeVarString(encoder, JSON.stringify(modifiedState))\n  }\n  return encoding.toUint8Array(encoder)\n}\n\n/**\n * @param {Awareness} awareness\n * @param {Uint8Array} update\n * @param {any} origin This will be added to the emitted change event\n */\nexport const applyAwarenessUpdate = (awareness, update, origin) => {\n  const decoder = decoding.createDecoder(update)\n  const timestamp = time.getUnixTime()\n  const added = []\n  const updated = []\n  const filteredUpdated = []\n  const removed = []\n  const len = decoding.readVarUint(decoder)\n  for (let i = 0; i < len; i++) {\n    const clientID = decoding.readVarUint(decoder)\n    let clock = decoding.readVarUint(decoder)\n    const state = JSON.parse(decoding.readVarString(decoder))\n    const clientMeta = awareness.meta.get(clientID)\n    const prevState = awareness.states.get(clientID)\n    const currClock = clientMeta === undefined ? 0 : clientMeta.clock\n    if (currClock < clock || (currClock === clock && state === null && awareness.states.has(clientID))) {\n      if (state === null) {\n        // never let a remote client remove this local state\n        if (clientID === awareness.clientID && awareness.getLocalState() != null) {\n          // remote client removed the local state. Do not remote state. Broadcast a message indicating\n          // that this client still exists by increasing the clock\n          clock++\n        } else {\n          awareness.states.delete(clientID)\n        }\n      } else {\n        awareness.states.set(clientID, state)\n      }\n      awareness.meta.set(clientID, {\n        clock,\n        lastUpdated: timestamp\n      })\n      if (clientMeta === undefined && state !== null) {\n        added.push(clientID)\n      } else if (clientMeta !== undefined && state === null) {\n        removed.push(clientID)\n      } else if (state !== null) {\n        if (!f.equalityDeep(state, prevState)) {\n          filteredUpdated.push(clientID)\n        }\n        updated.push(clientID)\n      }\n    }\n  }\n  if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {\n    awareness.emit('change', [{\n      added, updated: filteredUpdated, removed\n    }, origin])\n  }\n  if (added.length > 0 || updated.length > 0 || removed.length > 0) {\n    awareness.emit('update', [{\n      added, updated, removed\n    }, origin])\n  }\n}\n","// File copied as is from the y-webrtc package.\n/* eslint-disable eslint-comments/disable-enable-pair */\n/* eslint-disable eslint-comments/no-unlimited-disable */\n/* eslint-disable */\n// @ts-nocheck\n/* eslint-env browser */\n\nimport * as encoding from 'lib0/encoding';\nimport * as decoding from 'lib0/decoding';\nimport * as promise from 'lib0/promise';\nimport * as error from 'lib0/error';\nimport * as string from 'lib0/string';\n\n/**\n * @param {string} secret\n * @param {string} roomName\n * @return {PromiseLike<CryptoKey>}\n */\nexport const deriveKey = ( secret, roomName ) => {\n\tconst secretBuffer = string.encodeUtf8( secret ).buffer;\n\tconst salt = string.encodeUtf8( roomName ).buffer;\n\treturn crypto.subtle\n\t\t.importKey( 'raw', secretBuffer, 'PBKDF2', false, [ 'deriveKey' ] )\n\t\t.then( ( keyMaterial ) =>\n\t\t\tcrypto.subtle.deriveKey(\n\t\t\t\t{\n\t\t\t\t\tname: 'PBKDF2',\n\t\t\t\t\tsalt,\n\t\t\t\t\titerations: 100000,\n\t\t\t\t\thash: 'SHA-256',\n\t\t\t\t},\n\t\t\t\tkeyMaterial,\n\t\t\t\t{\n\t\t\t\t\tname: 'AES-GCM',\n\t\t\t\t\tlength: 256,\n\t\t\t\t},\n\t\t\t\ttrue,\n\t\t\t\t[ 'encrypt', 'decrypt' ]\n\t\t\t)\n\t\t);\n};\n\n/**\n * @param {Uint8Array} data data to be encrypted\n * @param {CryptoKey?} key\n * @return {PromiseLike<Uint8Array>} encrypted, base64 encoded message\n */\nexport const encrypt = ( data, key ) => {\n\tif ( ! key ) {\n\t\treturn /** @type {PromiseLike<Uint8Array>} */ (\n\t\t\tpromise.resolve( data )\n\t\t);\n\t}\n\tconst iv = crypto.getRandomValues( new Uint8Array( 12 ) );\n\treturn crypto.subtle\n\t\t.encrypt(\n\t\t\t{\n\t\t\t\tname: 'AES-GCM',\n\t\t\t\tiv,\n\t\t\t},\n\t\t\tkey,\n\t\t\tdata\n\t\t)\n\t\t.then( ( cipher ) => {\n\t\t\tconst encryptedDataEncoder = encoding.createEncoder();\n\t\t\tencoding.writeVarString( encryptedDataEncoder, 'AES-GCM' );\n\t\t\tencoding.writeVarUint8Array( encryptedDataEncoder, iv );\n\t\t\tencoding.writeVarUint8Array(\n\t\t\t\tencryptedDataEncoder,\n\t\t\t\tnew Uint8Array( cipher )\n\t\t\t);\n\t\t\treturn encoding.toUint8Array( encryptedDataEncoder );\n\t\t} );\n};\n\n/**\n * @param {Object} data data to be encrypted\n * @param {CryptoKey?} key\n * @return {PromiseLike<Uint8Array>} encrypted data, if key is provided\n */\nexport const encryptJson = ( data, key ) => {\n\tconst dataEncoder = encoding.createEncoder();\n\tencoding.writeAny( dataEncoder, data );\n\treturn encrypt( encoding.toUint8Array( dataEncoder ), key );\n};\n\n/**\n * @param {Uint8Array} data\n * @param {CryptoKey?} key\n * @return {PromiseLike<Uint8Array>} decrypted buffer\n */\nexport const decrypt = ( data, key ) => {\n\tif ( ! key ) {\n\t\treturn /** @type {PromiseLike<Uint8Array>} */ (\n\t\t\tpromise.resolve( data )\n\t\t);\n\t}\n\tconst dataDecoder = decoding.createDecoder( data );\n\tconst algorithm = decoding.readVarString( dataDecoder );\n\tif ( algorithm !== 'AES-GCM' ) {\n\t\tpromise.reject( error.create( 'Unknown encryption algorithm' ) );\n\t}\n\tconst iv = decoding.readVarUint8Array( dataDecoder );\n\tconst cipher = decoding.readVarUint8Array( dataDecoder );\n\treturn crypto.subtle\n\t\t.decrypt(\n\t\t\t{\n\t\t\t\tname: 'AES-GCM',\n\t\t\t\tiv,\n\t\t\t},\n\t\t\tkey,\n\t\t\tcipher\n\t\t)\n\t\t.then( ( data ) => new Uint8Array( data ) );\n};\n\n/**\n * @param {Uint8Array} data\n * @param {CryptoKey?} key\n * @return {PromiseLike<Object>} decrypted object\n */\nexport const decryptJson = ( data, key ) =>\n\tdecrypt( data, key ).then( ( decryptedValue ) =>\n\t\tdecoding.readAny(\n\t\t\tdecoding.createDecoder( new Uint8Array( decryptedValue ) )\n\t\t)\n\t);\n","// File copied as is from the y-webrtc package with only exports\n// added to the following vars/functions: signalingConns,rooms, publishSignalingMessage, log.\n/* eslint-disable eslint-comments/disable-enable-pair */\n/* eslint-disable eslint-comments/no-unlimited-disable */\n/* eslint-disable */\n// @ts-nocheck\n\nimport * as ws from 'lib0/websocket';\nimport * as map from 'lib0/map';\nimport * as error from 'lib0/error';\nimport * as random from 'lib0/random';\nimport * as encoding from 'lib0/encoding';\nimport * as decoding from 'lib0/decoding';\nimport { Observable } from 'lib0/observable';\nimport * as logging from 'lib0/logging';\nimport * as promise from 'lib0/promise';\nimport * as bc from 'lib0/broadcastchannel';\nimport * as buffer from 'lib0/buffer';\nimport * as math from 'lib0/math';\nimport { createMutex } from 'lib0/mutex';\n\nimport * as Y from 'yjs'; // eslint-disable-line\nimport Peer from 'simple-peer/simplepeer.min.js';\n\nimport * as syncProtocol from 'y-protocols/sync';\nimport * as awarenessProtocol from 'y-protocols/awareness';\n\nimport * as cryptoutils from './crypto.js';\n\nexport const log = logging.createModuleLogger( 'y-webrtc' );\n\nconst messageSync = 0;\nconst messageQueryAwareness = 3;\nconst messageAwareness = 1;\nconst messageBcPeerId = 4;\n\n/**\n * @type {Map<string, SignalingConn>}\n */\nexport const signalingConns = new Map();\n\n/**\n * @type {Map<string,Room>}\n */\nexport const rooms = new Map();\n\n/**\n * @param {Room} room\n */\nconst checkIsSynced = ( room ) => {\n\tlet synced = true;\n\troom.webrtcConns.forEach( ( peer ) => {\n\t\tif ( ! peer.synced ) {\n\t\t\tsynced = false;\n\t\t}\n\t} );\n\tif ( ( ! synced && room.synced ) || ( synced && ! room.synced ) ) {\n\t\troom.synced = synced;\n\t\troom.provider.emit( 'synced', [ { synced } ] );\n\t\tlog(\n\t\t\t'synced ',\n\t\t\tlogging.BOLD,\n\t\t\troom.name,\n\t\t\tlogging.UNBOLD,\n\t\t\t' with all peers'\n\t\t);\n\t}\n};\n\n/**\n * @param {Room} room\n * @param {Uint8Array} buf\n * @param {function} syncedCallback\n * @return {encoding.Encoder?}\n */\nconst readMessage = ( room, buf, syncedCallback ) => {\n\tconst decoder = decoding.createDecoder( buf );\n\tconst encoder = encoding.createEncoder();\n\tconst messageType = decoding.readVarUint( decoder );\n\tif ( room === undefined ) {\n\t\treturn null;\n\t}\n\tconst awareness = room.awareness;\n\tconst doc = room.doc;\n\tlet sendReply = false;\n\tswitch ( messageType ) {\n\t\tcase messageSync: {\n\t\t\tencoding.writeVarUint( encoder, messageSync );\n\t\t\tconst syncMessageType = syncProtocol.readSyncMessage(\n\t\t\t\tdecoder,\n\t\t\t\tencoder,\n\t\t\t\tdoc,\n\t\t\t\troom\n\t\t\t);\n\t\t\tif (\n\t\t\t\tsyncMessageType === syncProtocol.messageYjsSyncStep2 &&\n\t\t\t\t! room.synced\n\t\t\t) {\n\t\t\t\tsyncedCallback();\n\t\t\t}\n\t\t\tif ( syncMessageType === syncProtocol.messageYjsSyncStep1 ) {\n\t\t\t\tsendReply = true;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\tcase messageQueryAwareness:\n\t\t\tencoding.writeVarUint( encoder, messageAwareness );\n\t\t\tencoding.writeVarUint8Array(\n\t\t\t\tencoder,\n\t\t\t\tawarenessProtocol.encodeAwarenessUpdate(\n\t\t\t\t\tawareness,\n\t\t\t\t\tArray.from( awareness.getStates().keys() )\n\t\t\t\t)\n\t\t\t);\n\t\t\tsendReply = true;\n\t\t\tbreak;\n\t\tcase messageAwareness:\n\t\t\tawarenessProtocol.applyAwarenessUpdate(\n\t\t\t\tawareness,\n\t\t\t\tdecoding.readVarUint8Array( decoder ),\n\t\t\t\troom\n\t\t\t);\n\t\t\tbreak;\n\t\tcase messageBcPeerId: {\n\t\t\tconst add = decoding.readUint8( decoder ) === 1;\n\t\t\tconst peerName = decoding.readVarString( decoder );\n\t\t\tif (\n\t\t\t\tpeerName !== room.peerId &&\n\t\t\t\t( ( room.bcConns.has( peerName ) && ! add ) ||\n\t\t\t\t\t( ! room.bcConns.has( peerName ) && add ) )\n\t\t\t) {\n\t\t\t\tconst removed = [];\n\t\t\t\tconst added = [];\n\t\t\t\tif ( add ) {\n\t\t\t\t\troom.bcConns.add( peerName );\n\t\t\t\t\tadded.push( peerName );\n\t\t\t\t} else {\n\t\t\t\t\troom.bcConns.delete( peerName );\n\t\t\t\t\tremoved.push( peerName );\n\t\t\t\t}\n\t\t\t\troom.provider.emit( 'peers', [\n\t\t\t\t\t{\n\t\t\t\t\t\tadded,\n\t\t\t\t\t\tremoved,\n\t\t\t\t\t\twebrtcPeers: Array.from( room.webrtcConns.keys() ),\n\t\t\t\t\t\tbcPeers: Array.from( room.bcConns ),\n\t\t\t\t\t},\n\t\t\t\t] );\n\t\t\t\tbroadcastBcPeerId( room );\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\tdefault:\n\t\t\tconsole.error( 'Unable to compute message' );\n\t\t\treturn encoder;\n\t}\n\tif ( ! sendReply ) {\n\t\t// nothing has been written, no answer created\n\t\treturn null;\n\t}\n\treturn encoder;\n};\n\n/**\n * @param {WebrtcConn} peerConn\n * @param {Uint8Array} buf\n * @return {encoding.Encoder?}\n */\nconst readPeerMessage = ( peerConn, buf ) => {\n\tconst room = peerConn.room;\n\tlog(\n\t\t'received message from ',\n\t\tlogging.BOLD,\n\t\tpeerConn.remotePeerId,\n\t\tlogging.GREY,\n\t\t' (',\n\t\troom.name,\n\t\t')',\n\t\tlogging.UNBOLD,\n\t\tlogging.UNCOLOR\n\t);\n\treturn readMessage( room, buf, () => {\n\t\tpeerConn.synced = true;\n\t\tlog(\n\t\t\t'synced ',\n\t\t\tlogging.BOLD,\n\t\t\troom.name,\n\t\t\tlogging.UNBOLD,\n\t\t\t' with ',\n\t\t\tlogging.BOLD,\n\t\t\tpeerConn.remotePeerId\n\t\t);\n\t\tcheckIsSynced( room );\n\t} );\n};\n\n/**\n * @param {WebrtcConn} webrtcConn\n * @param {encoding.Encoder} encoder\n */\nconst sendWebrtcConn = ( webrtcConn, encoder ) => {\n\tlog(\n\t\t'send message to ',\n\t\tlogging.BOLD,\n\t\twebrtcConn.remotePeerId,\n\t\tlogging.UNBOLD,\n\t\tlogging.GREY,\n\t\t' (',\n\t\twebrtcConn.room.name,\n\t\t')',\n\t\tlogging.UNCOLOR\n\t);\n\ttry {\n\t\twebrtcConn.peer.send( encoding.toUint8Array( encoder ) );\n\t} catch ( e ) {}\n};\n\n/**\n * @param {Room} room\n * @param {Uint8Array} m\n */\nconst broadcastWebrtcConn = ( room, m ) => {\n\tlog( 'broadcast message in ', logging.BOLD, room.name, logging.UNBOLD );\n\troom.webrtcConns.forEach( ( conn ) => {\n\t\ttry {\n\t\t\tconn.peer.send( m );\n\t\t} catch ( e ) {}\n\t} );\n};\n\nexport class WebrtcConn {\n\t/**\n\t * @param {SignalingConn} signalingConn\n\t * @param {boolean} initiator\n\t * @param {string} remotePeerId\n\t * @param {Room} room\n\t */\n\tconstructor( signalingConn, initiator, remotePeerId, room ) {\n\t\tlog( 'establishing connection to ', logging.BOLD, remotePeerId );\n\t\tthis.room = room;\n\t\tthis.remotePeerId = remotePeerId;\n\t\tthis.glareToken = undefined;\n\t\tthis.closed = false;\n\t\tthis.connected = false;\n\t\tthis.synced = false;\n\t\t/**\n\t\t * @type {any}\n\t\t */\n\t\tthis.peer = new Peer( { initiator, ...room.provider.peerOpts } );\n\t\tthis.peer.on( 'signal', ( signal ) => {\n\t\t\tif ( this.glareToken === undefined ) {\n\t\t\t\t// add some randomness to the timestamp of the offer\n\t\t\t\tthis.glareToken = Date.now() + Math.random();\n\t\t\t}\n\t\t\tpublishSignalingMessage( signalingConn, room, {\n\t\t\t\tto: remotePeerId,\n\t\t\t\tfrom: room.peerId,\n\t\t\t\ttype: 'signal',\n\t\t\t\ttoken: this.glareToken,\n\t\t\t\tsignal,\n\t\t\t} );\n\t\t} );\n\t\tthis.peer.on( 'connect', () => {\n\t\t\tlog( 'connected to ', logging.BOLD, remotePeerId );\n\t\t\tthis.connected = true;\n\t\t\t// send sync step 1\n\t\t\tconst provider = room.provider;\n\t\t\tconst doc = provider.doc;\n\t\t\tconst awareness = room.awareness;\n\t\t\tconst encoder = encoding.createEncoder();\n\t\t\tencoding.writeVarUint( encoder, messageSync );\n\t\t\tsyncProtocol.writeSyncStep1( encoder, doc );\n\t\t\tsendWebrtcConn( this, encoder );\n\t\t\tconst awarenessStates = awareness.getStates();\n\t\t\tif ( awarenessStates.size > 0 ) {\n\t\t\t\tconst encoder = encoding.createEncoder();\n\t\t\t\tencoding.writeVarUint( encoder, messageAwareness );\n\t\t\t\tencoding.writeVarUint8Array(\n\t\t\t\t\tencoder,\n\t\t\t\t\tawarenessProtocol.encodeAwarenessUpdate(\n\t\t\t\t\t\tawareness,\n\t\t\t\t\t\tArray.from( awarenessStates.keys() )\n\t\t\t\t\t)\n\t\t\t\t);\n\t\t\t\tsendWebrtcConn( this, encoder );\n\t\t\t}\n\t\t} );\n\t\tthis.peer.on( 'close', () => {\n\t\t\tthis.connected = false;\n\t\t\tthis.closed = true;\n\t\t\tif ( room.webrtcConns.has( this.remotePeerId ) ) {\n\t\t\t\troom.webrtcConns.delete( this.remotePeerId );\n\t\t\t\troom.provider.emit( 'peers', [\n\t\t\t\t\t{\n\t\t\t\t\t\tremoved: [ this.remotePeerId ],\n\t\t\t\t\t\tadded: [],\n\t\t\t\t\t\twebrtcPeers: Array.from( room.webrtcConns.keys() ),\n\t\t\t\t\t\tbcPeers: Array.from( room.bcConns ),\n\t\t\t\t\t},\n\t\t\t\t] );\n\t\t\t}\n\t\t\tcheckIsSynced( room );\n\t\t\tthis.peer.destroy();\n\t\t\tlog( 'closed connection to ', logging.BOLD, remotePeerId );\n\t\t\tannounceSignalingInfo( room );\n\t\t} );\n\t\tthis.peer.on( 'error', ( err ) => {\n\t\t\tlog(\n\t\t\t\t'Error in connection to ',\n\t\t\t\tlogging.BOLD,\n\t\t\t\tremotePeerId,\n\t\t\t\t': ',\n\t\t\t\terr\n\t\t\t);\n\t\t\tannounceSignalingInfo( room );\n\t\t} );\n\t\tthis.peer.on( 'data', ( data ) => {\n\t\t\tconst answer = readPeerMessage( this, data );\n\t\t\tif ( answer !== null ) {\n\t\t\t\tsendWebrtcConn( this, answer );\n\t\t\t}\n\t\t} );\n\t}\n\n\tdestroy() {\n\t\tthis.peer.destroy();\n\t}\n}\n\n/**\n * @param {Room} room\n * @param {Uint8Array} m\n */\nconst broadcastBcMessage = ( room, m ) =>\n\tcryptoutils\n\t\t.encrypt( m, room.key )\n\t\t.then( ( data ) => room.mux( () => bc.publish( room.name, data ) ) );\n\n/**\n * @param {Room} room\n * @param {Uint8Array} m\n */\nconst broadcastRoomMessage = ( room, m ) => {\n\tif ( room.bcconnected ) {\n\t\tbroadcastBcMessage( room, m );\n\t}\n\tbroadcastWebrtcConn( room, m );\n};\n\n/**\n * @param {Room} room\n */\nconst announceSignalingInfo = ( room ) => {\n\tsignalingConns.forEach( ( conn ) => {\n\t\t// only subscribe if connection is established, otherwise the conn automatically subscribes to all rooms\n\t\tif ( conn.connected ) {\n\t\t\tconn.send( { type: 'subscribe', topics: [ room.name ] } );\n\t\t\tif ( room.webrtcConns.size < room.provider.maxConns ) {\n\t\t\t\tpublishSignalingMessage( conn, room, {\n\t\t\t\t\ttype: 'announce',\n\t\t\t\t\tfrom: room.peerId,\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t} );\n};\n\n/**\n * @param {Room} room\n */\nconst broadcastBcPeerId = ( room ) => {\n\tif ( room.provider.filterBcConns ) {\n\t\t// broadcast peerId via broadcastchannel\n\t\tconst encoderPeerIdBc = encoding.createEncoder();\n\t\tencoding.writeVarUint( encoderPeerIdBc, messageBcPeerId );\n\t\tencoding.writeUint8( encoderPeerIdBc, 1 );\n\t\tencoding.writeVarString( encoderPeerIdBc, room.peerId );\n\t\tbroadcastBcMessage( room, encoding.toUint8Array( encoderPeerIdBc ) );\n\t}\n};\n\nexport class Room {\n\t/**\n\t * @param {Y.Doc} doc\n\t * @param {WebrtcProvider} provider\n\t * @param {string} name\n\t * @param {CryptoKey|null} key\n\t */\n\tconstructor( doc, provider, name, key ) {\n\t\t/**\n\t\t * Do not assume that peerId is unique. This is only meant for sending signaling messages.\n\t\t *\n\t\t * @type {string}\n\t\t */\n\t\tthis.peerId = random.uuidv4();\n\t\tthis.doc = doc;\n\t\t/**\n\t\t * @type {awarenessProtocol.Awareness}\n\t\t */\n\t\tthis.awareness = provider.awareness;\n\t\tthis.provider = provider;\n\t\tthis.synced = false;\n\t\tthis.name = name;\n\t\t// @todo make key secret by scoping\n\t\tthis.key = key;\n\t\t/**\n\t\t * @type {Map<string, WebrtcConn>}\n\t\t */\n\t\tthis.webrtcConns = new Map();\n\t\t/**\n\t\t * @type {Set<string>}\n\t\t */\n\t\tthis.bcConns = new Set();\n\t\tthis.mux = createMutex();\n\t\tthis.bcconnected = false;\n\t\t/**\n\t\t * @param {ArrayBuffer} data\n\t\t */\n\t\tthis._bcSubscriber = ( data ) =>\n\t\t\tcryptoutils.decrypt( new Uint8Array( data ), key ).then( ( m ) =>\n\t\t\t\tthis.mux( () => {\n\t\t\t\t\tconst reply = readMessage( this, m, () => {} );\n\t\t\t\t\tif ( reply ) {\n\t\t\t\t\t\tbroadcastBcMessage(\n\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\tencoding.toUint8Array( reply )\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t} )\n\t\t\t);\n\t\t/**\n\t\t * Listens to Yjs updates and sends them to remote peers\n\t\t *\n\t\t * @param {Uint8Array} update\n\t\t * @param {any} origin\n\t\t */\n\t\tthis._docUpdateHandler = ( update, origin ) => {\n\t\t\tconst encoder = encoding.createEncoder();\n\t\t\tencoding.writeVarUint( encoder, messageSync );\n\t\t\tsyncProtocol.writeUpdate( encoder, update );\n\t\t\tbroadcastRoomMessage( this, encoding.toUint8Array( encoder ) );\n\t\t};\n\t\t/**\n\t\t * Listens to Awareness updates and sends them to remote peers\n\t\t *\n\t\t * @param {any} changed\n\t\t * @param {any} origin\n\t\t */\n\t\tthis._awarenessUpdateHandler = (\n\t\t\t{ added, updated, removed },\n\t\t\torigin\n\t\t) => {\n\t\t\tconst changedClients = added.concat( updated ).concat( removed );\n\t\t\tconst encoderAwareness = encoding.createEncoder();\n\t\t\tencoding.writeVarUint( encoderAwareness, messageAwareness );\n\t\t\tencoding.writeVarUint8Array(\n\t\t\t\tencoderAwareness,\n\t\t\t\tawarenessProtocol.encodeAwarenessUpdate(\n\t\t\t\t\tthis.awareness,\n\t\t\t\t\tchangedClients\n\t\t\t\t)\n\t\t\t);\n\t\t\tbroadcastRoomMessage(\n\t\t\t\tthis,\n\t\t\t\tencoding.toUint8Array( encoderAwareness )\n\t\t\t);\n\t\t};\n\n\t\tthis._beforeUnloadHandler = () => {\n\t\t\tawarenessProtocol.removeAwarenessStates(\n\t\t\t\tthis.awareness,\n\t\t\t\t[ doc.clientID ],\n\t\t\t\t'window unload'\n\t\t\t);\n\t\t\trooms.forEach( ( room ) => {\n\t\t\t\troom.disconnect();\n\t\t\t} );\n\t\t};\n\n\t\tif ( typeof window !== 'undefined' ) {\n\t\t\twindow.addEventListener(\n\t\t\t\t'beforeunload',\n\t\t\t\tthis._beforeUnloadHandler\n\t\t\t);\n\t\t} else if ( typeof process !== 'undefined' ) {\n\t\t\tprocess.on( 'exit', this._beforeUnloadHandler );\n\t\t}\n\t}\n\n\tconnect() {\n\t\tthis.doc.on( 'update', this._docUpdateHandler );\n\t\tthis.awareness.on( 'update', this._awarenessUpdateHandler );\n\t\t// signal through all available signaling connections\n\t\tannounceSignalingInfo( this );\n\t\tconst roomName = this.name;\n\t\tbc.subscribe( roomName, this._bcSubscriber );\n\t\tthis.bcconnected = true;\n\t\t// broadcast peerId via broadcastchannel\n\t\tbroadcastBcPeerId( this );\n\t\t// write sync step 1\n\t\tconst encoderSync = encoding.createEncoder();\n\t\tencoding.writeVarUint( encoderSync, messageSync );\n\t\tsyncProtocol.writeSyncStep1( encoderSync, this.doc );\n\t\tbroadcastBcMessage( this, encoding.toUint8Array( encoderSync ) );\n\t\t// broadcast local state\n\t\tconst encoderState = encoding.createEncoder();\n\t\tencoding.writeVarUint( encoderState, messageSync );\n\t\tsyncProtocol.writeSyncStep2( encoderState, this.doc );\n\t\tbroadcastBcMessage( this, encoding.toUint8Array( encoderState ) );\n\t\t// write queryAwareness\n\t\tconst encoderAwarenessQuery = encoding.createEncoder();\n\t\tencoding.writeVarUint( encoderAwarenessQuery, messageQueryAwareness );\n\t\tbroadcastBcMessage(\n\t\t\tthis,\n\t\t\tencoding.toUint8Array( encoderAwarenessQuery )\n\t\t);\n\t\t// broadcast local awareness state\n\t\tconst encoderAwarenessState = encoding.createEncoder();\n\t\tencoding.writeVarUint( encoderAwarenessState, messageAwareness );\n\t\tencoding.writeVarUint8Array(\n\t\t\tencoderAwarenessState,\n\t\t\tawarenessProtocol.encodeAwarenessUpdate( this.awareness, [\n\t\t\t\tthis.doc.clientID,\n\t\t\t] )\n\t\t);\n\t\tbroadcastBcMessage(\n\t\t\tthis,\n\t\t\tencoding.toUint8Array( encoderAwarenessState )\n\t\t);\n\t}\n\n\tdisconnect() {\n\t\t// signal through all available signaling connections\n\t\tsignalingConns.forEach( ( conn ) => {\n\t\t\tif ( conn.connected ) {\n\t\t\t\tconn.send( { type: 'unsubscribe', topics: [ this.name ] } );\n\t\t\t}\n\t\t} );\n\t\tawarenessProtocol.removeAwarenessStates(\n\t\t\tthis.awareness,\n\t\t\t[ this.doc.clientID ],\n\t\t\t'disconnect'\n\t\t);\n\t\t// broadcast peerId removal via broadcastchannel\n\t\tconst encoderPeerIdBc = encoding.createEncoder();\n\t\tencoding.writeVarUint( encoderPeerIdBc, messageBcPeerId );\n\t\tencoding.writeUint8( encoderPeerIdBc, 0 ); // remove peerId from other bc peers\n\t\tencoding.writeVarString( encoderPeerIdBc, this.peerId );\n\t\tbroadcastBcMessage( this, encoding.toUint8Array( encoderPeerIdBc ) );\n\n\t\tbc.unsubscribe( this.name, this._bcSubscriber );\n\t\tthis.bcconnected = false;\n\t\tthis.doc.off( 'update', this._docUpdateHandler );\n\t\tthis.awareness.off( 'update', this._awarenessUpdateHandler );\n\t\tthis.webrtcConns.forEach( ( conn ) => conn.destroy() );\n\t}\n\n\tdestroy() {\n\t\tthis.disconnect();\n\t\tif ( typeof window !== 'undefined' ) {\n\t\t\twindow.removeEventListener(\n\t\t\t\t'beforeunload',\n\t\t\t\tthis._beforeUnloadHandler\n\t\t\t);\n\t\t} else if ( typeof process !== 'undefined' ) {\n\t\t\tprocess.off( 'exit', this._beforeUnloadHandler );\n\t\t}\n\t}\n}\n\n/**\n * @param {Y.Doc} doc\n * @param {WebrtcProvider} provider\n * @param {string} name\n * @param {CryptoKey|null} key\n * @return {Room}\n */\nconst openRoom = ( doc, provider, name, key ) => {\n\t// there must only be one room\n\tif ( rooms.has( name ) ) {\n\t\tthrow error.create(\n\t\t\t`A Yjs Doc connected to room \"${ name }\" already exists!`\n\t\t);\n\t}\n\tconst room = new Room( doc, provider, name, key );\n\trooms.set( name, /** @type {Room} */ ( room ) );\n\treturn room;\n};\n\n/**\n * @param {SignalingConn} conn\n * @param {Room} room\n * @param {any} data\n */\nexport const publishSignalingMessage = ( conn, room, data ) => {\n\tif ( room.key ) {\n\t\tcryptoutils.encryptJson( data, room.key ).then( ( data ) => {\n\t\t\tconn.send( {\n\t\t\t\ttype: 'publish',\n\t\t\t\ttopic: room.name,\n\t\t\t\tdata: buffer.toBase64( data ),\n\t\t\t} );\n\t\t} );\n\t} else {\n\t\tconn.send( { type: 'publish', topic: room.name, data } );\n\t}\n};\n\nexport class SignalingConn extends ws.WebsocketClient {\n\tconstructor( url ) {\n\t\tsuper( url );\n\t\t/**\n\t\t * @type {Set<WebrtcProvider>}\n\t\t */\n\t\tthis.providers = new Set();\n\t\tthis.on( 'connect', () => {\n\t\t\tlog( `connected (${ url })` );\n\t\t\tconst topics = Array.from( rooms.keys() );\n\t\t\tthis.send( { type: 'subscribe', topics } );\n\t\t\trooms.forEach( ( room ) =>\n\t\t\t\tpublishSignalingMessage( this, room, {\n\t\t\t\t\ttype: 'announce',\n\t\t\t\t\tfrom: room.peerId,\n\t\t\t\t} )\n\t\t\t);\n\t\t} );\n\t\tthis.on( 'message', ( m ) => {\n\t\t\tswitch ( m.type ) {\n\t\t\t\tcase 'publish': {\n\t\t\t\t\tconst roomName = m.topic;\n\t\t\t\t\tconst room = rooms.get( roomName );\n\t\t\t\t\tif ( room == null || typeof roomName !== 'string' ) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tconst execMessage = ( data ) => {\n\t\t\t\t\t\tconst webrtcConns = room.webrtcConns;\n\t\t\t\t\t\tconst peerId = room.peerId;\n\t\t\t\t\t\tif (\n\t\t\t\t\t\t\tdata == null ||\n\t\t\t\t\t\t\tdata.from === peerId ||\n\t\t\t\t\t\t\t( data.to !== undefined && data.to !== peerId ) ||\n\t\t\t\t\t\t\troom.bcConns.has( data.from )\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t// ignore messages that are not addressed to this conn, or from clients that are connected via broadcastchannel\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tconst emitPeerChange = webrtcConns.has( data.from )\n\t\t\t\t\t\t\t? () => {}\n\t\t\t\t\t\t\t: () =>\n\t\t\t\t\t\t\t\t\troom.provider.emit( 'peers', [\n\t\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\t\tremoved: [],\n\t\t\t\t\t\t\t\t\t\t\tadded: [ data.from ],\n\t\t\t\t\t\t\t\t\t\t\twebrtcPeers: Array.from(\n\t\t\t\t\t\t\t\t\t\t\t\troom.webrtcConns.keys()\n\t\t\t\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t\t\t\t\tbcPeers: Array.from( room.bcConns ),\n\t\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t] );\n\t\t\t\t\t\tswitch ( data.type ) {\n\t\t\t\t\t\t\tcase 'announce':\n\t\t\t\t\t\t\t\tif (\n\t\t\t\t\t\t\t\t\twebrtcConns.size < room.provider.maxConns\n\t\t\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t\t\tmap.setIfUndefined(\n\t\t\t\t\t\t\t\t\t\twebrtcConns,\n\t\t\t\t\t\t\t\t\t\tdata.from,\n\t\t\t\t\t\t\t\t\t\t() =>\n\t\t\t\t\t\t\t\t\t\t\tnew WebrtcConn(\n\t\t\t\t\t\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\t\t\t\t\t\ttrue,\n\t\t\t\t\t\t\t\t\t\t\t\tdata.from,\n\t\t\t\t\t\t\t\t\t\t\t\troom\n\t\t\t\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\temitPeerChange();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\tcase 'signal':\n\t\t\t\t\t\t\t\tif ( data.signal.type === 'offer' ) {\n\t\t\t\t\t\t\t\t\tconst existingConn = webrtcConns.get(\n\t\t\t\t\t\t\t\t\t\tdata.from\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\tif ( existingConn ) {\n\t\t\t\t\t\t\t\t\t\tconst remoteToken = data.token;\n\t\t\t\t\t\t\t\t\t\tconst localToken =\n\t\t\t\t\t\t\t\t\t\t\texistingConn.glareToken;\n\t\t\t\t\t\t\t\t\t\tif (\n\t\t\t\t\t\t\t\t\t\t\tlocalToken &&\n\t\t\t\t\t\t\t\t\t\t\tlocalToken > remoteToken\n\t\t\t\t\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t\t\t\t\tlog(\n\t\t\t\t\t\t\t\t\t\t\t\t'offer rejected: ',\n\t\t\t\t\t\t\t\t\t\t\t\tdata.from\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t// if we don't reject the offer, we will be accepting it and answering it\n\t\t\t\t\t\t\t\t\t\texistingConn.glareToken = undefined;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tif ( data.signal.type === 'answer' ) {\n\t\t\t\t\t\t\t\t\tlog( 'offer answered by: ', data.from );\n\t\t\t\t\t\t\t\t\tconst existingConn = webrtcConns.get(\n\t\t\t\t\t\t\t\t\t\tdata.from\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\texistingConn.glareToken = undefined;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tif ( data.to === peerId ) {\n\t\t\t\t\t\t\t\t\tmap.setIfUndefined(\n\t\t\t\t\t\t\t\t\t\twebrtcConns,\n\t\t\t\t\t\t\t\t\t\tdata.from,\n\t\t\t\t\t\t\t\t\t\t() =>\n\t\t\t\t\t\t\t\t\t\t\tnew WebrtcConn(\n\t\t\t\t\t\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\t\t\t\t\t\tfalse,\n\t\t\t\t\t\t\t\t\t\t\t\tdata.from,\n\t\t\t\t\t\t\t\t\t\t\t\troom\n\t\t\t\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t\t\t).peer.signal( data.signal );\n\t\t\t\t\t\t\t\t\temitPeerChange();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\tif ( room.key ) {\n\t\t\t\t\t\tif ( typeof m.data === 'string' ) {\n\t\t\t\t\t\t\tcryptoutils\n\t\t\t\t\t\t\t\t.decryptJson(\n\t\t\t\t\t\t\t\t\tbuffer.fromBase64( m.data ),\n\t\t\t\t\t\t\t\t\troom.key\n\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t\t.then( execMessage );\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\texecMessage( m.data );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t\tthis.on( 'disconnect', () => log( `disconnect (${ url })` ) );\n\t}\n}\n\n/**\n * @typedef {Object} ProviderOptions\n * @property {Array<string>} [signaling]\n * @property {string} [password]\n * @property {awarenessProtocol.Awareness} [awareness]\n * @property {number} [maxConns]\n * @property {boolean} [filterBcConns]\n * @property {any} [peerOpts]\n */\n\n/**\n * @extends Observable<string>\n */\nexport class WebrtcProvider extends Observable {\n\t/**\n\t * @param {string} roomName\n\t * @param {Y.Doc} doc\n\t * @param {ProviderOptions?} opts\n\t */\n\tconstructor(\n\t\troomName,\n\t\tdoc,\n\t\t{\n\t\t\tsignaling = [ 'wss://y-webrtc-eu.fly.dev' ],\n\t\t\tpassword = null,\n\t\t\tawareness = new awarenessProtocol.Awareness( doc ),\n\t\t\tmaxConns = 20 + math.floor( random.rand() * 15 ), // the random factor reduces the chance that n clients form a cluster\n\t\t\tfilterBcConns = true,\n\t\t\tpeerOpts = {}, // simple-peer options. See https://github.com/feross/simple-peer#peer--new-peeropts\n\t\t} = {}\n\t) {\n\t\tsuper();\n\t\tthis.roomName = roomName;\n\t\tthis.doc = doc;\n\t\tthis.filterBcConns = filterBcConns;\n\t\t/**\n\t\t * @type {awarenessProtocol.Awareness}\n\t\t */\n\t\tthis.awareness = awareness;\n\t\tthis.shouldConnect = false;\n\t\tthis.signalingUrls = signaling;\n\t\tthis.signalingConns = [];\n\t\tthis.maxConns = maxConns;\n\t\tthis.peerOpts = peerOpts;\n\t\t/**\n\t\t * @type {PromiseLike<CryptoKey | null>}\n\t\t */\n\t\tthis.key = password\n\t\t\t? cryptoutils.deriveKey( password, roomName )\n\t\t\t: /** @type {PromiseLike<null>} */ ( promise.resolve( null ) );\n\t\t/**\n\t\t * @type {Room|null}\n\t\t */\n\t\tthis.room = null;\n\t\tthis.key.then( ( key ) => {\n\t\t\tthis.room = openRoom( doc, this, roomName, key );\n\t\t\tif ( this.shouldConnect ) {\n\t\t\t\tthis.room.connect();\n\t\t\t} else {\n\t\t\t\tthis.room.disconnect();\n\t\t\t}\n\t\t} );\n\t\tthis.connect();\n\t\tthis.destroy = this.destroy.bind( this );\n\t\tdoc.on( 'destroy', this.destroy );\n\t}\n\n\t/**\n\t * @type {boolean}\n\t */\n\tget connected() {\n\t\treturn this.room !== null && this.shouldConnect;\n\t}\n\n\tconnect() {\n\t\tthis.shouldConnect = true;\n\t\tthis.signalingUrls.forEach( ( url ) => {\n\t\t\tconst signalingConn = map.setIfUndefined(\n\t\t\t\tsignalingConns,\n\t\t\t\turl,\n\t\t\t\t() => new SignalingConn( url )\n\t\t\t);\n\t\t\tthis.signalingConns.push( signalingConn );\n\t\t\tsignalingConn.providers.add( this );\n\t\t} );\n\t\tif ( this.room ) {\n\t\t\tthis.room.connect();\n\t\t}\n\t}\n\n\tdisconnect() {\n\t\tthis.shouldConnect = false;\n\t\tthis.signalingConns.forEach( ( conn ) => {\n\t\t\tconn.providers.delete( this );\n\t\t\tif ( conn.providers.size === 0 ) {\n\t\t\t\tconn.destroy();\n\t\t\t\tsignalingConns.delete( conn.url );\n\t\t\t}\n\t\t} );\n\t\tif ( this.room ) {\n\t\t\tthis.room.disconnect();\n\t\t}\n\t}\n\n\tdestroy() {\n\t\tthis.doc.off( 'destroy', this.destroy );\n\t\t// need to wait for key before deleting room\n\t\tthis.key.then( () => {\n\t\t\t/** @type {Room} */ ( this.room ).destroy();\n\t\t\trooms.delete( this.roomName );\n\t\t} );\n\t\tsuper.destroy();\n\t}\n}\n","/**\n * Mutual exclude for JavaScript.\n *\n * @module mutex\n */\n\n/**\n * @callback mutex\n * @param {function():void} cb Only executed when this mutex is not in the current stack\n * @param {function():void} [elseCb] Executed when this mutex is in the current stack\n */\n\n/**\n * Creates a mutual exclude function with the following property:\n *\n * ```js\n * const mutex = createMutex()\n * mutex(() => {\n *   // This function is immediately executed\n *   mutex(() => {\n *     // This function is not executed, as the mutex is already active.\n *   })\n * })\n * ```\n *\n * @return {mutex} A mutual exclude function\n * @public\n */\nexport const createMutex = () => {\n  let token = true\n  return (f, g) => {\n    if (token) {\n      token = false\n      try {\n        f()\n      } finally {\n        token = true\n      }\n    } else if (g !== undefined) {\n      g()\n    }\n  }\n}\n","/**\n * External dependencies\n */\n/**\n * Internal dependencies\n */\nimport {\n\tWebrtcProvider,\n\tSignalingConn,\n\tWebrtcConn,\n\tsignalingConns,\n\trooms,\n\tpublishSignalingMessage,\n\tlog,\n} from './y-webrtc/y-webrtc';\nimport * as cryptoutils from './y-webrtc/crypto';\n\nimport * as map from 'lib0/map';\nimport { Observable } from 'lib0/observable';\nimport * as buffer from 'lib0/buffer';\n\n/**\n * WordPress dependencies\n */\nimport { addQueryArgs } from '@wordpress/url';\n\n/**\n * Method copied as is from the SignalingConn constructor.\n * Setups the needed event handlers for an http signaling connection.\n *\n * @param {HttpSignalingConn} signalCon The signaling connection.\n * @param {string}            url       The url.\n */\nfunction setupSignalEventHandlers( signalCon, url ) {\n\tsignalCon.on( 'connect', () => {\n\t\tlog( `connected (${ url })` );\n\t\tconst topics = Array.from( rooms.keys() );\n\t\tsignalCon.send( { type: 'subscribe', topics } );\n\t\trooms.forEach( ( room ) =>\n\t\t\tpublishSignalingMessage( signalCon, room, {\n\t\t\t\ttype: 'announce',\n\t\t\t\tfrom: room.peerId,\n\t\t\t} )\n\t\t);\n\t} );\n\tsignalCon.on(\n\t\t'message',\n\t\t( /** @type {{ type: any; topic: any; data: string; }} */ m ) => {\n\t\t\tswitch ( m.type ) {\n\t\t\t\tcase 'publish': {\n\t\t\t\t\tconst roomName = m.topic;\n\t\t\t\t\tconst room = rooms.get( roomName );\n\t\t\t\t\tif (\n\t\t\t\t\t\troom === null ||\n\t\t\t\t\t\ttypeof roomName !== 'string' ||\n\t\t\t\t\t\troom === undefined\n\t\t\t\t\t) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tconst execMessage = ( /** @type {any} */ data ) => {\n\t\t\t\t\t\tconst webrtcConns = room.webrtcConns;\n\t\t\t\t\t\tconst peerId = room.peerId;\n\t\t\t\t\t\tif (\n\t\t\t\t\t\t\tdata === null ||\n\t\t\t\t\t\t\tdata.from === peerId ||\n\t\t\t\t\t\t\t( data.to !== undefined && data.to !== peerId ) ||\n\t\t\t\t\t\t\troom.bcConns.has( data.from )\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t// ignore messages that are not addressed to this conn, or from clients that are connected via broadcastchannel\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tconst emitPeerChange = webrtcConns.has( data.from )\n\t\t\t\t\t\t\t? () => {}\n\t\t\t\t\t\t\t: () =>\n\t\t\t\t\t\t\t\t\troom.provider.emit( 'peers', [\n\t\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\t\tremoved: [],\n\t\t\t\t\t\t\t\t\t\t\tadded: [ data.from ],\n\t\t\t\t\t\t\t\t\t\t\twebrtcPeers: Array.from(\n\t\t\t\t\t\t\t\t\t\t\t\troom.webrtcConns.keys()\n\t\t\t\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t\t\t\t\tbcPeers: Array.from( room.bcConns ),\n\t\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t] );\n\t\t\t\t\t\tswitch ( data.type ) {\n\t\t\t\t\t\t\tcase 'announce':\n\t\t\t\t\t\t\t\tif (\n\t\t\t\t\t\t\t\t\twebrtcConns.size < room.provider.maxConns\n\t\t\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t\t\tmap.setIfUndefined(\n\t\t\t\t\t\t\t\t\t\twebrtcConns,\n\t\t\t\t\t\t\t\t\t\tdata.from,\n\t\t\t\t\t\t\t\t\t\t() =>\n\t\t\t\t\t\t\t\t\t\t\tnew WebrtcConn(\n\t\t\t\t\t\t\t\t\t\t\t\tsignalCon,\n\t\t\t\t\t\t\t\t\t\t\t\ttrue,\n\t\t\t\t\t\t\t\t\t\t\t\tdata.from,\n\t\t\t\t\t\t\t\t\t\t\t\troom\n\t\t\t\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\temitPeerChange();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\tcase 'signal':\n\t\t\t\t\t\t\t\tif ( data.signal.type === 'offer' ) {\n\t\t\t\t\t\t\t\t\tconst existingConn = webrtcConns.get(\n\t\t\t\t\t\t\t\t\t\tdata.from\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\tif ( existingConn ) {\n\t\t\t\t\t\t\t\t\t\tconst remoteToken = data.token;\n\t\t\t\t\t\t\t\t\t\tconst localToken =\n\t\t\t\t\t\t\t\t\t\t\texistingConn.glareToken;\n\t\t\t\t\t\t\t\t\t\tif (\n\t\t\t\t\t\t\t\t\t\t\tlocalToken &&\n\t\t\t\t\t\t\t\t\t\t\tlocalToken > remoteToken\n\t\t\t\t\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t\t\t\t\tlog(\n\t\t\t\t\t\t\t\t\t\t\t\t'offer rejected: ',\n\t\t\t\t\t\t\t\t\t\t\t\tdata.from\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t// if we don't reject the offer, we will be accepting it and answering it\n\t\t\t\t\t\t\t\t\t\texistingConn.glareToken = undefined;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tif ( data.signal.type === 'answer' ) {\n\t\t\t\t\t\t\t\t\tlog( 'offer answered by: ', data.from );\n\t\t\t\t\t\t\t\t\tconst existingConn = webrtcConns.get(\n\t\t\t\t\t\t\t\t\t\tdata.from\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\tif ( existingConn ) {\n\t\t\t\t\t\t\t\t\t\texistingConn.glareToken = undefined;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tif ( data.to === peerId ) {\n\t\t\t\t\t\t\t\t\tmap.setIfUndefined(\n\t\t\t\t\t\t\t\t\t\twebrtcConns,\n\t\t\t\t\t\t\t\t\t\tdata.from,\n\t\t\t\t\t\t\t\t\t\t() =>\n\t\t\t\t\t\t\t\t\t\t\tnew WebrtcConn(\n\t\t\t\t\t\t\t\t\t\t\t\tsignalCon,\n\t\t\t\t\t\t\t\t\t\t\t\tfalse,\n\t\t\t\t\t\t\t\t\t\t\t\tdata.from,\n\t\t\t\t\t\t\t\t\t\t\t\troom\n\t\t\t\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t\t\t).peer.signal( data.signal );\n\t\t\t\t\t\t\t\t\temitPeerChange();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\tif ( room.key ) {\n\t\t\t\t\t\tif ( typeof m.data === 'string' ) {\n\t\t\t\t\t\t\tcryptoutils\n\t\t\t\t\t\t\t\t.decryptJson(\n\t\t\t\t\t\t\t\t\tbuffer.fromBase64( m.data ),\n\t\t\t\t\t\t\t\t\troom.key\n\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t\t.then( execMessage );\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\texecMessage( m.data );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t);\n\tsignalCon.on( 'disconnect', () => log( `disconnect (${ url })` ) );\n}\n\n/**\n * Method that instantiates the http signaling connection.\n * Tries to implement the same methods a websocket provides using ajax requests\n * to send messages and EventSource to retrieve messages.\n *\n * @param {HttpSignalingConn} httpClient The signaling connection.\n */\nfunction setupHttpSignal( httpClient ) {\n\tif ( httpClient.shouldConnect && httpClient.ws === null ) {\n\t\t// eslint-disable-next-line no-restricted-syntax\n\t\tconst subscriberId = Math.floor( 100000 + Math.random() * 900000 );\n\t\tconst url = httpClient.url;\n\t\tconst eventSource = new window.EventSource(\n\t\t\taddQueryArgs( url, {\n\t\t\t\tsubscriber_id: subscriberId,\n\t\t\t\taction: 'gutenberg_signaling_server',\n\t\t\t} )\n\t\t);\n\t\t/**\n\t\t * @type {any}\n\t\t */\n\t\tlet pingTimeout = null;\n\t\teventSource.onmessage = ( event ) => {\n\t\t\thttpClient.lastMessageReceived = Date.now();\n\t\t\tconst data = event.data;\n\t\t\tif ( data ) {\n\t\t\t\tconst messages = JSON.parse( data );\n\t\t\t\tif ( Array.isArray( messages ) ) {\n\t\t\t\t\tmessages.forEach( onSingleMessage );\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\t// @ts-ignore\n\t\thttpClient.ws = eventSource;\n\t\thttpClient.connecting = true;\n\t\thttpClient.connected = false;\n\t\tconst onSingleMessage = ( /** @type {any} */ message ) => {\n\t\t\tif ( message && message.type === 'pong' ) {\n\t\t\t\tclearTimeout( pingTimeout );\n\t\t\t\tpingTimeout = setTimeout(\n\t\t\t\t\tsendPing,\n\t\t\t\t\tmessageReconnectTimeout / 2\n\t\t\t\t);\n\t\t\t}\n\t\t\thttpClient.emit( 'message', [ message, httpClient ] );\n\t\t};\n\n\t\t/**\n\t\t * @param {any} error\n\t\t */\n\t\tconst onclose = ( error ) => {\n\t\t\tif ( httpClient.ws !== null ) {\n\t\t\t\thttpClient.ws.close();\n\t\t\t\thttpClient.ws = null;\n\t\t\t\thttpClient.connecting = false;\n\t\t\t\tif ( httpClient.connected ) {\n\t\t\t\t\thttpClient.connected = false;\n\t\t\t\t\thttpClient.emit( 'disconnect', [\n\t\t\t\t\t\t{ type: 'disconnect', error },\n\t\t\t\t\t\thttpClient,\n\t\t\t\t\t] );\n\t\t\t\t} else {\n\t\t\t\t\thttpClient.unsuccessfulReconnects++;\n\t\t\t\t}\n\t\t\t}\n\t\t\tclearTimeout( pingTimeout );\n\t\t};\n\t\tconst sendPing = () => {\n\t\t\tif (\n\t\t\t\thttpClient.ws &&\n\t\t\t\thttpClient.ws.readyState === window.EventSource.OPEN\n\t\t\t) {\n\t\t\t\thttpClient.send( {\n\t\t\t\t\ttype: 'ping',\n\t\t\t\t} );\n\t\t\t}\n\t\t};\n\t\tif ( httpClient.ws ) {\n\t\t\thttpClient.ws.onclose = () => {\n\t\t\t\tonclose( null );\n\t\t\t};\n\t\t\thttpClient.ws.send = function send(\n\t\t\t\t/** @type {string} */ message\n\t\t\t) {\n\t\t\t\twindow\n\t\t\t\t\t.fetch( url, {\n\t\t\t\t\t\tbody: new URLSearchParams( {\n\t\t\t\t\t\t\tsubscriber_id: subscriberId.toString(),\n\t\t\t\t\t\t\taction: 'gutenberg_signaling_server',\n\t\t\t\t\t\t\tmessage,\n\t\t\t\t\t\t} ),\n\t\t\t\t\t\tmethod: 'POST',\n\t\t\t\t\t} )\n\t\t\t\t\t.catch( () => {\n\t\t\t\t\t\tlog(\n\t\t\t\t\t\t\t'Error sending to server with message: ' + message\n\t\t\t\t\t\t);\n\t\t\t\t\t} );\n\t\t\t};\n\t\t}\n\t\teventSource.onerror = () => {\n\t\t\t// Todo: add an error handler\n\t\t};\n\t\teventSource.onopen = () => {\n\t\t\tif ( httpClient.connected ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif ( eventSource.readyState === window.EventSource.OPEN ) {\n\t\t\t\thttpClient.lastMessageReceived = Date.now();\n\t\t\t\thttpClient.connecting = false;\n\t\t\t\thttpClient.connected = true;\n\t\t\t\thttpClient.unsuccessfulReconnects = 0;\n\t\t\t\thttpClient.emit( 'connect', [\n\t\t\t\t\t{ type: 'connect' },\n\t\t\t\t\thttpClient,\n\t\t\t\t] );\n\t\t\t\t// set ping\n\t\t\t\tpingTimeout = setTimeout(\n\t\t\t\t\tsendPing,\n\t\t\t\t\tmessageReconnectTimeout / 2\n\t\t\t\t);\n\t\t\t}\n\t\t};\n\t}\n}\nconst messageReconnectTimeout = 30000;\n\n/**\n * @augments Observable<string>\n */ export class HttpSignalingConn extends Observable {\n\t/**\n\t * @param {string} url\n\t */\n\tconstructor( url ) {\n\t\tsuper();\n\n\t\t//WebsocketClient from lib0/websocket.js\n\t\tthis.url = url;\n\t\t/**\n\t\t * @type {WebSocket?}\n\t\t */\n\t\tthis.ws = null;\n\t\t// @ts-ignore\n\t\tthis.binaryType = null; // this.binaryType = binaryType\n\t\tthis.connected = false;\n\t\tthis.connecting = false;\n\t\tthis.unsuccessfulReconnects = 0;\n\t\tthis.lastMessageReceived = 0;\n\t\t/**\n\t\t * Whether to connect to other peers or not\n\t\t *\n\t\t * @type {boolean}\n\t\t */\n\t\tthis.shouldConnect = true;\n\t\tthis._checkInterval = setInterval( () => {\n\t\t\tif (\n\t\t\t\tthis.connected &&\n\t\t\t\tmessageReconnectTimeout <\n\t\t\t\t\tDate.now() - this.lastMessageReceived &&\n\t\t\t\tthis.ws\n\t\t\t) {\n\t\t\t\t// no message received in a long time - not even your own awareness\n\t\t\t\t// updates (which are updated every 15 seconds)\n\t\t\t\tthis.ws.close();\n\t\t\t}\n\t\t}, messageReconnectTimeout / 2 );\n\t\t//setupWS( this );\n\t\tsetupHttpSignal( this );\n\n\t\t// From SignalingConn\n\t\t/**\n\t\t * @type {Set<WebrtcProvider>}\n\t\t */\n\t\tthis.providers = new Set();\n\n\t\tsetupSignalEventHandlers( this, url );\n\t}\n\n\t/**\n\t * @param {any} message\n\t */\n\tsend( message ) {\n\t\tif ( this.ws ) {\n\t\t\tthis.ws.send( JSON.stringify( message ) );\n\t\t}\n\t}\n\n\tdestroy() {\n\t\tclearInterval( this._checkInterval );\n\t\tthis.disconnect();\n\t\tsuper.destroy();\n\t}\n\n\tdisconnect() {\n\t\tthis.shouldConnect = false;\n\t\tif ( this.ws !== null ) {\n\t\t\tthis.ws.close();\n\t\t}\n\t}\n\n\tconnect() {\n\t\tthis.shouldConnect = true;\n\t\tif ( ! this.connected && this.ws === null ) {\n\t\t\tsetupHttpSignal( this );\n\t\t}\n\t}\n}\n\nexport class WebrtcProviderWithHttpSignaling extends WebrtcProvider {\n\tconnect() {\n\t\tthis.shouldConnect = true;\n\t\tthis.signalingUrls.forEach( ( /** @type {string} */ url ) => {\n\t\t\tconst signalingConn = map.setIfUndefined(\n\t\t\t\tsignalingConns,\n\t\t\t\turl,\n\t\t\t\t// Only this conditional logic to create a normal websocket connection or\n\t\t\t\t// an http signaling connection was added to the constructor when compared\n\t\t\t\t// with the base class.\n\t\t\t\turl.startsWith( 'ws://' ) || url.startsWith( 'wss://' )\n\t\t\t\t\t? () => new SignalingConn( url )\n\t\t\t\t\t: () => new HttpSignalingConn( url )\n\t\t\t);\n\t\t\tthis.signalingConns.push( signalingConn );\n\t\t\tsignalingConn.providers.add( this );\n\t\t} );\n\t\tif ( this.room ) {\n\t\t\tthis.room.connect();\n\t\t}\n\t}\n}\n","/**\n * WordPress dependencies\n */\nimport {\n\tcreateSyncProvider,\n\tconnectIndexDb,\n\tcreateWebRTCConnection,\n} from '@wordpress/sync';\n\nlet syncProvider;\n\nexport function getSyncProvider() {\n\tif ( ! syncProvider ) {\n\t\tsyncProvider = createSyncProvider(\n\t\t\tconnectIndexDb,\n\t\t\tcreateWebRTCConnection( {\n\t\t\t\tsignaling: [\n\t\t\t\t\t//'ws://localhost:4444',\n\t\t\t\t\twindow?.wp?.ajax?.settings?.url,\n\t\t\t\t],\n\t\t\t\tpassword: window?.__experimentalCollaborativeEditingSecret,\n\t\t\t} )\n\t\t);\n\t}\n\n\treturn syncProvider;\n}\n","/**\n * External dependencies\n */\n// import { WebrtcProvider } from 'y-webrtc';\n\n/**\n * Internal dependencies\n */\nimport { WebrtcProviderWithHttpSignaling } from './webrtc-http-stream-signaling';\n\n/** @typedef {import('./types').ObjectType} ObjectType */\n/** @typedef {import('./types').ObjectID} ObjectID */\n/** @typedef {import('./types').CRDTDoc} CRDTDoc */\n\n/**\n * Function that creates a new WebRTC Connection.\n *\n * @param {Object}        config           The object ID.\n *\n * @param {Array<string>} config.signaling\n * @param {string}        config.password\n * @return {Function} Promise that resolves when the connection is established.\n */\nexport function createWebRTCConnection( { signaling, password } ) {\n\treturn function (\n\t\t/** @type {string} */ objectId,\n\t\t/** @type {string} */ objectType,\n\t\t/** @type {import(\"yjs\").Doc} */ doc\n\t) {\n\t\tconst roomName = `${ objectType }-${ objectId }`;\n\t\tnew WebrtcProviderWithHttpSignaling( roomName, doc, {\n\t\t\tsignaling,\n\t\t\t// @ts-ignore\n\t\t\tpassword,\n\t\t} );\n\n\t\treturn Promise.resolve( () => true );\n\t};\n}\n","/**\n * External dependencies\n */\nimport fastDeepEqual from 'fast-deep-equal/es6';\nimport { v4 as uuid } from 'uuid';\n\n/**\n * WordPress dependencies\n */\nimport apiFetch from '@wordpress/api-fetch';\nimport { addQueryArgs } from '@wordpress/url';\nimport deprecated from '@wordpress/deprecated';\n\n/**\n * Internal dependencies\n */\nimport { getNestedValue, setNestedValue } from './utils';\nimport { receiveItems, removeItems, receiveQueriedItems } from './queried-data';\nimport { DEFAULT_ENTITY_KEY } from './entities';\nimport { createBatch } from './batch';\nimport { STORE_NAME } from './name';\nimport { getSyncProvider } from './sync';\n\n/**\n * Returns an action object used in signalling that authors have been received.\n * Ignored from documentation as it's internal to the data store.\n *\n * @ignore\n *\n * @param {string}       queryID Query ID.\n * @param {Array|Object} users   Users received.\n *\n * @return {Object} Action object.\n */\nexport function receiveUserQuery( queryID, users ) {\n\treturn {\n\t\ttype: 'RECEIVE_USER_QUERY',\n\t\tusers: Array.isArray( users ) ? users : [ users ],\n\t\tqueryID,\n\t};\n}\n\n/**\n * Returns an action used in signalling that the current user has been received.\n * Ignored from documentation as it's internal to the data store.\n *\n * @ignore\n *\n * @param {Object} currentUser Current user object.\n *\n * @return {Object} Action object.\n */\nexport function receiveCurrentUser( currentUser ) {\n\treturn {\n\t\ttype: 'RECEIVE_CURRENT_USER',\n\t\tcurrentUser,\n\t};\n}\n\n/**\n * Returns an action object used in adding new entities.\n *\n * @param {Array} entities Entities received.\n *\n * @return {Object} Action object.\n */\nexport function addEntities( entities ) {\n\treturn {\n\t\ttype: 'ADD_ENTITIES',\n\t\tentities,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that entity records have been received.\n *\n * @param {string}       kind            Kind of the received entity record.\n * @param {string}       name            Name of the received entity record.\n * @param {Array|Object} records         Records received.\n * @param {?Object}      query           Query Object.\n * @param {?boolean}     invalidateCache Should invalidate query caches.\n * @param {?Object}      edits           Edits to reset.\n * @param {?Object}      meta            Meta information about pagination.\n * @return {Object} Action object.\n */\nexport function receiveEntityRecords(\n\tkind,\n\tname,\n\trecords,\n\tquery,\n\tinvalidateCache = false,\n\tedits,\n\tmeta\n) {\n\t// Auto drafts should not have titles, but some plugins rely on them so we can't filter this\n\t// on the server.\n\tif ( kind === 'postType' ) {\n\t\trecords = ( Array.isArray( records ) ? records : [ records ] ).map(\n\t\t\t( record ) =>\n\t\t\t\trecord.status === 'auto-draft'\n\t\t\t\t\t? { ...record, title: '' }\n\t\t\t\t\t: record\n\t\t);\n\t}\n\tlet action;\n\tif ( query ) {\n\t\taction = receiveQueriedItems( records, query, edits, meta );\n\t} else {\n\t\taction = receiveItems( records, edits, meta );\n\t}\n\n\treturn {\n\t\t...action,\n\t\tkind,\n\t\tname,\n\t\tinvalidateCache,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that the current theme has been received.\n * Ignored from documentation as it's internal to the data store.\n *\n * @ignore\n *\n * @param {Object} currentTheme The current theme.\n *\n * @return {Object} Action object.\n */\nexport function receiveCurrentTheme( currentTheme ) {\n\treturn {\n\t\ttype: 'RECEIVE_CURRENT_THEME',\n\t\tcurrentTheme,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that the current global styles id has been received.\n * Ignored from documentation as it's internal to the data store.\n *\n * @ignore\n *\n * @param {string} currentGlobalStylesId The current global styles id.\n *\n * @return {Object} Action object.\n */\nexport function __experimentalReceiveCurrentGlobalStylesId(\n\tcurrentGlobalStylesId\n) {\n\treturn {\n\t\ttype: 'RECEIVE_CURRENT_GLOBAL_STYLES_ID',\n\t\tid: currentGlobalStylesId,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that the theme base global styles have been received\n * Ignored from documentation as it's internal to the data store.\n *\n * @ignore\n *\n * @param {string} stylesheet   The theme's identifier\n * @param {Object} globalStyles The global styles object.\n *\n * @return {Object} Action object.\n */\nexport function __experimentalReceiveThemeBaseGlobalStyles(\n\tstylesheet,\n\tglobalStyles\n) {\n\treturn {\n\t\ttype: 'RECEIVE_THEME_GLOBAL_STYLES',\n\t\tstylesheet,\n\t\tglobalStyles,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that the theme global styles variations have been received.\n * Ignored from documentation as it's internal to the data store.\n *\n * @ignore\n *\n * @param {string} stylesheet The theme's identifier\n * @param {Array}  variations The global styles variations.\n *\n * @return {Object} Action object.\n */\nexport function __experimentalReceiveThemeGlobalStyleVariations(\n\tstylesheet,\n\tvariations\n) {\n\treturn {\n\t\ttype: 'RECEIVE_THEME_GLOBAL_STYLE_VARIATIONS',\n\t\tstylesheet,\n\t\tvariations,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that the index has been received.\n *\n * @deprecated since WP 5.9, this is not useful anymore, use the selector directly.\n *\n * @return {Object} Action object.\n */\nexport function receiveThemeSupports() {\n\tdeprecated( \"wp.data.dispatch( 'core' ).receiveThemeSupports\", {\n\t\tsince: '5.9',\n\t} );\n\n\treturn {\n\t\ttype: 'DO_NOTHING',\n\t};\n}\n\n/**\n * Returns an action object used in signalling that the theme global styles CPT post revisions have been received.\n * Ignored from documentation as it's internal to the data store.\n *\n * @deprecated since WordPress 6.5.0. Callers should use `dispatch( 'core' ).receiveRevision` instead.\n *\n * @ignore\n *\n * @param {number} currentId The post id.\n * @param {Array}  revisions The global styles revisions.\n *\n * @return {Object} Action object.\n */\nexport function receiveThemeGlobalStyleRevisions( currentId, revisions ) {\n\tdeprecated(\n\t\t\"wp.data.dispatch( 'core' ).receiveThemeGlobalStyleRevisions()\",\n\t\t{\n\t\t\tsince: '6.5.0',\n\t\t\talternative: \"wp.data.dispatch( 'core' ).receiveRevisions\",\n\t\t}\n\t);\n\treturn {\n\t\ttype: 'RECEIVE_THEME_GLOBAL_STYLE_REVISIONS',\n\t\tcurrentId,\n\t\trevisions,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that the preview data for\n * a given URl has been received.\n * Ignored from documentation as it's internal to the data store.\n *\n * @ignore\n *\n * @param {string} url     URL to preview the embed for.\n * @param {*}      preview Preview data.\n *\n * @return {Object} Action object.\n */\nexport function receiveEmbedPreview( url, preview ) {\n\treturn {\n\t\ttype: 'RECEIVE_EMBED_PREVIEW',\n\t\turl,\n\t\tpreview,\n\t};\n}\n\n/**\n * Action triggered to delete an entity record.\n *\n * @param {string}        kind                         Kind of the deleted entity.\n * @param {string}        name                         Name of the deleted entity.\n * @param {number|string} recordId                     Record ID of the deleted entity.\n * @param {?Object}       query                        Special query parameters for the\n *                                                     DELETE API call.\n * @param {Object}        [options]                    Delete options.\n * @param {Function}      [options.__unstableFetch]    Internal use only. Function to\n *                                                     call instead of `apiFetch()`.\n *                                                     Must return a promise.\n * @param {boolean}       [options.throwOnError=false] If false, this action suppresses all\n *                                                     the exceptions. Defaults to false.\n */\nexport const deleteEntityRecord =\n\t(\n\t\tkind,\n\t\tname,\n\t\trecordId,\n\t\tquery,\n\t\t{ __unstableFetch = apiFetch, throwOnError = false } = {}\n\t) =>\n\tasync ( { dispatch, resolveSelect } ) => {\n\t\tconst configs = await resolveSelect.getEntitiesConfig( kind );\n\t\tconst entityConfig = configs.find(\n\t\t\t( config ) => config.kind === kind && config.name === name\n\t\t);\n\t\tlet error;\n\t\tlet deletedRecord = false;\n\t\tif ( ! entityConfig ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst lock = await dispatch.__unstableAcquireStoreLock(\n\t\t\tSTORE_NAME,\n\t\t\t[ 'entities', 'records', kind, name, recordId ],\n\t\t\t{ exclusive: true }\n\t\t);\n\n\t\ttry {\n\t\t\tdispatch( {\n\t\t\t\ttype: 'DELETE_ENTITY_RECORD_START',\n\t\t\t\tkind,\n\t\t\t\tname,\n\t\t\t\trecordId,\n\t\t\t} );\n\n\t\t\tlet hasError = false;\n\t\t\ttry {\n\t\t\t\tlet path = `${ entityConfig.baseURL }/${ recordId }`;\n\n\t\t\t\tif ( query ) {\n\t\t\t\t\tpath = addQueryArgs( path, query );\n\t\t\t\t}\n\n\t\t\t\tdeletedRecord = await __unstableFetch( {\n\t\t\t\t\tpath,\n\t\t\t\t\tmethod: 'DELETE',\n\t\t\t\t} );\n\n\t\t\t\tawait dispatch( removeItems( kind, name, recordId, true ) );\n\t\t\t} catch ( _error ) {\n\t\t\t\thasError = true;\n\t\t\t\terror = _error;\n\t\t\t}\n\n\t\t\tdispatch( {\n\t\t\t\ttype: 'DELETE_ENTITY_RECORD_FINISH',\n\t\t\t\tkind,\n\t\t\t\tname,\n\t\t\t\trecordId,\n\t\t\t\terror,\n\t\t\t} );\n\n\t\t\tif ( hasError && throwOnError ) {\n\t\t\t\tthrow error;\n\t\t\t}\n\n\t\t\treturn deletedRecord;\n\t\t} finally {\n\t\t\tdispatch.__unstableReleaseStoreLock( lock );\n\t\t}\n\t};\n\n/**\n * Returns an action object that triggers an\n * edit to an entity record.\n *\n * @param {string}        kind                 Kind of the edited entity record.\n * @param {string}        name                 Name of the edited entity record.\n * @param {number|string} recordId             Record ID of the edited entity record.\n * @param {Object}        edits                The edits.\n * @param {Object}        options              Options for the edit.\n * @param {boolean}       [options.undoIgnore] Whether to ignore the edit in undo history or not.\n *\n * @return {Object} Action object.\n */\nexport const editEntityRecord =\n\t( kind, name, recordId, edits, options = {} ) =>\n\t( { select, dispatch } ) => {\n\t\tconst entityConfig = select.getEntityConfig( kind, name );\n\t\tif ( ! entityConfig ) {\n\t\t\tthrow new Error(\n\t\t\t\t`The entity being edited (${ kind }, ${ name }) does not have a loaded config.`\n\t\t\t);\n\t\t}\n\t\tconst { mergedEdits = {} } = entityConfig;\n\t\tconst record = select.getRawEntityRecord( kind, name, recordId );\n\t\tconst editedRecord = select.getEditedEntityRecord(\n\t\t\tkind,\n\t\t\tname,\n\t\t\trecordId\n\t\t);\n\n\t\tconst edit = {\n\t\t\tkind,\n\t\t\tname,\n\t\t\trecordId,\n\t\t\t// Clear edits when they are equal to their persisted counterparts\n\t\t\t// so that the property is not considered dirty.\n\t\t\tedits: Object.keys( edits ).reduce( ( acc, key ) => {\n\t\t\t\tconst recordValue = record[ key ];\n\t\t\t\tconst editedRecordValue = editedRecord[ key ];\n\t\t\t\tconst value = mergedEdits[ key ]\n\t\t\t\t\t? { ...editedRecordValue, ...edits[ key ] }\n\t\t\t\t\t: edits[ key ];\n\t\t\t\tacc[ key ] = fastDeepEqual( recordValue, value )\n\t\t\t\t\t? undefined\n\t\t\t\t\t: value;\n\t\t\t\treturn acc;\n\t\t\t}, {} ),\n\t\t};\n\t\tif ( window.__experimentalEnableSync && entityConfig.syncConfig ) {\n\t\t\tif ( globalThis.IS_GUTENBERG_PLUGIN ) {\n\t\t\t\tconst objectId = entityConfig.getSyncObjectId( recordId );\n\t\t\t\tgetSyncProvider().update(\n\t\t\t\t\tentityConfig.syncObjectType + '--edit',\n\t\t\t\t\tobjectId,\n\t\t\t\t\tedit.edits\n\t\t\t\t);\n\t\t\t}\n\t\t} else {\n\t\t\tif ( ! options.undoIgnore ) {\n\t\t\t\tselect.getUndoManager().addRecord(\n\t\t\t\t\t[\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tid: { kind, name, recordId },\n\t\t\t\t\t\t\tchanges: Object.keys( edits ).reduce(\n\t\t\t\t\t\t\t\t( acc, key ) => {\n\t\t\t\t\t\t\t\t\tacc[ key ] = {\n\t\t\t\t\t\t\t\t\t\tfrom: editedRecord[ key ],\n\t\t\t\t\t\t\t\t\t\tto: edits[ key ],\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t\treturn acc;\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t{}\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t\toptions.isCached\n\t\t\t\t);\n\t\t\t}\n\t\t\tdispatch( {\n\t\t\t\ttype: 'EDIT_ENTITY_RECORD',\n\t\t\t\t...edit,\n\t\t\t} );\n\t\t}\n\t};\n\n/**\n * Action triggered to undo the last edit to\n * an entity record, if any.\n */\nexport const undo =\n\t() =>\n\t( { select, dispatch } ) => {\n\t\tconst undoRecord = select.getUndoManager().undo();\n\t\tif ( ! undoRecord ) {\n\t\t\treturn;\n\t\t}\n\t\tdispatch( {\n\t\t\ttype: 'UNDO',\n\t\t\trecord: undoRecord,\n\t\t} );\n\t};\n\n/**\n * Action triggered to redo the last undone\n * edit to an entity record, if any.\n */\nexport const redo =\n\t() =>\n\t( { select, dispatch } ) => {\n\t\tconst redoRecord = select.getUndoManager().redo();\n\t\tif ( ! redoRecord ) {\n\t\t\treturn;\n\t\t}\n\t\tdispatch( {\n\t\t\ttype: 'REDO',\n\t\t\trecord: redoRecord,\n\t\t} );\n\t};\n\n/**\n * Forces the creation of a new undo level.\n *\n * @return {Object} Action object.\n */\nexport const __unstableCreateUndoLevel =\n\t() =>\n\t( { select } ) => {\n\t\tselect.getUndoManager().addRecord();\n\t};\n\n/**\n * Action triggered to save an entity record.\n *\n * @param {string}   kind                         Kind of the received entity.\n * @param {string}   name                         Name of the received entity.\n * @param {Object}   record                       Record to be saved.\n * @param {Object}   options                      Saving options.\n * @param {boolean}  [options.isAutosave=false]   Whether this is an autosave.\n * @param {Function} [options.__unstableFetch]    Internal use only. Function to\n *                                                call instead of `apiFetch()`.\n *                                                Must return a promise.\n * @param {boolean}  [options.throwOnError=false] If false, this action suppresses all\n *                                                the exceptions. Defaults to false.\n */\nexport const saveEntityRecord =\n\t(\n\t\tkind,\n\t\tname,\n\t\trecord,\n\t\t{\n\t\t\tisAutosave = false,\n\t\t\t__unstableFetch = apiFetch,\n\t\t\tthrowOnError = false,\n\t\t} = {}\n\t) =>\n\tasync ( { select, resolveSelect, dispatch } ) => {\n\t\tconst configs = await resolveSelect.getEntitiesConfig( kind );\n\t\tconst entityConfig = configs.find(\n\t\t\t( config ) => config.kind === kind && config.name === name\n\t\t);\n\t\tif ( ! entityConfig ) {\n\t\t\treturn;\n\t\t}\n\t\tconst entityIdKey = entityConfig.key || DEFAULT_ENTITY_KEY;\n\t\tconst recordId = record[ entityIdKey ];\n\n\t\tconst lock = await dispatch.__unstableAcquireStoreLock(\n\t\t\tSTORE_NAME,\n\t\t\t[ 'entities', 'records', kind, name, recordId || uuid() ],\n\t\t\t{ exclusive: true }\n\t\t);\n\n\t\ttry {\n\t\t\t// Evaluate optimized edits.\n\t\t\t// (Function edits that should be evaluated on save to avoid expensive computations on every edit.)\n\t\t\tfor ( const [ key, value ] of Object.entries( record ) ) {\n\t\t\t\tif ( typeof value === 'function' ) {\n\t\t\t\t\tconst evaluatedValue = value(\n\t\t\t\t\t\tselect.getEditedEntityRecord( kind, name, recordId )\n\t\t\t\t\t);\n\t\t\t\t\tdispatch.editEntityRecord(\n\t\t\t\t\t\tkind,\n\t\t\t\t\t\tname,\n\t\t\t\t\t\trecordId,\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t[ key ]: evaluatedValue,\n\t\t\t\t\t\t},\n\t\t\t\t\t\t{ undoIgnore: true }\n\t\t\t\t\t);\n\t\t\t\t\trecord[ key ] = evaluatedValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tdispatch( {\n\t\t\t\ttype: 'SAVE_ENTITY_RECORD_START',\n\t\t\t\tkind,\n\t\t\t\tname,\n\t\t\t\trecordId,\n\t\t\t\tisAutosave,\n\t\t\t} );\n\t\t\tlet updatedRecord;\n\t\t\tlet error;\n\t\t\tlet hasError = false;\n\t\t\ttry {\n\t\t\t\tconst path = `${ entityConfig.baseURL }${\n\t\t\t\t\trecordId ? '/' + recordId : ''\n\t\t\t\t}`;\n\t\t\t\tconst persistedRecord = select.getRawEntityRecord(\n\t\t\t\t\tkind,\n\t\t\t\t\tname,\n\t\t\t\t\trecordId\n\t\t\t\t);\n\n\t\t\t\tif ( isAutosave ) {\n\t\t\t\t\t// Most of this autosave logic is very specific to posts.\n\t\t\t\t\t// This is fine for now as it is the only supported autosave,\n\t\t\t\t\t// but ideally this should all be handled in the back end,\n\t\t\t\t\t// so the client just sends and receives objects.\n\t\t\t\t\tconst currentUser = select.getCurrentUser();\n\t\t\t\t\tconst currentUserId = currentUser\n\t\t\t\t\t\t? currentUser.id\n\t\t\t\t\t\t: undefined;\n\t\t\t\t\tconst autosavePost = await resolveSelect.getAutosave(\n\t\t\t\t\t\tpersistedRecord.type,\n\t\t\t\t\t\tpersistedRecord.id,\n\t\t\t\t\t\tcurrentUserId\n\t\t\t\t\t);\n\t\t\t\t\t// Autosaves need all expected fields to be present.\n\t\t\t\t\t// So we fallback to the previous autosave and then\n\t\t\t\t\t// to the actual persisted entity if the edits don't\n\t\t\t\t\t// have a value.\n\t\t\t\t\tlet data = {\n\t\t\t\t\t\t...persistedRecord,\n\t\t\t\t\t\t...autosavePost,\n\t\t\t\t\t\t...record,\n\t\t\t\t\t};\n\t\t\t\t\tdata = Object.keys( data ).reduce(\n\t\t\t\t\t\t( acc, key ) => {\n\t\t\t\t\t\t\tif (\n\t\t\t\t\t\t\t\t[\n\t\t\t\t\t\t\t\t\t'title',\n\t\t\t\t\t\t\t\t\t'excerpt',\n\t\t\t\t\t\t\t\t\t'content',\n\t\t\t\t\t\t\t\t\t'meta',\n\t\t\t\t\t\t\t\t].includes( key )\n\t\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t\tacc[ key ] = data[ key ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn acc;\n\t\t\t\t\t\t},\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t// Do not update the `status` if we have edited it when auto saving.\n\t\t\t\t\t\t\t// It's very important to let the user explicitly save this change,\n\t\t\t\t\t\t\t// because it can lead to unexpected results. An example would be to\n\t\t\t\t\t\t\t// have a draft post and change the status to publish.\n\t\t\t\t\t\t\tstatus:\n\t\t\t\t\t\t\t\tdata.status === 'auto-draft'\n\t\t\t\t\t\t\t\t\t? 'draft'\n\t\t\t\t\t\t\t\t\t: undefined,\n\t\t\t\t\t\t}\n\t\t\t\t\t);\n\t\t\t\t\tupdatedRecord = await __unstableFetch( {\n\t\t\t\t\t\tpath: `${ path }/autosaves`,\n\t\t\t\t\t\tmethod: 'POST',\n\t\t\t\t\t\tdata,\n\t\t\t\t\t} );\n\n\t\t\t\t\t// An autosave may be processed by the server as a regular save\n\t\t\t\t\t// when its update is requested by the author and the post had\n\t\t\t\t\t// draft or auto-draft status.\n\t\t\t\t\tif ( persistedRecord.id === updatedRecord.id ) {\n\t\t\t\t\t\tlet newRecord = {\n\t\t\t\t\t\t\t...persistedRecord,\n\t\t\t\t\t\t\t...data,\n\t\t\t\t\t\t\t...updatedRecord,\n\t\t\t\t\t\t};\n\t\t\t\t\t\tnewRecord = Object.keys( newRecord ).reduce(\n\t\t\t\t\t\t\t( acc, key ) => {\n\t\t\t\t\t\t\t\t// These properties are persisted in autosaves.\n\t\t\t\t\t\t\t\tif (\n\t\t\t\t\t\t\t\t\t[ 'title', 'excerpt', 'content' ].includes(\n\t\t\t\t\t\t\t\t\t\tkey\n\t\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t\t\tacc[ key ] = newRecord[ key ];\n\t\t\t\t\t\t\t\t} else if ( key === 'status' ) {\n\t\t\t\t\t\t\t\t\t// Status is only persisted in autosaves when going from\n\t\t\t\t\t\t\t\t\t// \"auto-draft\" to \"draft\".\n\t\t\t\t\t\t\t\t\tacc[ key ] =\n\t\t\t\t\t\t\t\t\t\tpersistedRecord.status ===\n\t\t\t\t\t\t\t\t\t\t\t'auto-draft' &&\n\t\t\t\t\t\t\t\t\t\tnewRecord.status === 'draft'\n\t\t\t\t\t\t\t\t\t\t\t? newRecord.status\n\t\t\t\t\t\t\t\t\t\t\t: persistedRecord.status;\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\t// These properties are not persisted in autosaves.\n\t\t\t\t\t\t\t\t\tacc[ key ] = persistedRecord[ key ];\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\treturn acc;\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t{}\n\t\t\t\t\t\t);\n\t\t\t\t\t\tdispatch.receiveEntityRecords(\n\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\tnewRecord,\n\t\t\t\t\t\t\tundefined,\n\t\t\t\t\t\t\ttrue\n\t\t\t\t\t\t);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tdispatch.receiveAutosaves(\n\t\t\t\t\t\t\tpersistedRecord.id,\n\t\t\t\t\t\t\tupdatedRecord\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tlet edits = record;\n\t\t\t\t\tif ( entityConfig.__unstablePrePersist ) {\n\t\t\t\t\t\tedits = {\n\t\t\t\t\t\t\t...edits,\n\t\t\t\t\t\t\t...entityConfig.__unstablePrePersist(\n\t\t\t\t\t\t\t\tpersistedRecord,\n\t\t\t\t\t\t\t\tedits\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t\tupdatedRecord = await __unstableFetch( {\n\t\t\t\t\t\tpath,\n\t\t\t\t\t\tmethod: recordId ? 'PUT' : 'POST',\n\t\t\t\t\t\tdata: edits,\n\t\t\t\t\t} );\n\t\t\t\t\tdispatch.receiveEntityRecords(\n\t\t\t\t\t\tkind,\n\t\t\t\t\t\tname,\n\t\t\t\t\t\tupdatedRecord,\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\ttrue,\n\t\t\t\t\t\tedits\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t} catch ( _error ) {\n\t\t\t\thasError = true;\n\t\t\t\terror = _error;\n\t\t\t}\n\t\t\tdispatch( {\n\t\t\t\ttype: 'SAVE_ENTITY_RECORD_FINISH',\n\t\t\t\tkind,\n\t\t\t\tname,\n\t\t\t\trecordId,\n\t\t\t\terror,\n\t\t\t\tisAutosave,\n\t\t\t} );\n\n\t\t\tif ( hasError && throwOnError ) {\n\t\t\t\tthrow error;\n\t\t\t}\n\n\t\t\treturn updatedRecord;\n\t\t} finally {\n\t\t\tdispatch.__unstableReleaseStoreLock( lock );\n\t\t}\n\t};\n\n/**\n * Runs multiple core-data actions at the same time using one API request.\n *\n * Example:\n *\n * ```\n * const [ savedRecord, updatedRecord, deletedRecord ] =\n *   await dispatch( 'core' ).__experimentalBatch( [\n *     ( { saveEntityRecord } ) => saveEntityRecord( 'root', 'widget', widget ),\n *     ( { saveEditedEntityRecord } ) => saveEntityRecord( 'root', 'widget', 123 ),\n *     ( { deleteEntityRecord } ) => deleteEntityRecord( 'root', 'widget', 123, null ),\n *   ] );\n * ```\n *\n * @param {Array} requests Array of functions which are invoked simultaneously.\n *                         Each function is passed an object containing\n *                         `saveEntityRecord`, `saveEditedEntityRecord`, and\n *                         `deleteEntityRecord`.\n *\n * @return {(thunkArgs: Object) => Promise} A promise that resolves to an array containing the return\n *                                          values of each function given in `requests`.\n */\nexport const __experimentalBatch =\n\t( requests ) =>\n\tasync ( { dispatch } ) => {\n\t\tconst batch = createBatch();\n\t\tconst api = {\n\t\t\tsaveEntityRecord( kind, name, record, options ) {\n\t\t\t\treturn batch.add( ( add ) =>\n\t\t\t\t\tdispatch.saveEntityRecord( kind, name, record, {\n\t\t\t\t\t\t...options,\n\t\t\t\t\t\t__unstableFetch: add,\n\t\t\t\t\t} )\n\t\t\t\t);\n\t\t\t},\n\t\t\tsaveEditedEntityRecord( kind, name, recordId, options ) {\n\t\t\t\treturn batch.add( ( add ) =>\n\t\t\t\t\tdispatch.saveEditedEntityRecord( kind, name, recordId, {\n\t\t\t\t\t\t...options,\n\t\t\t\t\t\t__unstableFetch: add,\n\t\t\t\t\t} )\n\t\t\t\t);\n\t\t\t},\n\t\t\tdeleteEntityRecord( kind, name, recordId, query, options ) {\n\t\t\t\treturn batch.add( ( add ) =>\n\t\t\t\t\tdispatch.deleteEntityRecord( kind, name, recordId, query, {\n\t\t\t\t\t\t...options,\n\t\t\t\t\t\t__unstableFetch: add,\n\t\t\t\t\t} )\n\t\t\t\t);\n\t\t\t},\n\t\t};\n\t\tconst resultPromises = requests.map( ( request ) => request( api ) );\n\t\tconst [ , ...results ] = await Promise.all( [\n\t\t\tbatch.run(),\n\t\t\t...resultPromises,\n\t\t] );\n\t\treturn results;\n\t};\n\n/**\n * Action triggered to save an entity record's edits.\n *\n * @param {string}  kind     Kind of the entity.\n * @param {string}  name     Name of the entity.\n * @param {Object}  recordId ID of the record.\n * @param {Object=} options  Saving options.\n */\nexport const saveEditedEntityRecord =\n\t( kind, name, recordId, options ) =>\n\tasync ( { select, dispatch, resolveSelect } ) => {\n\t\tif ( ! select.hasEditsForEntityRecord( kind, name, recordId ) ) {\n\t\t\treturn;\n\t\t}\n\t\tconst configs = await resolveSelect.getEntitiesConfig( kind );\n\t\tconst entityConfig = configs.find(\n\t\t\t( config ) => config.kind === kind && config.name === name\n\t\t);\n\t\tif ( ! entityConfig ) {\n\t\t\treturn;\n\t\t}\n\t\tconst entityIdKey = entityConfig.key || DEFAULT_ENTITY_KEY;\n\n\t\tconst edits = select.getEntityRecordNonTransientEdits(\n\t\t\tkind,\n\t\t\tname,\n\t\t\trecordId\n\t\t);\n\t\tconst record = { [ entityIdKey ]: recordId, ...edits };\n\t\treturn await dispatch.saveEntityRecord( kind, name, record, options );\n\t};\n\n/**\n * Action triggered to save only specified properties for the entity.\n *\n * @param {string}        kind        Kind of the entity.\n * @param {string}        name        Name of the entity.\n * @param {number|string} recordId    ID of the record.\n * @param {Array}         itemsToSave List of entity properties or property paths to save.\n * @param {Object}        options     Saving options.\n */\nexport const __experimentalSaveSpecifiedEntityEdits =\n\t( kind, name, recordId, itemsToSave, options ) =>\n\tasync ( { select, dispatch, resolveSelect } ) => {\n\t\tif ( ! select.hasEditsForEntityRecord( kind, name, recordId ) ) {\n\t\t\treturn;\n\t\t}\n\t\tconst edits = select.getEntityRecordNonTransientEdits(\n\t\t\tkind,\n\t\t\tname,\n\t\t\trecordId\n\t\t);\n\t\tconst editsToSave = {};\n\n\t\tfor ( const item of itemsToSave ) {\n\t\t\tsetNestedValue( editsToSave, item, getNestedValue( edits, item ) );\n\t\t}\n\n\t\tconst configs = await resolveSelect.getEntitiesConfig( kind );\n\t\tconst entityConfig = configs.find(\n\t\t\t( config ) => config.kind === kind && config.name === name\n\t\t);\n\n\t\tconst entityIdKey = entityConfig?.key || DEFAULT_ENTITY_KEY;\n\n\t\t// If a record key is provided then update the existing record.\n\t\t// This necessitates providing `recordKey` to saveEntityRecord as part of the\n\t\t// `record` argument (here called `editsToSave`) to stop that action creating\n\t\t// a new record and instead cause it to update the existing record.\n\t\tif ( recordId ) {\n\t\t\teditsToSave[ entityIdKey ] = recordId;\n\t\t}\n\t\treturn await dispatch.saveEntityRecord(\n\t\t\tkind,\n\t\t\tname,\n\t\t\teditsToSave,\n\t\t\toptions\n\t\t);\n\t};\n\n/**\n * Returns an action object used in signalling that Upload permissions have been received.\n *\n * @deprecated since WP 5.9, use receiveUserPermission instead.\n *\n * @param {boolean} hasUploadPermissions Does the user have permission to upload files?\n *\n * @return {Object} Action object.\n */\nexport function receiveUploadPermissions( hasUploadPermissions ) {\n\tdeprecated( \"wp.data.dispatch( 'core' ).receiveUploadPermissions\", {\n\t\tsince: '5.9',\n\t\talternative: 'receiveUserPermission',\n\t} );\n\n\treturn receiveUserPermission( 'create/media', hasUploadPermissions );\n}\n\n/**\n * Returns an action object used in signalling that the current user has\n * permission to perform an action on a REST resource.\n * Ignored from documentation as it's internal to the data store.\n *\n * @ignore\n *\n * @param {string}  key       A key that represents the action and REST resource.\n * @param {boolean} isAllowed Whether or not the user can perform the action.\n *\n * @return {Object} Action object.\n */\nexport function receiveUserPermission( key, isAllowed ) {\n\treturn {\n\t\ttype: 'RECEIVE_USER_PERMISSION',\n\t\tkey,\n\t\tisAllowed,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that the current user has\n * permission to perform an action on a REST resource. Ignored from\n * documentation as it's internal to the data store.\n *\n * @ignore\n *\n * @param {Object<string, boolean>} permissions An object where keys represent\n *                                              actions and REST resources, and\n *                                              values indicate whether the user\n *                                              is allowed to perform the\n *                                              action.\n *\n * @return {Object} Action object.\n */\nexport function receiveUserPermissions( permissions ) {\n\treturn {\n\t\ttype: 'RECEIVE_USER_PERMISSIONS',\n\t\tpermissions,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that the autosaves for a\n * post have been received.\n * Ignored from documentation as it's internal to the data store.\n *\n * @ignore\n *\n * @param {number}       postId    The id of the post that is parent to the autosave.\n * @param {Array|Object} autosaves An array of autosaves or singular autosave object.\n *\n * @return {Object} Action object.\n */\nexport function receiveAutosaves( postId, autosaves ) {\n\treturn {\n\t\ttype: 'RECEIVE_AUTOSAVES',\n\t\tpostId,\n\t\tautosaves: Array.isArray( autosaves ) ? autosaves : [ autosaves ],\n\t};\n}\n\n/**\n * Returns an action object signalling that the fallback Navigation\n * Menu id has been received.\n *\n * @param {integer} fallbackId the id of the fallback Navigation Menu\n * @return {Object} Action object.\n */\nexport function receiveNavigationFallbackId( fallbackId ) {\n\treturn {\n\t\ttype: 'RECEIVE_NAVIGATION_FALLBACK_ID',\n\t\tfallbackId,\n\t};\n}\n\n/**\n * Returns an action object used to set the template for a given query.\n *\n * @param {Object} query      The lookup query.\n * @param {string} templateId The resolved template id.\n *\n * @return {Object} Action object.\n */\nexport function receiveDefaultTemplateId( query, templateId ) {\n\treturn {\n\t\ttype: 'RECEIVE_DEFAULT_TEMPLATE',\n\t\tquery,\n\t\ttemplateId,\n\t};\n}\n\n/**\n * Action triggered to receive revision items.\n *\n * @param {string}        kind            Kind of the received entity record revisions.\n * @param {string}        name            Name of the received entity record revisions.\n * @param {number|string} recordKey       The key of the entity record whose revisions you want to fetch.\n * @param {Array|Object}  records         Revisions received.\n * @param {?Object}       query           Query Object.\n * @param {?boolean}      invalidateCache Should invalidate query caches.\n * @param {?Object}       meta            Meta information about pagination.\n */\nexport const receiveRevisions =\n\t( kind, name, recordKey, records, query, invalidateCache = false, meta ) =>\n\tasync ( { dispatch, resolveSelect } ) => {\n\t\tconst configs = await resolveSelect.getEntitiesConfig( kind );\n\t\tconst entityConfig = configs.find(\n\t\t\t( config ) => config.kind === kind && config.name === name\n\t\t);\n\t\tconst key =\n\t\t\tentityConfig && entityConfig?.revisionKey\n\t\t\t\t? entityConfig.revisionKey\n\t\t\t\t: DEFAULT_ENTITY_KEY;\n\n\t\tdispatch( {\n\t\t\ttype: 'RECEIVE_ITEM_REVISIONS',\n\t\t\tkey,\n\t\t\titems: Array.isArray( records ) ? records : [ records ],\n\t\t\trecordKey,\n\t\t\tmeta,\n\t\t\tquery,\n\t\t\tkind,\n\t\t\tname,\n\t\t\tinvalidateCache,\n\t\t} );\n\t};\n","/**\n * Returns an action object used in signalling that the registered post meta\n * fields for a post type have been received.\n *\n * @param {string} postType           Post type slug.\n * @param {Object} registeredPostMeta Registered post meta.\n *\n * @return {Object} Action object.\n */\nexport function receiveRegisteredPostMeta( postType, registeredPostMeta ) {\n\treturn {\n\t\ttype: 'RECEIVE_REGISTERED_POST_META',\n\t\tpostType,\n\t\tregisteredPostMeta,\n\t};\n}\n","import {\n  pascalCase,\n  pascalCaseTransform,\n  pascalCaseTransformMerge,\n  Options,\n} from \"pascal-case\";\n\nexport { Options };\n\nexport function camelCaseTransform(input: string, index: number) {\n  if (index === 0) return input.toLowerCase();\n  return pascalCaseTransform(input, index);\n}\n\nexport function camelCaseTransformMerge(input: string, index: number) {\n  if (index === 0) return input.toLowerCase();\n  return pascalCaseTransformMerge(input);\n}\n\nexport function camelCase(input: string, options: Options = {}) {\n  return pascalCase(input, {\n    transform: camelCaseTransform,\n    ...options,\n  });\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"htmlEntities\"];","/**\n * Higher-order function which forward the resolution to another resolver with the same arguments.\n *\n * @param {string} resolverName forwarded resolver.\n *\n * @return {Function} Enhanced resolver.\n */\nconst forwardResolver =\n\t( resolverName ) =>\n\t( ...args ) =>\n\tasync ( { resolveSelect } ) => {\n\t\tawait resolveSelect[ resolverName ]( ...args );\n\t};\n\nexport default forwardResolver;\n","export const RECEIVE_INTERMEDIATE_RESULTS = Symbol(\n\t'RECEIVE_INTERMEDIATE_RESULTS'\n);\n","/**\n * WordPress dependencies\n */\nimport apiFetch from '@wordpress/api-fetch';\nimport { addQueryArgs } from '@wordpress/url';\nimport { decodeEntities } from '@wordpress/html-entities';\nimport { __ } from '@wordpress/i18n';\n\nexport type SearchOptions = {\n\t/**\n\t * Displays initial search suggestions, when true.\n\t */\n\tisInitialSuggestions?: boolean;\n\t/**\n\t * Search options for initial suggestions.\n\t */\n\tinitialSuggestionsSearchOptions?: Omit<\n\t\tSearchOptions,\n\t\t'isInitialSuggestions' | 'initialSuggestionsSearchOptions'\n\t>;\n\t/**\n\t * Filters by search type.\n\t */\n\ttype?: 'attachment' | 'post' | 'term' | 'post-format';\n\t/**\n\t * Slug of the post-type or taxonomy.\n\t */\n\tsubtype?: string;\n\t/**\n\t * Which page of results to return.\n\t */\n\tpage?: number;\n\t/**\n\t * Search results per page.\n\t */\n\tperPage?: number;\n};\n\nexport type EditorSettings = {\n\t/**\n\t * Disables post formats, when true.\n\t */\n\tdisablePostFormats?: boolean;\n};\n\ntype SearchAPIResult = {\n\tid: number;\n\ttitle: string;\n\turl: string;\n\ttype: string;\n\tsubtype: string;\n};\n\ntype MediaAPIResult = {\n\tid: number;\n\ttitle: { rendered: string };\n\tsource_url: string;\n\ttype: string;\n};\n\nexport type SearchResult = {\n\t/**\n\t * Post or term id.\n\t */\n\tid: number;\n\t/**\n\t * Link url.\n\t */\n\turl: string;\n\t/**\n\t * Title of the link.\n\t */\n\ttitle: string;\n\t/**\n\t * The taxonomy or post type slug or type URL.\n\t */\n\ttype: string;\n\t/**\n\t * Link kind of post-type or taxonomy\n\t */\n\tkind?: string;\n};\n\n/**\n * Fetches link suggestions from the WordPress API.\n *\n * WordPress does not support searching multiple tables at once, e.g. posts and terms, so we\n * perform multiple queries at the same time and then merge the results together.\n *\n * @param search\n * @param searchOptions\n * @param editorSettings\n *\n * @example\n * ```js\n * import { __experimentalFetchLinkSuggestions as fetchLinkSuggestions } from '@wordpress/core-data';\n *\n * //...\n *\n * export function initialize( id, settings ) {\n *\n * settings.__experimentalFetchLinkSuggestions = (\n *     search,\n *     searchOptions\n * ) => fetchLinkSuggestions( search, searchOptions, settings );\n * ```\n */\nexport default async function fetchLinkSuggestions(\n\tsearch: string,\n\tsearchOptions: SearchOptions = {},\n\teditorSettings: EditorSettings = {}\n): Promise< SearchResult[] > {\n\tconst searchOptionsToUse =\n\t\tsearchOptions.isInitialSuggestions &&\n\t\tsearchOptions.initialSuggestionsSearchOptions\n\t\t\t? {\n\t\t\t\t\t...searchOptions,\n\t\t\t\t\t...searchOptions.initialSuggestionsSearchOptions,\n\t\t\t  }\n\t\t\t: searchOptions;\n\n\tconst {\n\t\ttype,\n\t\tsubtype,\n\t\tpage,\n\t\tperPage = searchOptions.isInitialSuggestions ? 3 : 20,\n\t} = searchOptionsToUse;\n\n\tconst { disablePostFormats = false } = editorSettings;\n\n\tconst queries: Promise< SearchResult[] >[] = [];\n\n\tif ( ! type || type === 'post' ) {\n\t\tqueries.push(\n\t\t\tapiFetch< SearchAPIResult[] >( {\n\t\t\t\tpath: addQueryArgs( '/wp/v2/search', {\n\t\t\t\t\tsearch,\n\t\t\t\t\tpage,\n\t\t\t\t\tper_page: perPage,\n\t\t\t\t\ttype: 'post',\n\t\t\t\t\tsubtype,\n\t\t\t\t} ),\n\t\t\t} )\n\t\t\t\t.then( ( results ) => {\n\t\t\t\t\treturn results.map( ( result ) => {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tid: result.id,\n\t\t\t\t\t\t\turl: result.url,\n\t\t\t\t\t\t\ttitle:\n\t\t\t\t\t\t\t\tdecodeEntities( result.title || '' ) ||\n\t\t\t\t\t\t\t\t__( '(no title)' ),\n\t\t\t\t\t\t\ttype: result.subtype || result.type,\n\t\t\t\t\t\t\tkind: 'post-type',\n\t\t\t\t\t\t};\n\t\t\t\t\t} );\n\t\t\t\t} )\n\t\t\t\t.catch( () => [] ) // Fail by returning no results.\n\t\t);\n\t}\n\n\tif ( ! type || type === 'term' ) {\n\t\tqueries.push(\n\t\t\tapiFetch< SearchAPIResult[] >( {\n\t\t\t\tpath: addQueryArgs( '/wp/v2/search', {\n\t\t\t\t\tsearch,\n\t\t\t\t\tpage,\n\t\t\t\t\tper_page: perPage,\n\t\t\t\t\ttype: 'term',\n\t\t\t\t\tsubtype,\n\t\t\t\t} ),\n\t\t\t} )\n\t\t\t\t.then( ( results ) => {\n\t\t\t\t\treturn results.map( ( result ) => {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tid: result.id,\n\t\t\t\t\t\t\turl: result.url,\n\t\t\t\t\t\t\ttitle:\n\t\t\t\t\t\t\t\tdecodeEntities( result.title || '' ) ||\n\t\t\t\t\t\t\t\t__( '(no title)' ),\n\t\t\t\t\t\t\ttype: result.subtype || result.type,\n\t\t\t\t\t\t\tkind: 'taxonomy',\n\t\t\t\t\t\t};\n\t\t\t\t\t} );\n\t\t\t\t} )\n\t\t\t\t.catch( () => [] ) // Fail by returning no results.\n\t\t);\n\t}\n\n\tif ( ! disablePostFormats && ( ! type || type === 'post-format' ) ) {\n\t\tqueries.push(\n\t\t\tapiFetch< SearchAPIResult[] >( {\n\t\t\t\tpath: addQueryArgs( '/wp/v2/search', {\n\t\t\t\t\tsearch,\n\t\t\t\t\tpage,\n\t\t\t\t\tper_page: perPage,\n\t\t\t\t\ttype: 'post-format',\n\t\t\t\t\tsubtype,\n\t\t\t\t} ),\n\t\t\t} )\n\t\t\t\t.then( ( results ) => {\n\t\t\t\t\treturn results.map( ( result ) => {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tid: result.id,\n\t\t\t\t\t\t\turl: result.url,\n\t\t\t\t\t\t\ttitle:\n\t\t\t\t\t\t\t\tdecodeEntities( result.title || '' ) ||\n\t\t\t\t\t\t\t\t__( '(no title)' ),\n\t\t\t\t\t\t\ttype: result.subtype || result.type,\n\t\t\t\t\t\t\tkind: 'taxonomy',\n\t\t\t\t\t\t};\n\t\t\t\t\t} );\n\t\t\t\t} )\n\t\t\t\t.catch( () => [] ) // Fail by returning no results.\n\t\t);\n\t}\n\n\tif ( ! type || type === 'attachment' ) {\n\t\tqueries.push(\n\t\t\tapiFetch< MediaAPIResult[] >( {\n\t\t\t\tpath: addQueryArgs( '/wp/v2/media', {\n\t\t\t\t\tsearch,\n\t\t\t\t\tpage,\n\t\t\t\t\tper_page: perPage,\n\t\t\t\t} ),\n\t\t\t} )\n\t\t\t\t.then( ( results ) => {\n\t\t\t\t\treturn results.map( ( result ) => {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tid: result.id,\n\t\t\t\t\t\t\turl: result.source_url,\n\t\t\t\t\t\t\ttitle:\n\t\t\t\t\t\t\t\tdecodeEntities( result.title.rendered || '' ) ||\n\t\t\t\t\t\t\t\t__( '(no title)' ),\n\t\t\t\t\t\t\ttype: result.type,\n\t\t\t\t\t\t\tkind: 'media',\n\t\t\t\t\t\t};\n\t\t\t\t\t} );\n\t\t\t\t} )\n\t\t\t\t.catch( () => [] ) // Fail by returning no results.\n\t\t);\n\t}\n\n\tconst responses = await Promise.all( queries );\n\n\tlet results = responses.flat();\n\tresults = results.filter( ( result ) => !! result.id );\n\tresults = sortResults( results, search );\n\tresults = results.slice( 0, perPage );\n\treturn results;\n}\n\n/**\n * Sort search results by relevance to the given query.\n *\n * Sorting is necessary as we're querying multiple endpoints and merging the results. For example\n * a taxonomy title might be more relevant than a post title, but by default taxonomy results will\n * be ordered after all the (potentially irrelevant) post results.\n *\n * We sort by scoring each result, where the score is the number of tokens in the title that are\n * also in the search query, divided by the total number of tokens in the title. This gives us a\n * score between 0 and 1, where 1 is a perfect match.\n *\n * @param results\n * @param search\n */\nexport function sortResults( results: SearchResult[], search: string ) {\n\tconst searchTokens = tokenize( search );\n\n\tconst scores = {};\n\tfor ( const result of results ) {\n\t\tif ( result.title ) {\n\t\t\tconst titleTokens = tokenize( result.title );\n\t\t\tconst exactMatchingTokens = titleTokens.filter( ( titleToken ) =>\n\t\t\t\tsearchTokens.some(\n\t\t\t\t\t( searchToken ) => titleToken === searchToken\n\t\t\t\t)\n\t\t\t);\n\t\t\tconst subMatchingTokens = titleTokens.filter( ( titleToken ) =>\n\t\t\t\tsearchTokens.some(\n\t\t\t\t\t( searchToken ) =>\n\t\t\t\t\t\ttitleToken !== searchToken &&\n\t\t\t\t\t\ttitleToken.includes( searchToken )\n\t\t\t\t)\n\t\t\t);\n\n\t\t\t// The score is a combination of exact matches and sub-matches.\n\t\t\t// More weight is given to exact matches, as they are more relevant (e.g. \"cat\" vs \"caterpillar\").\n\t\t\t// Diving by the total number of tokens in the title normalizes the score and skews\n\t\t\t// the results towards shorter titles.\n\t\t\tconst exactMatchScore =\n\t\t\t\t( exactMatchingTokens.length / titleTokens.length ) * 10;\n\n\t\t\tconst subMatchScore = subMatchingTokens.length / titleTokens.length;\n\n\t\t\tscores[ result.id ] = exactMatchScore + subMatchScore;\n\t\t} else {\n\t\t\tscores[ result.id ] = 0;\n\t\t}\n\t}\n\n\treturn results.sort( ( a, b ) => scores[ b.id ] - scores[ a.id ] );\n}\n\n/**\n * Turns text into an array of tokens, with whitespace and punctuation removed.\n *\n * For example, `\"I'm having a ball.\"` becomes `[ \"im\", \"having\", \"a\", \"ball\" ]`.\n *\n * @param text\n */\nexport function tokenize( text: string ): string[] {\n\t// \\p{L} matches any kind of letter from any language.\n\t// \\p{N} matches any kind of numeric character.\n\treturn text.toLowerCase().match( /[\\p{L}\\p{N}]+/gu ) || [];\n}\n","/**\n * WordPress dependencies\n */\nimport apiFetch from '@wordpress/api-fetch';\nimport {\n\taddQueryArgs,\n\tprependHTTP,\n\tisURL,\n\tgetProtocol,\n\tisValidProtocol,\n} from '@wordpress/url';\n\n/**\n * A simple in-memory cache for requests.\n * This avoids repeat HTTP requests which may be beneficial\n * for those wishing to preserve low-bandwidth.\n */\nconst CACHE = new Map();\n\n/**\n * @typedef WPRemoteUrlData\n *\n * @property {string} title contents of the remote URL's `<title>` tag.\n */\n\n/**\n * Fetches data about a remote URL.\n * eg: <title> tag, favicon...etc.\n *\n * @async\n * @param {string}  url     the URL to request details from.\n * @param {?Object} options any options to pass to the underlying fetch.\n * @example\n * ```js\n * import { __experimentalFetchUrlData as fetchUrlData } from '@wordpress/core-data';\n *\n * //...\n *\n * export function initialize( id, settings ) {\n *\n * settings.__experimentalFetchUrlData = (\n * url\n * ) => fetchUrlData( url );\n * ```\n * @return {Promise< WPRemoteUrlData[] >} Remote URL data.\n */\nconst fetchUrlData = async ( url, options = {} ) => {\n\tconst endpoint = '/wp-block-editor/v1/url-details';\n\n\tconst args = {\n\t\turl: prependHTTP( url ),\n\t};\n\n\tif ( ! isURL( url ) ) {\n\t\treturn Promise.reject( `${ url } is not a valid URL.` );\n\t}\n\n\t// Test for \"http\" based URL as it is possible for valid\n\t// yet unusable URLs such as `tel:123456` to be passed.\n\tconst protocol = getProtocol( url );\n\n\tif (\n\t\t! protocol ||\n\t\t! isValidProtocol( protocol ) ||\n\t\t! protocol.startsWith( 'http' ) ||\n\t\t! /^https?:\\/\\/[^\\/\\s]/i.test( url )\n\t) {\n\t\treturn Promise.reject(\n\t\t\t`${ url } does not have a valid protocol. URLs must be \"http\" based`\n\t\t);\n\t}\n\n\tif ( CACHE.has( url ) ) {\n\t\treturn CACHE.get( url );\n\t}\n\n\treturn apiFetch( {\n\t\tpath: addQueryArgs( endpoint, args ),\n\t\t...options,\n\t} ).then( ( res ) => {\n\t\tCACHE.set( url, res );\n\t\treturn res;\n\t} );\n};\n\nexport default fetchUrlData;\n","/**\n * External dependencies\n */\nimport { camelCase } from 'change-case';\n\n/**\n * WordPress dependencies\n */\nimport apiFetch from '@wordpress/api-fetch';\n\nexport { default as __experimentalFetchLinkSuggestions } from './__experimental-fetch-link-suggestions';\nexport { default as __experimentalFetchUrlData } from './__experimental-fetch-url-data';\n\nexport async function fetchBlockPatterns() {\n\tconst restPatterns = await apiFetch( {\n\t\tpath: '/wp/v2/block-patterns/patterns',\n\t} );\n\tif ( ! restPatterns ) {\n\t\treturn [];\n\t}\n\treturn restPatterns.map( ( pattern ) =>\n\t\tObject.fromEntries(\n\t\t\tObject.entries( pattern ).map( ( [ key, value ] ) => [\n\t\t\t\tcamelCase( key ),\n\t\t\t\tvalue,\n\t\t\t] )\n\t\t)\n\t);\n}\n","/**\n * External dependencies\n */\nimport { camelCase } from 'change-case';\n\n/**\n * WordPress dependencies\n */\nimport { addQueryArgs } from '@wordpress/url';\nimport { decodeEntities } from '@wordpress/html-entities';\nimport apiFetch from '@wordpress/api-fetch';\n\n/**\n * Internal dependencies\n */\nimport { STORE_NAME } from './name';\nimport { additionalEntityConfigLoaders, DEFAULT_ENTITY_KEY } from './entities';\nimport {\n\tforwardResolver,\n\tgetNormalizedCommaSeparable,\n\tgetUserPermissionCacheKey,\n\tgetUserPermissionsFromAllowHeader,\n\tALLOWED_RESOURCE_ACTIONS,\n\tRECEIVE_INTERMEDIATE_RESULTS,\n} from './utils';\nimport { getSyncProvider } from './sync';\nimport { fetchBlockPatterns } from './fetch';\n\n/**\n * Requests authors from the REST API.\n *\n * @param {Object|undefined} query Optional object of query parameters to\n *                                 include with request.\n */\nexport const getAuthors =\n\t( query ) =>\n\tasync ( { dispatch } ) => {\n\t\tconst path = addQueryArgs(\n\t\t\t'/wp/v2/users/?who=authors&per_page=100',\n\t\t\tquery\n\t\t);\n\t\tconst users = await apiFetch( { path } );\n\t\tdispatch.receiveUserQuery( path, users );\n\t};\n\n/**\n * Requests the current user from the REST API.\n */\nexport const getCurrentUser =\n\t() =>\n\tasync ( { dispatch } ) => {\n\t\tconst currentUser = await apiFetch( { path: '/wp/v2/users/me' } );\n\t\tdispatch.receiveCurrentUser( currentUser );\n\t};\n\n/**\n * Requests an entity's record from the REST API.\n *\n * @param {string}           kind  Entity kind.\n * @param {string}           name  Entity name.\n * @param {number|string}    key   Record's key\n * @param {Object|undefined} query Optional object of query parameters to\n *                                 include with request. If requesting specific\n *                                 fields, fields must always include the ID.\n */\nexport const getEntityRecord =\n\t( kind, name, key = '', query ) =>\n\tasync ( { select, dispatch, registry, resolveSelect } ) => {\n\t\tconst configs = await resolveSelect.getEntitiesConfig( kind );\n\t\tconst entityConfig = configs.find(\n\t\t\t( config ) => config.name === name && config.kind === kind\n\t\t);\n\t\tif ( ! entityConfig ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst lock = await dispatch.__unstableAcquireStoreLock(\n\t\t\tSTORE_NAME,\n\t\t\t[ 'entities', 'records', kind, name, key ],\n\t\t\t{ exclusive: false }\n\t\t);\n\n\t\ttry {\n\t\t\t// Entity supports configs,\n\t\t\t// use the sync algorithm instead of the old fetch behavior.\n\t\t\tif (\n\t\t\t\twindow.__experimentalEnableSync &&\n\t\t\t\tentityConfig.syncConfig &&\n\t\t\t\t! query\n\t\t\t) {\n\t\t\t\tif ( globalThis.IS_GUTENBERG_PLUGIN ) {\n\t\t\t\t\tconst objectId = entityConfig.getSyncObjectId( key );\n\n\t\t\t\t\t// Loads the persisted document.\n\t\t\t\t\tawait getSyncProvider().bootstrap(\n\t\t\t\t\t\tentityConfig.syncObjectType,\n\t\t\t\t\t\tobjectId,\n\t\t\t\t\t\t( record ) => {\n\t\t\t\t\t\t\tdispatch.receiveEntityRecords(\n\t\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\t\trecord,\n\t\t\t\t\t\t\t\tquery\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t);\n\n\t\t\t\t\t// Bootstraps the edited document as well (and load from peers).\n\t\t\t\t\tawait getSyncProvider().bootstrap(\n\t\t\t\t\t\tentityConfig.syncObjectType + '--edit',\n\t\t\t\t\t\tobjectId,\n\t\t\t\t\t\t( record ) => {\n\t\t\t\t\t\t\tdispatch( {\n\t\t\t\t\t\t\t\ttype: 'EDIT_ENTITY_RECORD',\n\t\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\t\trecordId: key,\n\t\t\t\t\t\t\t\tedits: record,\n\t\t\t\t\t\t\t\tmeta: {\n\t\t\t\t\t\t\t\t\tundo: undefined,\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t}\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif ( query !== undefined && query._fields ) {\n\t\t\t\t\t// If requesting specific fields, items and query association to said\n\t\t\t\t\t// records are stored by ID reference. Thus, fields must always include\n\t\t\t\t\t// the ID.\n\t\t\t\t\tquery = {\n\t\t\t\t\t\t...query,\n\t\t\t\t\t\t_fields: [\n\t\t\t\t\t\t\t...new Set( [\n\t\t\t\t\t\t\t\t...( getNormalizedCommaSeparable(\n\t\t\t\t\t\t\t\t\tquery._fields\n\t\t\t\t\t\t\t\t) || [] ),\n\t\t\t\t\t\t\t\tentityConfig.key || DEFAULT_ENTITY_KEY,\n\t\t\t\t\t\t\t] ),\n\t\t\t\t\t\t].join(),\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\t// Disable reason: While true that an early return could leave `path`\n\t\t\t\t// unused, it's important that path is derived using the query prior to\n\t\t\t\t// additional query modifications in the condition below, since those\n\t\t\t\t// modifications are relevant to how the data is tracked in state, and not\n\t\t\t\t// for how the request is made to the REST API.\n\n\t\t\t\t// eslint-disable-next-line @wordpress/no-unused-vars-before-return\n\t\t\t\tconst path = addQueryArgs(\n\t\t\t\t\tentityConfig.baseURL + ( key ? '/' + key : '' ),\n\t\t\t\t\t{\n\t\t\t\t\t\t...entityConfig.baseURLParams,\n\t\t\t\t\t\t...query,\n\t\t\t\t\t}\n\t\t\t\t);\n\n\t\t\t\tif ( query !== undefined && query._fields ) {\n\t\t\t\t\tquery = { ...query, include: [ key ] };\n\n\t\t\t\t\t// The resolution cache won't consider query as reusable based on the\n\t\t\t\t\t// fields, so it's tested here, prior to initiating the REST request,\n\t\t\t\t\t// and without causing `getEntityRecords` resolution to occur.\n\t\t\t\t\tconst hasRecords = select.hasEntityRecords(\n\t\t\t\t\t\tkind,\n\t\t\t\t\t\tname,\n\t\t\t\t\t\tquery\n\t\t\t\t\t);\n\t\t\t\t\tif ( hasRecords ) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tconst response = await apiFetch( { path, parse: false } );\n\t\t\t\tconst record = await response.json();\n\t\t\t\tconst permissions = getUserPermissionsFromAllowHeader(\n\t\t\t\t\tresponse.headers?.get( 'allow' )\n\t\t\t\t);\n\n\t\t\t\tconst canUserResolutionsArgs = [];\n\t\t\t\tconst receiveUserPermissionArgs = {};\n\t\t\t\tfor ( const action of ALLOWED_RESOURCE_ACTIONS ) {\n\t\t\t\t\treceiveUserPermissionArgs[\n\t\t\t\t\t\tgetUserPermissionCacheKey( action, {\n\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\tid: key,\n\t\t\t\t\t\t} )\n\t\t\t\t\t] = permissions[ action ];\n\n\t\t\t\t\tcanUserResolutionsArgs.push( [\n\t\t\t\t\t\taction,\n\t\t\t\t\t\t{ kind, name, id: key },\n\t\t\t\t\t] );\n\t\t\t\t}\n\n\t\t\t\tregistry.batch( () => {\n\t\t\t\t\tdispatch.receiveEntityRecords( kind, name, record, query );\n\t\t\t\t\tdispatch.receiveUserPermissions(\n\t\t\t\t\t\treceiveUserPermissionArgs\n\t\t\t\t\t);\n\t\t\t\t\tdispatch.finishResolutions(\n\t\t\t\t\t\t'canUser',\n\t\t\t\t\t\tcanUserResolutionsArgs\n\t\t\t\t\t);\n\t\t\t\t} );\n\t\t\t}\n\t\t} finally {\n\t\t\tdispatch.__unstableReleaseStoreLock( lock );\n\t\t}\n\t};\n\n/**\n * Requests an entity's record from the REST API.\n */\nexport const getRawEntityRecord = forwardResolver( 'getEntityRecord' );\n\n/**\n * Requests an entity's record from the REST API.\n */\nexport const getEditedEntityRecord = forwardResolver( 'getEntityRecord' );\n\n/**\n * Requests the entity's records from the REST API.\n *\n * @param {string}  kind  Entity kind.\n * @param {string}  name  Entity name.\n * @param {?Object} query Query Object. If requesting specific fields, fields\n *                        must always include the ID.\n */\nexport const getEntityRecords =\n\t( kind, name, query = {} ) =>\n\tasync ( { dispatch, registry, resolveSelect } ) => {\n\t\tconst configs = await resolveSelect.getEntitiesConfig( kind );\n\t\tconst entityConfig = configs.find(\n\t\t\t( config ) => config.name === name && config.kind === kind\n\t\t);\n\t\tif ( ! entityConfig ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst lock = await dispatch.__unstableAcquireStoreLock(\n\t\t\tSTORE_NAME,\n\t\t\t[ 'entities', 'records', kind, name ],\n\t\t\t{ exclusive: false }\n\t\t);\n\n\t\tconst key = entityConfig.key || DEFAULT_ENTITY_KEY;\n\n\t\tfunction getResolutionsArgs( records ) {\n\t\t\treturn records\n\t\t\t\t.filter( ( record ) => record?.[ key ] )\n\t\t\t\t.map( ( record ) => [ kind, name, record[ key ] ] );\n\t\t}\n\n\t\ttry {\n\t\t\tif ( query._fields ) {\n\t\t\t\t// If requesting specific fields, items and query association to said\n\t\t\t\t// records are stored by ID reference. Thus, fields must always include\n\t\t\t\t// the ID.\n\t\t\t\tquery = {\n\t\t\t\t\t...query,\n\t\t\t\t\t_fields: [\n\t\t\t\t\t\t...new Set( [\n\t\t\t\t\t\t\t...( getNormalizedCommaSeparable( query._fields ) ||\n\t\t\t\t\t\t\t\t[] ),\n\t\t\t\t\t\t\tentityConfig.key || DEFAULT_ENTITY_KEY,\n\t\t\t\t\t\t] ),\n\t\t\t\t\t].join(),\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tconst path = addQueryArgs( entityConfig.baseURL, {\n\t\t\t\t...entityConfig.baseURLParams,\n\t\t\t\t...query,\n\t\t\t} );\n\n\t\t\tlet records = [],\n\t\t\t\tmeta;\n\t\t\tif ( entityConfig.supportsPagination && query.per_page !== -1 ) {\n\t\t\t\tconst response = await apiFetch( { path, parse: false } );\n\t\t\t\trecords = Object.values( await response.json() );\n\t\t\t\tmeta = {\n\t\t\t\t\ttotalItems: parseInt(\n\t\t\t\t\t\tresponse.headers.get( 'X-WP-Total' )\n\t\t\t\t\t),\n\t\t\t\t\ttotalPages: parseInt(\n\t\t\t\t\t\tresponse.headers.get( 'X-WP-TotalPages' )\n\t\t\t\t\t),\n\t\t\t\t};\n\t\t\t} else if (\n\t\t\t\tquery.per_page === -1 &&\n\t\t\t\tquery[ RECEIVE_INTERMEDIATE_RESULTS ] === true\n\t\t\t) {\n\t\t\t\tlet page = 1;\n\t\t\t\tlet totalPages;\n\n\t\t\t\tdo {\n\t\t\t\t\tconst response = await apiFetch( {\n\t\t\t\t\t\tpath: addQueryArgs( path, { page, per_page: 100 } ),\n\t\t\t\t\t\tparse: false,\n\t\t\t\t\t} );\n\t\t\t\t\tconst pageRecords = Object.values( await response.json() );\n\n\t\t\t\t\ttotalPages = parseInt(\n\t\t\t\t\t\tresponse.headers.get( 'X-WP-TotalPages' )\n\t\t\t\t\t);\n\n\t\t\t\t\trecords.push( ...pageRecords );\n\t\t\t\t\tregistry.batch( () => {\n\t\t\t\t\t\tdispatch.receiveEntityRecords(\n\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\trecords,\n\t\t\t\t\t\t\tquery\n\t\t\t\t\t\t);\n\t\t\t\t\t\tdispatch.finishResolutions(\n\t\t\t\t\t\t\t'getEntityRecord',\n\t\t\t\t\t\t\tgetResolutionsArgs( pageRecords )\n\t\t\t\t\t\t);\n\t\t\t\t\t} );\n\t\t\t\t\tpage++;\n\t\t\t\t} while ( page <= totalPages );\n\n\t\t\t\tmeta = {\n\t\t\t\t\ttotalItems: records.length,\n\t\t\t\t\ttotalPages: 1,\n\t\t\t\t};\n\t\t\t} else {\n\t\t\t\trecords = Object.values( await apiFetch( { path } ) );\n\t\t\t\tmeta = {\n\t\t\t\t\ttotalItems: records.length,\n\t\t\t\t\ttotalPages: 1,\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// If we request fields but the result doesn't contain the fields,\n\t\t\t// explicitly set these fields as \"undefined\"\n\t\t\t// that way we consider the query \"fulfilled\".\n\t\t\tif ( query._fields ) {\n\t\t\t\trecords = records.map( ( record ) => {\n\t\t\t\t\tquery._fields.split( ',' ).forEach( ( field ) => {\n\t\t\t\t\t\tif ( ! record.hasOwnProperty( field ) ) {\n\t\t\t\t\t\t\trecord[ field ] = undefined;\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\n\t\t\t\t\treturn record;\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\tregistry.batch( () => {\n\t\t\t\tdispatch.receiveEntityRecords(\n\t\t\t\t\tkind,\n\t\t\t\t\tname,\n\t\t\t\t\trecords,\n\t\t\t\t\tquery,\n\t\t\t\t\tfalse,\n\t\t\t\t\tundefined,\n\t\t\t\t\tmeta\n\t\t\t\t);\n\n\t\t\t\t// When requesting all fields, the list of results can be used to resolve\n\t\t\t\t// the `getEntityRecord` and `canUser` selectors in addition to `getEntityRecords`.\n\t\t\t\t// See https://github.com/WordPress/gutenberg/pull/26575\n\t\t\t\t// See https://github.com/WordPress/gutenberg/pull/64504\n\t\t\t\tif ( ! query?._fields && ! query.context ) {\n\t\t\t\t\tconst targetHints = records\n\t\t\t\t\t\t.filter( ( record ) => record?.[ key ] )\n\t\t\t\t\t\t.map( ( record ) => ( {\n\t\t\t\t\t\t\tid: record[ key ],\n\t\t\t\t\t\t\tpermissions: getUserPermissionsFromAllowHeader(\n\t\t\t\t\t\t\t\trecord?._links?.self?.[ 0 ].targetHints.allow\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t} ) );\n\n\t\t\t\t\tconst canUserResolutionsArgs = [];\n\t\t\t\t\tconst receiveUserPermissionArgs = {};\n\t\t\t\t\tfor ( const targetHint of targetHints ) {\n\t\t\t\t\t\tfor ( const action of ALLOWED_RESOURCE_ACTIONS ) {\n\t\t\t\t\t\t\tcanUserResolutionsArgs.push( [\n\t\t\t\t\t\t\t\taction,\n\t\t\t\t\t\t\t\t{ kind, name, id: targetHint.id },\n\t\t\t\t\t\t\t] );\n\n\t\t\t\t\t\t\treceiveUserPermissionArgs[\n\t\t\t\t\t\t\t\tgetUserPermissionCacheKey( action, {\n\t\t\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\t\t\tid: targetHint.id,\n\t\t\t\t\t\t\t\t} )\n\t\t\t\t\t\t\t] = targetHint.permissions[ action ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tdispatch.receiveUserPermissions(\n\t\t\t\t\t\treceiveUserPermissionArgs\n\t\t\t\t\t);\n\t\t\t\t\tdispatch.finishResolutions(\n\t\t\t\t\t\t'getEntityRecord',\n\t\t\t\t\t\tgetResolutionsArgs( records )\n\t\t\t\t\t);\n\t\t\t\t\tdispatch.finishResolutions(\n\t\t\t\t\t\t'canUser',\n\t\t\t\t\t\tcanUserResolutionsArgs\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\tdispatch.__unstableReleaseStoreLock( lock );\n\t\t\t} );\n\t\t} catch ( e ) {\n\t\t\tdispatch.__unstableReleaseStoreLock( lock );\n\t\t}\n\t};\n\ngetEntityRecords.shouldInvalidate = ( action, kind, name ) => {\n\treturn (\n\t\t( action.type === 'RECEIVE_ITEMS' || action.type === 'REMOVE_ITEMS' ) &&\n\t\taction.invalidateCache &&\n\t\tkind === action.kind &&\n\t\tname === action.name\n\t);\n};\n\n/**\n * Requests the current theme.\n */\nexport const getCurrentTheme =\n\t() =>\n\tasync ( { dispatch, resolveSelect } ) => {\n\t\tconst activeThemes = await resolveSelect.getEntityRecords(\n\t\t\t'root',\n\t\t\t'theme',\n\t\t\t{ status: 'active' }\n\t\t);\n\n\t\tdispatch.receiveCurrentTheme( activeThemes[ 0 ] );\n\t};\n\n/**\n * Requests theme supports data from the index.\n */\nexport const getThemeSupports = forwardResolver( 'getCurrentTheme' );\n\n/**\n * Requests a preview from the Embed API.\n *\n * @param {string} url URL to get the preview for.\n */\nexport const getEmbedPreview =\n\t( url ) =>\n\tasync ( { dispatch } ) => {\n\t\ttry {\n\t\t\tconst embedProxyResponse = await apiFetch( {\n\t\t\t\tpath: addQueryArgs( '/oembed/1.0/proxy', { url } ),\n\t\t\t} );\n\t\t\tdispatch.receiveEmbedPreview( url, embedProxyResponse );\n\t\t} catch ( error ) {\n\t\t\t// Embed API 404s if the URL cannot be embedded, so we have to catch the error from the apiRequest here.\n\t\t\tdispatch.receiveEmbedPreview( url, false );\n\t\t}\n\t};\n\n/**\n * Checks whether the current user can perform the given action on the given\n * REST resource.\n *\n * @param {string}        requestedAction Action to check. One of: 'create', 'read', 'update',\n *                                        'delete'.\n * @param {string|Object} resource        Entity resource to check. Accepts entity object `{ kind: 'root', name: 'media', id: 1 }`\n *                                        or REST base as a string - `media`.\n * @param {?string}       id              ID of the rest resource to check.\n */\nexport const canUser =\n\t( requestedAction, resource, id ) =>\n\tasync ( { dispatch, registry, resolveSelect } ) => {\n\t\tif ( ! ALLOWED_RESOURCE_ACTIONS.includes( requestedAction ) ) {\n\t\t\tthrow new Error( `'${ requestedAction }' is not a valid action.` );\n\t\t}\n\n\t\tconst { hasStartedResolution } = registry.select( STORE_NAME );\n\n\t\t// Prevent resolving the same resource twice.\n\t\tfor ( const relatedAction of ALLOWED_RESOURCE_ACTIONS ) {\n\t\t\tif ( relatedAction === requestedAction ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst isAlreadyResolving = hasStartedResolution( 'canUser', [\n\t\t\t\trelatedAction,\n\t\t\t\tresource,\n\t\t\t\tid,\n\t\t\t] );\n\t\t\tif ( isAlreadyResolving ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\n\t\tlet resourcePath = null;\n\t\tif ( typeof resource === 'object' ) {\n\t\t\tif ( ! resource.kind || ! resource.name ) {\n\t\t\t\tthrow new Error( 'The entity resource object is not valid.' );\n\t\t\t}\n\n\t\t\tconst configs = await resolveSelect.getEntitiesConfig(\n\t\t\t\tresource.kind\n\t\t\t);\n\t\t\tconst entityConfig = configs.find(\n\t\t\t\t( config ) =>\n\t\t\t\t\tconfig.name === resource.name &&\n\t\t\t\t\tconfig.kind === resource.kind\n\t\t\t);\n\t\t\tif ( ! entityConfig ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tresourcePath =\n\t\t\t\tentityConfig.baseURL + ( resource.id ? '/' + resource.id : '' );\n\t\t} else {\n\t\t\tresourcePath = `/wp/v2/${ resource }` + ( id ? '/' + id : '' );\n\t\t}\n\n\t\tlet response;\n\t\ttry {\n\t\t\tresponse = await apiFetch( {\n\t\t\t\tpath: resourcePath,\n\t\t\t\tmethod: 'OPTIONS',\n\t\t\t\tparse: false,\n\t\t\t} );\n\t\t} catch ( error ) {\n\t\t\t// Do nothing if our OPTIONS request comes back with an API error (4xx or\n\t\t\t// 5xx). The previously determined isAllowed value will remain in the store.\n\t\t\treturn;\n\t\t}\n\n\t\t// Optional chaining operator is used here because the API requests don't\n\t\t// return the expected result in the React native version. Instead, API requests\n\t\t// only return the result, without including response properties like the headers.\n\t\tconst permissions = getUserPermissionsFromAllowHeader(\n\t\t\tresponse.headers?.get( 'allow' )\n\t\t);\n\t\tregistry.batch( () => {\n\t\t\tfor ( const action of ALLOWED_RESOURCE_ACTIONS ) {\n\t\t\t\tconst key = getUserPermissionCacheKey( action, resource, id );\n\n\t\t\t\tdispatch.receiveUserPermission( key, permissions[ action ] );\n\n\t\t\t\t// Mark related action resolutions as finished.\n\t\t\t\tif ( action !== requestedAction ) {\n\t\t\t\t\tdispatch.finishResolution( 'canUser', [\n\t\t\t\t\t\taction,\n\t\t\t\t\t\tresource,\n\t\t\t\t\t\tid,\n\t\t\t\t\t] );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t};\n\n/**\n * Checks whether the current user can perform the given action on the given\n * REST resource.\n *\n * @param {string}        kind     Entity kind.\n * @param {string}        name     Entity name.\n * @param {number|string} recordId Record's id.\n */\nexport const canUserEditEntityRecord =\n\t( kind, name, recordId ) =>\n\tasync ( { dispatch } ) => {\n\t\tawait dispatch( canUser( 'update', { kind, name, id: recordId } ) );\n\t};\n\n/**\n * Request autosave data from the REST API.\n *\n * @param {string} postType The type of the parent post.\n * @param {number} postId   The id of the parent post.\n */\nexport const getAutosaves =\n\t( postType, postId ) =>\n\tasync ( { dispatch, resolveSelect } ) => {\n\t\tconst {\n\t\t\trest_base: restBase,\n\t\t\trest_namespace: restNamespace = 'wp/v2',\n\t\t\tsupports,\n\t\t} = await resolveSelect.getPostType( postType );\n\t\tif ( ! supports?.autosave ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst autosaves = await apiFetch( {\n\t\t\tpath: `/${ restNamespace }/${ restBase }/${ postId }/autosaves?context=edit`,\n\t\t} );\n\n\t\tif ( autosaves && autosaves.length ) {\n\t\t\tdispatch.receiveAutosaves( postId, autosaves );\n\t\t}\n\t};\n\n/**\n * Request autosave data from the REST API.\n *\n * This resolver exists to ensure the underlying autosaves are fetched via\n * `getAutosaves` when a call to the `getAutosave` selector is made.\n *\n * @param {string} postType The type of the parent post.\n * @param {number} postId   The id of the parent post.\n */\nexport const getAutosave =\n\t( postType, postId ) =>\n\tasync ( { resolveSelect } ) => {\n\t\tawait resolveSelect.getAutosaves( postType, postId );\n\t};\n\nexport const __experimentalGetCurrentGlobalStylesId =\n\t() =>\n\tasync ( { dispatch, resolveSelect } ) => {\n\t\tconst activeThemes = await resolveSelect.getEntityRecords(\n\t\t\t'root',\n\t\t\t'theme',\n\t\t\t{ status: 'active' }\n\t\t);\n\t\tconst globalStylesURL =\n\t\t\tactiveThemes?.[ 0 ]?._links?.[ 'wp:user-global-styles' ]?.[ 0 ]\n\t\t\t\t?.href;\n\t\tif ( ! globalStylesURL ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Regex matches the ID at the end of a URL or immediately before\n\t\t// the query string.\n\t\tconst matches = globalStylesURL.match( /\\/(\\d+)(?:\\?|$)/ );\n\t\tconst id = matches ? Number( matches[ 1 ] ) : null;\n\n\t\tif ( id ) {\n\t\t\tdispatch.__experimentalReceiveCurrentGlobalStylesId( id );\n\t\t}\n\t};\n\nexport const __experimentalGetCurrentThemeBaseGlobalStyles =\n\t() =>\n\tasync ( { resolveSelect, dispatch } ) => {\n\t\tconst currentTheme = await resolveSelect.getCurrentTheme();\n\t\t// Please adjust the preloaded requests if this changes!\n\t\tconst themeGlobalStyles = await apiFetch( {\n\t\t\tpath: `/wp/v2/global-styles/themes/${ currentTheme.stylesheet }?context=view`,\n\t\t} );\n\t\tdispatch.__experimentalReceiveThemeBaseGlobalStyles(\n\t\t\tcurrentTheme.stylesheet,\n\t\t\tthemeGlobalStyles\n\t\t);\n\t};\n\nexport const __experimentalGetCurrentThemeGlobalStylesVariations =\n\t() =>\n\tasync ( { resolveSelect, dispatch } ) => {\n\t\tconst currentTheme = await resolveSelect.getCurrentTheme();\n\t\t// Please adjust the preloaded requests if this changes!\n\t\tconst variations = await apiFetch( {\n\t\t\tpath: `/wp/v2/global-styles/themes/${ currentTheme.stylesheet }/variations?context=view`,\n\t\t} );\n\t\tdispatch.__experimentalReceiveThemeGlobalStyleVariations(\n\t\t\tcurrentTheme.stylesheet,\n\t\t\tvariations\n\t\t);\n\t};\n\n/**\n * Fetches and returns the revisions of the current global styles theme.\n */\nexport const getCurrentThemeGlobalStylesRevisions =\n\t() =>\n\tasync ( { resolveSelect, dispatch } ) => {\n\t\tconst globalStylesId =\n\t\t\tawait resolveSelect.__experimentalGetCurrentGlobalStylesId();\n\t\tconst record = globalStylesId\n\t\t\t? await resolveSelect.getEntityRecord(\n\t\t\t\t\t'root',\n\t\t\t\t\t'globalStyles',\n\t\t\t\t\tglobalStylesId\n\t\t\t  )\n\t\t\t: undefined;\n\t\tconst revisionsURL = record?._links?.[ 'version-history' ]?.[ 0 ]?.href;\n\n\t\tif ( revisionsURL ) {\n\t\t\tconst resetRevisions = await apiFetch( {\n\t\t\t\turl: revisionsURL,\n\t\t\t} );\n\t\t\tconst revisions = resetRevisions?.map( ( revision ) =>\n\t\t\t\tObject.fromEntries(\n\t\t\t\t\tObject.entries( revision ).map( ( [ key, value ] ) => [\n\t\t\t\t\t\tcamelCase( key ),\n\t\t\t\t\t\tvalue,\n\t\t\t\t\t] )\n\t\t\t\t)\n\t\t\t);\n\t\t\tdispatch.receiveThemeGlobalStyleRevisions(\n\t\t\t\tglobalStylesId,\n\t\t\t\trevisions\n\t\t\t);\n\t\t}\n\t};\n\ngetCurrentThemeGlobalStylesRevisions.shouldInvalidate = ( action ) => {\n\treturn (\n\t\taction.type === 'SAVE_ENTITY_RECORD_FINISH' &&\n\t\taction.kind === 'root' &&\n\t\t! action.error &&\n\t\taction.name === 'globalStyles'\n\t);\n};\n\nexport const getBlockPatterns =\n\t() =>\n\tasync ( { dispatch } ) => {\n\t\tconst patterns = await fetchBlockPatterns();\n\t\tdispatch( { type: 'RECEIVE_BLOCK_PATTERNS', patterns } );\n\t};\n\nexport const getBlockPatternCategories =\n\t() =>\n\tasync ( { dispatch } ) => {\n\t\tconst categories = await apiFetch( {\n\t\t\tpath: '/wp/v2/block-patterns/categories',\n\t\t} );\n\t\tdispatch( { type: 'RECEIVE_BLOCK_PATTERN_CATEGORIES', categories } );\n\t};\n\nexport const getUserPatternCategories =\n\t() =>\n\tasync ( { dispatch, resolveSelect } ) => {\n\t\tconst patternCategories = await resolveSelect.getEntityRecords(\n\t\t\t'taxonomy',\n\t\t\t'wp_pattern_category',\n\t\t\t{\n\t\t\t\tper_page: -1,\n\t\t\t\t_fields: 'id,name,description,slug',\n\t\t\t\tcontext: 'view',\n\t\t\t}\n\t\t);\n\n\t\tconst mappedPatternCategories =\n\t\t\tpatternCategories?.map( ( userCategory ) => ( {\n\t\t\t\t...userCategory,\n\t\t\t\tlabel: decodeEntities( userCategory.name ),\n\t\t\t\tname: userCategory.slug,\n\t\t\t} ) ) || [];\n\n\t\tdispatch( {\n\t\t\ttype: 'RECEIVE_USER_PATTERN_CATEGORIES',\n\t\t\tpatternCategories: mappedPatternCategories,\n\t\t} );\n\t};\n\nexport const getNavigationFallbackId =\n\t() =>\n\tasync ( { dispatch, select, registry } ) => {\n\t\tconst fallback = await apiFetch( {\n\t\t\tpath: addQueryArgs( '/wp-block-editor/v1/navigation-fallback', {\n\t\t\t\t_embed: true,\n\t\t\t} ),\n\t\t} );\n\n\t\tconst record = fallback?._embedded?.self;\n\n\t\tregistry.batch( () => {\n\t\t\tdispatch.receiveNavigationFallbackId( fallback?.id );\n\n\t\t\tif ( ! record ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// If the fallback is already in the store, don't invalidate navigation queries.\n\t\t\t// Otherwise, invalidate the cache for the scenario where there were no Navigation\n\t\t\t// posts in the state and the fallback created one.\n\t\t\tconst existingFallbackEntityRecord = select.getEntityRecord(\n\t\t\t\t'postType',\n\t\t\t\t'wp_navigation',\n\t\t\t\tfallback.id\n\t\t\t);\n\t\t\tconst invalidateNavigationQueries = ! existingFallbackEntityRecord;\n\t\t\tdispatch.receiveEntityRecords(\n\t\t\t\t'postType',\n\t\t\t\t'wp_navigation',\n\t\t\t\trecord,\n\t\t\t\tundefined,\n\t\t\t\tinvalidateNavigationQueries\n\t\t\t);\n\n\t\t\t// Resolve to avoid further network requests.\n\t\t\tdispatch.finishResolution( 'getEntityRecord', [\n\t\t\t\t'postType',\n\t\t\t\t'wp_navigation',\n\t\t\t\tfallback.id,\n\t\t\t] );\n\t\t} );\n\t};\n\nexport const getDefaultTemplateId =\n\t( query ) =>\n\tasync ( { dispatch, registry, resolveSelect } ) => {\n\t\tconst template = await apiFetch( {\n\t\t\tpath: addQueryArgs( '/wp/v2/templates/lookup', query ),\n\t\t} );\n\t\t// Wait for the the entities config to be loaded, otherwise receiving\n\t\t// the template as an entity will not work.\n\t\tawait resolveSelect.getEntitiesConfig( 'postType' );\n\t\t// Endpoint may return an empty object if no template is found.\n\t\tif ( template?.id ) {\n\t\t\tregistry.batch( () => {\n\t\t\t\tdispatch.receiveDefaultTemplateId( query, template.id );\n\t\t\t\tdispatch.receiveEntityRecords( 'postType', 'wp_template', [\n\t\t\t\t\ttemplate,\n\t\t\t\t] );\n\t\t\t\t// Avoid further network requests.\n\t\t\t\tdispatch.finishResolution( 'getEntityRecord', [\n\t\t\t\t\t'postType',\n\t\t\t\t\t'wp_template',\n\t\t\t\t\ttemplate.id,\n\t\t\t\t] );\n\t\t\t} );\n\t\t}\n\t};\n\n/**\n * Requests an entity's revisions from the REST API.\n *\n * @param {string}           kind      Entity kind.\n * @param {string}           name      Entity name.\n * @param {number|string}    recordKey The key of the entity record whose revisions you want to fetch.\n * @param {Object|undefined} query     Optional object of query parameters to\n *                                     include with request. If requesting specific\n *                                     fields, fields must always include the ID.\n */\nexport const getRevisions =\n\t( kind, name, recordKey, query = {} ) =>\n\tasync ( { dispatch, registry, resolveSelect } ) => {\n\t\tconst configs = await resolveSelect.getEntitiesConfig( kind );\n\t\tconst entityConfig = configs.find(\n\t\t\t( config ) => config.name === name && config.kind === kind\n\t\t);\n\n\t\tif ( ! entityConfig ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( query._fields ) {\n\t\t\t// If requesting specific fields, items and query association to said\n\t\t\t// records are stored by ID reference. Thus, fields must always include\n\t\t\t// the ID.\n\t\t\tquery = {\n\t\t\t\t...query,\n\t\t\t\t_fields: [\n\t\t\t\t\t...new Set( [\n\t\t\t\t\t\t...( getNormalizedCommaSeparable( query._fields ) ||\n\t\t\t\t\t\t\t[] ),\n\t\t\t\t\t\tentityConfig.revisionKey || DEFAULT_ENTITY_KEY,\n\t\t\t\t\t] ),\n\t\t\t\t].join(),\n\t\t\t};\n\t\t}\n\n\t\tconst path = addQueryArgs(\n\t\t\tentityConfig.getRevisionsUrl( recordKey ),\n\t\t\tquery\n\t\t);\n\n\t\tlet records, response;\n\t\tconst meta = {};\n\t\tconst isPaginated =\n\t\t\tentityConfig.supportsPagination && query.per_page !== -1;\n\t\ttry {\n\t\t\tresponse = await apiFetch( { path, parse: ! isPaginated } );\n\t\t} catch ( error ) {\n\t\t\t// Do nothing if our request comes back with an API error.\n\t\t\treturn;\n\t\t}\n\n\t\tif ( response ) {\n\t\t\tif ( isPaginated ) {\n\t\t\t\trecords = Object.values( await response.json() );\n\t\t\t\tmeta.totalItems = parseInt(\n\t\t\t\t\tresponse.headers.get( 'X-WP-Total' )\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\trecords = Object.values( response );\n\t\t\t}\n\n\t\t\t// If we request fields but the result doesn't contain the fields,\n\t\t\t// explicitly set these fields as \"undefined\"\n\t\t\t// that way we consider the query \"fulfilled\".\n\t\t\tif ( query._fields ) {\n\t\t\t\trecords = records.map( ( record ) => {\n\t\t\t\t\tquery._fields.split( ',' ).forEach( ( field ) => {\n\t\t\t\t\t\tif ( ! record.hasOwnProperty( field ) ) {\n\t\t\t\t\t\t\trecord[ field ] = undefined;\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\n\t\t\t\t\treturn record;\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\tregistry.batch( () => {\n\t\t\t\tdispatch.receiveRevisions(\n\t\t\t\t\tkind,\n\t\t\t\t\tname,\n\t\t\t\t\trecordKey,\n\t\t\t\t\trecords,\n\t\t\t\t\tquery,\n\t\t\t\t\tfalse,\n\t\t\t\t\tmeta\n\t\t\t\t);\n\n\t\t\t\t// When requesting all fields, the list of results can be used to\n\t\t\t\t// resolve the `getRevision` selector in addition to `getRevisions`.\n\t\t\t\tif ( ! query?._fields && ! query.context ) {\n\t\t\t\t\tconst key = entityConfig.key || DEFAULT_ENTITY_KEY;\n\t\t\t\t\tconst resolutionsArgs = records\n\t\t\t\t\t\t.filter( ( record ) => record[ key ] )\n\t\t\t\t\t\t.map( ( record ) => [\n\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\trecordKey,\n\t\t\t\t\t\t\trecord[ key ],\n\t\t\t\t\t\t] );\n\n\t\t\t\t\tdispatch.finishResolutions(\n\t\t\t\t\t\t'getRevision',\n\t\t\t\t\t\tresolutionsArgs\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\t};\n\n// Invalidate cache when a new revision is created.\ngetRevisions.shouldInvalidate = ( action, kind, name, recordKey ) =>\n\taction.type === 'SAVE_ENTITY_RECORD_FINISH' &&\n\tname === action.name &&\n\tkind === action.kind &&\n\t! action.error &&\n\trecordKey === action.recordId;\n\n/**\n * Requests a specific Entity revision from the REST API.\n *\n * @param {string}           kind        Entity kind.\n * @param {string}           name        Entity name.\n * @param {number|string}    recordKey   The key of the entity record whose revisions you want to fetch.\n * @param {number|string}    revisionKey The revision's key.\n * @param {Object|undefined} query       Optional object of query parameters to\n *                                       include with request. If requesting specific\n *                                       fields, fields must always include the ID.\n */\nexport const getRevision =\n\t( kind, name, recordKey, revisionKey, query ) =>\n\tasync ( { dispatch, resolveSelect } ) => {\n\t\tconst configs = await resolveSelect.getEntitiesConfig( kind );\n\t\tconst entityConfig = configs.find(\n\t\t\t( config ) => config.name === name && config.kind === kind\n\t\t);\n\n\t\tif ( ! entityConfig ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( query !== undefined && query._fields ) {\n\t\t\t// If requesting specific fields, items and query association to said\n\t\t\t// records are stored by ID reference. Thus, fields must always include\n\t\t\t// the ID.\n\t\t\tquery = {\n\t\t\t\t...query,\n\t\t\t\t_fields: [\n\t\t\t\t\t...new Set( [\n\t\t\t\t\t\t...( getNormalizedCommaSeparable( query._fields ) ||\n\t\t\t\t\t\t\t[] ),\n\t\t\t\t\t\tentityConfig.revisionKey || DEFAULT_ENTITY_KEY,\n\t\t\t\t\t] ),\n\t\t\t\t].join(),\n\t\t\t};\n\t\t}\n\t\tconst path = addQueryArgs(\n\t\t\tentityConfig.getRevisionsUrl( recordKey, revisionKey ),\n\t\t\tquery\n\t\t);\n\n\t\tlet record;\n\t\ttry {\n\t\t\trecord = await apiFetch( { path } );\n\t\t} catch ( error ) {\n\t\t\t// Do nothing if our request comes back with an API error.\n\t\t\treturn;\n\t\t}\n\n\t\tif ( record ) {\n\t\t\tdispatch.receiveRevisions( kind, name, recordKey, record, query );\n\t\t}\n\t};\n\n/**\n * Requests a specific post type options from the REST API.\n *\n * @param {string} postType Post type slug.\n */\nexport const getRegisteredPostMeta =\n\t( postType ) =>\n\tasync ( { dispatch, resolveSelect } ) => {\n\t\tlet options;\n\t\ttry {\n\t\t\tconst {\n\t\t\t\trest_namespace: restNamespace = 'wp/v2',\n\t\t\t\trest_base: restBase,\n\t\t\t} = ( await resolveSelect.getPostType( postType ) ) || {};\n\t\t\toptions = await apiFetch( {\n\t\t\t\tpath: `${ restNamespace }/${ restBase }/?context=edit`,\n\t\t\t\tmethod: 'OPTIONS',\n\t\t\t} );\n\t\t} catch ( error ) {\n\t\t\t// Do nothing if the request comes back with an API error.\n\t\t\treturn;\n\t\t}\n\n\t\tif ( options ) {\n\t\t\tdispatch.receiveRegisteredPostMeta(\n\t\t\t\tpostType,\n\t\t\t\toptions?.schema?.properties?.meta?.properties\n\t\t\t);\n\t\t}\n\t};\n\n/**\n * Requests entity configs for the given kind from the REST API.\n *\n * @param {string} kind Entity kind.\n */\nexport const getEntitiesConfig =\n\t( kind ) =>\n\tasync ( { dispatch } ) => {\n\t\tconst loader = additionalEntityConfigLoaders.find(\n\t\t\t( l ) => l.kind === kind\n\t\t);\n\n\t\tif ( ! loader ) {\n\t\t\treturn;\n\t\t}\n\n\t\ttry {\n\t\t\tconst configs = await loader.loadEntities();\n\t\t\tif ( ! configs.length ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tdispatch.addEntities( configs );\n\t\t} catch {\n\t\t\t// Do nothing if the request comes back with an API error.\n\t\t}\n\t};\n","export function deepCopyLocksTreePath( tree, path ) {\n\tconst newTree = { ...tree };\n\tlet currentNode = newTree;\n\tfor ( const branchName of path ) {\n\t\tcurrentNode.children = {\n\t\t\t...currentNode.children,\n\t\t\t[ branchName ]: {\n\t\t\t\tlocks: [],\n\t\t\t\tchildren: {},\n\t\t\t\t...currentNode.children[ branchName ],\n\t\t\t},\n\t\t};\n\t\tcurrentNode = currentNode.children[ branchName ];\n\t}\n\treturn newTree;\n}\n\nexport function getNode( tree, path ) {\n\tlet currentNode = tree;\n\tfor ( const branchName of path ) {\n\t\tconst nextNode = currentNode.children[ branchName ];\n\t\tif ( ! nextNode ) {\n\t\t\treturn null;\n\t\t}\n\t\tcurrentNode = nextNode;\n\t}\n\treturn currentNode;\n}\n\nexport function* iteratePath( tree, path ) {\n\tlet currentNode = tree;\n\tyield currentNode;\n\tfor ( const branchName of path ) {\n\t\tconst nextNode = currentNode.children[ branchName ];\n\t\tif ( ! nextNode ) {\n\t\t\tbreak;\n\t\t}\n\t\tyield nextNode;\n\t\tcurrentNode = nextNode;\n\t}\n}\n\nexport function* iterateDescendants( node ) {\n\tconst stack = Object.values( node.children );\n\twhile ( stack.length ) {\n\t\tconst childNode = stack.pop();\n\t\tyield childNode;\n\t\tstack.push( ...Object.values( childNode.children ) );\n\t}\n}\n\nexport function hasConflictingLock( { exclusive }, locks ) {\n\tif ( exclusive && locks.length ) {\n\t\treturn true;\n\t}\n\n\tif ( ! exclusive && locks.filter( ( lock ) => lock.exclusive ).length ) {\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n","/**\n * Internal dependencies\n */\nimport { getNode, deepCopyLocksTreePath } from './utils';\n\nconst DEFAULT_STATE = {\n\trequests: [],\n\ttree: {\n\t\tlocks: [],\n\t\tchildren: {},\n\t},\n};\n\n/**\n * Reducer returning locks.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport default function locks( state = DEFAULT_STATE, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'ENQUEUE_LOCK_REQUEST': {\n\t\t\tconst { request } = action;\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\trequests: [ request, ...state.requests ],\n\t\t\t};\n\t\t}\n\t\tcase 'GRANT_LOCK_REQUEST': {\n\t\t\tconst { lock, request } = action;\n\t\t\tconst { store, path } = request;\n\t\t\tconst storePath = [ store, ...path ];\n\n\t\t\tconst newTree = deepCopyLocksTreePath( state.tree, storePath );\n\t\t\tconst node = getNode( newTree, storePath );\n\t\t\tnode.locks = [ ...node.locks, lock ];\n\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\trequests: state.requests.filter( ( r ) => r !== request ),\n\t\t\t\ttree: newTree,\n\t\t\t};\n\t\t}\n\t\tcase 'RELEASE_LOCK': {\n\t\t\tconst { lock } = action;\n\t\t\tconst storePath = [ lock.store, ...lock.path ];\n\n\t\t\tconst newTree = deepCopyLocksTreePath( state.tree, storePath );\n\t\t\tconst node = getNode( newTree, storePath );\n\t\t\tnode.locks = node.locks.filter( ( l ) => l !== lock );\n\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\ttree: newTree,\n\t\t\t};\n\t\t}\n\t}\n\n\treturn state;\n}\n","/**\n * Internal dependencies\n */\nimport {\n\titerateDescendants,\n\titeratePath,\n\thasConflictingLock,\n\tgetNode,\n} from './utils';\n\nexport function getPendingLockRequests( state ) {\n\treturn state.requests;\n}\n\nexport function isLockAvailable( state, store, path, { exclusive } ) {\n\tconst storePath = [ store, ...path ];\n\tconst locks = state.tree;\n\n\t// Validate all parents and the node itself\n\tfor ( const node of iteratePath( locks, storePath ) ) {\n\t\tif ( hasConflictingLock( { exclusive }, node.locks ) ) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\t// iteratePath terminates early if path is unreachable, let's\n\t// re-fetch the node and check it exists in the tree.\n\tconst node = getNode( locks, storePath );\n\tif ( ! node ) {\n\t\treturn true;\n\t}\n\n\t// Validate all nested nodes\n\tfor ( const descendant of iterateDescendants( node ) ) {\n\t\tif ( hasConflictingLock( { exclusive }, descendant.locks ) ) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n","/**\n * Internal dependencies\n */\nimport reducer from './reducer';\nimport { isLockAvailable, getPendingLockRequests } from './selectors';\n\nexport default function createLocks() {\n\tlet state = reducer( undefined, { type: '@@INIT' } );\n\n\tfunction processPendingLockRequests() {\n\t\tfor ( const request of getPendingLockRequests( state ) ) {\n\t\t\tconst { store, path, exclusive, notifyAcquired } = request;\n\t\t\tif ( isLockAvailable( state, store, path, { exclusive } ) ) {\n\t\t\t\tconst lock = { store, path, exclusive };\n\t\t\t\tstate = reducer( state, {\n\t\t\t\t\ttype: 'GRANT_LOCK_REQUEST',\n\t\t\t\t\tlock,\n\t\t\t\t\trequest,\n\t\t\t\t} );\n\t\t\t\tnotifyAcquired( lock );\n\t\t\t}\n\t\t}\n\t}\n\n\tfunction acquire( store, path, exclusive ) {\n\t\treturn new Promise( ( resolve ) => {\n\t\t\tstate = reducer( state, {\n\t\t\t\ttype: 'ENQUEUE_LOCK_REQUEST',\n\t\t\t\trequest: { store, path, exclusive, notifyAcquired: resolve },\n\t\t\t} );\n\t\t\tprocessPendingLockRequests();\n\t\t} );\n\t}\n\tfunction release( lock ) {\n\t\tstate = reducer( state, {\n\t\t\ttype: 'RELEASE_LOCK',\n\t\t\tlock,\n\t\t} );\n\t\tprocessPendingLockRequests();\n\t}\n\n\treturn { acquire, release };\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"element\"];","/**\n * WordPress dependencies\n */\nimport { createContext } from '@wordpress/element';\n\nexport const EntityContext = createContext( {} );\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"ReactJSXRuntime\"];","/**\n * WordPress dependencies\n */\nimport { useContext, useMemo } from '@wordpress/element';\n\n/**\n * Internal dependencies\n */\nimport { EntityContext } from './entity-context';\n\n/**\n * Context provider component for providing\n * an entity for a specific entity.\n *\n * @param {Object} props          The component's props.\n * @param {string} props.kind     The entity kind.\n * @param {string} props.type     The entity name.\n * @param {number} props.id       The entity ID.\n * @param {*}      props.children The children to wrap.\n *\n * @return {Object} The provided children, wrapped with\n *                   the entity's context provider.\n */\nexport default function EntityProvider( { kind, type: name, id, children } ) {\n\tconst parent = useContext( EntityContext );\n\tconst childContext = useMemo(\n\t\t() => ( {\n\t\t\t...parent,\n\t\t\t[ kind ]: {\n\t\t\t\t...parent?.[ kind ],\n\t\t\t\t[ name ]: id,\n\t\t\t},\n\t\t} ),\n\t\t[ parent, kind, name, id ]\n\t);\n\treturn (\n\t\t<EntityContext.Provider value={ childContext }>\n\t\t\t{ children }\n\t\t</EntityContext.Provider>\n\t);\n}\n","export const enum Status {\n\tIdle = 'IDLE',\n\tResolving = 'RESOLVING',\n\tError = 'ERROR',\n\tSuccess = 'SUCCESS',\n}\n","/**\n * WordPress dependencies\n */\nimport { useSelect } from '@wordpress/data';\n\n/**\n * Internal dependencies\n */\nimport memoize from './memoize';\nimport { Status } from './constants';\n\nexport const META_SELECTORS = [\n\t'getIsResolving',\n\t'hasStartedResolution',\n\t'hasFinishedResolution',\n\t'isResolving',\n\t'getCachedResolvers',\n];\n\ninterface QuerySelectResponse< Data > {\n\t/** the requested selector return value */\n\tdata: Data;\n\n\t/** is the record still being resolved? Via the `isResolving` meta-selector */\n\tisResolving: boolean;\n\n\t/** was the resolution started? Via the `hasStartedResolution` meta-selector */\n\thasStarted: boolean;\n\n\t/** has the resolution finished? Via the `hasFinishedResolution` meta-selector. */\n\thasResolved: boolean;\n}\n\n/**\n * Like useSelect, but the selectors return objects containing\n * both the original data AND the resolution info.\n *\n * @since 6.1.0 Introduced in WordPress core.\n * @private\n *\n * @param {Function} mapQuerySelect see useSelect\n * @param {Array}    deps           see useSelect\n *\n * @example\n * ```js\n * import { useQuerySelect } from '@wordpress/data';\n * import { store as coreDataStore } from '@wordpress/core-data';\n *\n * function PageTitleDisplay( { id } ) {\n *   const { data: page, isResolving } = useQuerySelect( ( query ) => {\n *     return query( coreDataStore ).getEntityRecord( 'postType', 'page', id )\n *   }, [ id ] );\n *\n *   if ( isResolving ) {\n *     return 'Loading...';\n *   }\n *\n *   return page.title;\n * }\n *\n * // Rendered in the application:\n * // <PageTitleDisplay id={ 10 } />\n * ```\n *\n * In the above example, when `PageTitleDisplay` is rendered into an\n * application, the page and the resolution details will be retrieved from\n * the store state using the `mapSelect` callback on `useQuerySelect`.\n *\n * If the id prop changes then any page in the state for that id is\n * retrieved. If the id prop doesn't change and other props are passed in\n * that do change, the title will not change because the dependency is just\n * the id.\n * @see useSelect\n *\n * @return {QuerySelectResponse} Queried data.\n */\nexport default function useQuerySelect( mapQuerySelect, deps ) {\n\treturn useSelect( ( select, registry ) => {\n\t\tconst resolve = ( store ) => enrichSelectors( select( store ) );\n\t\treturn mapQuerySelect( resolve, registry );\n\t}, deps );\n}\n\ninterface EnrichedSelectors {\n\t< Selectors extends Record< string, ( ...args: any[] ) => any > >(\n\t\tselectors: Selectors\n\t): {\n\t\t[ Selector in keyof Selectors ]: (\n\t\t\t...args: Parameters< Selectors[ Selector ] >\n\t\t) => QuerySelectResponse< ReturnType< Selectors[ Selector ] > >;\n\t};\n}\n\n/**\n * Transform simple selectors into ones that return an object with the\n * original return value AND the resolution info.\n *\n * @param {Object} selectors Selectors to enrich\n * @return {EnrichedSelectors} Enriched selectors\n */\nconst enrichSelectors = memoize( ( ( selectors ) => {\n\tconst resolvers = {};\n\tfor ( const selectorName in selectors ) {\n\t\tif ( META_SELECTORS.includes( selectorName ) ) {\n\t\t\tcontinue;\n\t\t}\n\t\tObject.defineProperty( resolvers, selectorName, {\n\t\t\tget:\n\t\t\t\t() =>\n\t\t\t\t( ...args: unknown[] ) => {\n\t\t\t\t\tconst data = selectors[ selectorName ]( ...args );\n\t\t\t\t\tconst resolutionStatus = selectors.getResolutionState(\n\t\t\t\t\t\tselectorName,\n\t\t\t\t\t\targs\n\t\t\t\t\t)?.status;\n\n\t\t\t\t\tlet status;\n\t\t\t\t\tswitch ( resolutionStatus ) {\n\t\t\t\t\t\tcase 'resolving':\n\t\t\t\t\t\t\tstatus = Status.Resolving;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase 'finished':\n\t\t\t\t\t\t\tstatus = Status.Success;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase 'error':\n\t\t\t\t\t\t\tstatus = Status.Error;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase undefined:\n\t\t\t\t\t\t\tstatus = Status.Idle;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdata,\n\t\t\t\t\t\tstatus,\n\t\t\t\t\t\tisResolving: status === Status.Resolving,\n\t\t\t\t\t\thasStarted: status !== Status.Idle,\n\t\t\t\t\t\thasResolved:\n\t\t\t\t\t\t\tstatus === Status.Success ||\n\t\t\t\t\t\t\tstatus === Status.Error,\n\t\t\t\t\t};\n\t\t\t\t},\n\t\t} );\n\t}\n\treturn resolvers;\n} ) as EnrichedSelectors );\n","/**\n * Memize options object.\n *\n * @typedef MemizeOptions\n *\n * @property {number} [maxSize] Maximum size of the cache.\n */\n\n/**\n * Internal cache entry.\n *\n * @typedef MemizeCacheNode\n *\n * @property {?MemizeCacheNode|undefined} [prev] Previous node.\n * @property {?MemizeCacheNode|undefined} [next] Next node.\n * @property {Array<*>}                   args   Function arguments for cache\n *                                               entry.\n * @property {*}                          val    Function result.\n */\n\n/**\n * Properties of the enhanced function for controlling cache.\n *\n * @typedef MemizeMemoizedFunction\n *\n * @property {()=>void} clear Clear the cache.\n */\n\n/**\n * Accepts a function to be memoized, and returns a new memoized function, with\n * optional options.\n *\n * @template {(...args: any[]) => any} F\n *\n * @param {F}             fn        Function to memoize.\n * @param {MemizeOptions} [options] Options object.\n *\n * @return {((...args: Parameters<F>) => ReturnType<F>) & MemizeMemoizedFunction} Memoized function.\n */\nfunction memize(fn, options) {\n\tvar size = 0;\n\n\t/** @type {?MemizeCacheNode|undefined} */\n\tvar head;\n\n\t/** @type {?MemizeCacheNode|undefined} */\n\tvar tail;\n\n\toptions = options || {};\n\n\tfunction memoized(/* ...args */) {\n\t\tvar node = head,\n\t\t\tlen = arguments.length,\n\t\t\targs,\n\t\t\ti;\n\n\t\tsearchCache: while (node) {\n\t\t\t// Perform a shallow equality test to confirm that whether the node\n\t\t\t// under test is a candidate for the arguments passed. Two arrays\n\t\t\t// are shallowly equal if their length matches and each entry is\n\t\t\t// strictly equal between the two sets. Avoid abstracting to a\n\t\t\t// function which could incur an arguments leaking deoptimization.\n\n\t\t\t// Check whether node arguments match arguments length\n\t\t\tif (node.args.length !== arguments.length) {\n\t\t\t\tnode = node.next;\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Check whether node arguments match arguments values\n\t\t\tfor (i = 0; i < len; i++) {\n\t\t\t\tif (node.args[i] !== arguments[i]) {\n\t\t\t\t\tnode = node.next;\n\t\t\t\t\tcontinue searchCache;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// At this point we can assume we've found a match\n\n\t\t\t// Surface matched node to head if not already\n\t\t\tif (node !== head) {\n\t\t\t\t// As tail, shift to previous. Must only shift if not also\n\t\t\t\t// head, since if both head and tail, there is no previous.\n\t\t\t\tif (node === tail) {\n\t\t\t\t\ttail = node.prev;\n\t\t\t\t}\n\n\t\t\t\t// Adjust siblings to point to each other. If node was tail,\n\t\t\t\t// this also handles new tail's empty `next` assignment.\n\t\t\t\t/** @type {MemizeCacheNode} */ (node.prev).next = node.next;\n\t\t\t\tif (node.next) {\n\t\t\t\t\tnode.next.prev = node.prev;\n\t\t\t\t}\n\n\t\t\t\tnode.next = head;\n\t\t\t\tnode.prev = null;\n\t\t\t\t/** @type {MemizeCacheNode} */ (head).prev = node;\n\t\t\t\thead = node;\n\t\t\t}\n\n\t\t\t// Return immediately\n\t\t\treturn node.val;\n\t\t}\n\n\t\t// No cached value found. Continue to insertion phase:\n\n\t\t// Create a copy of arguments (avoid leaking deoptimization)\n\t\targs = new Array(len);\n\t\tfor (i = 0; i < len; i++) {\n\t\t\targs[i] = arguments[i];\n\t\t}\n\n\t\tnode = {\n\t\t\targs: args,\n\n\t\t\t// Generate the result from original function\n\t\t\tval: fn.apply(null, args),\n\t\t};\n\n\t\t// Don't need to check whether node is already head, since it would\n\t\t// have been returned above already if it was\n\n\t\t// Shift existing head down list\n\t\tif (head) {\n\t\t\thead.prev = node;\n\t\t\tnode.next = head;\n\t\t} else {\n\t\t\t// If no head, follows that there's no tail (at initial or reset)\n\t\t\ttail = node;\n\t\t}\n\n\t\t// Trim tail if we're reached max size and are pending cache insertion\n\t\tif (size === /** @type {MemizeOptions} */ (options).maxSize) {\n\t\t\ttail = /** @type {MemizeCacheNode} */ (tail).prev;\n\t\t\t/** @type {MemizeCacheNode} */ (tail).next = null;\n\t\t} else {\n\t\t\tsize++;\n\t\t}\n\n\t\thead = node;\n\n\t\treturn node.val;\n\t}\n\n\tmemoized.clear = function () {\n\t\thead = null;\n\t\ttail = null;\n\t\tsize = 0;\n\t};\n\n\t// Ignore reason: There's not a clear solution to create an intersection of\n\t// the function with additional properties, where the goal is to retain the\n\t// function signature of the incoming argument and add control properties\n\t// on the return value.\n\n\t// @ts-ignore\n\treturn memoized;\n}\n\nexport { memize as default };\n","/**\n * WordPress dependencies\n */\nimport { useDispatch, useSelect } from '@wordpress/data';\nimport deprecated from '@wordpress/deprecated';\nimport { useMemo } from '@wordpress/element';\n\n/**\n * Internal dependencies\n */\nimport useQuerySelect from './use-query-select';\nimport { store as coreStore } from '../';\nimport type { Status } from './constants';\n\nexport interface EntityRecordResolution< RecordType > {\n\t/** The requested entity record */\n\trecord: RecordType | null;\n\n\t/** The edited entity record */\n\teditedRecord: Partial< RecordType >;\n\n\t/** The edits to the edited entity record */\n\tedits: Partial< RecordType >;\n\n\t/** Apply local (in-browser) edits to the edited entity record */\n\tedit: ( diff: Partial< RecordType > ) => void;\n\n\t/** Persist the edits to the server */\n\tsave: () => Promise< void >;\n\n\t/**\n\t * Is the record still being resolved?\n\t */\n\tisResolving: boolean;\n\n\t/**\n\t * Does the record have any local edits?\n\t */\n\thasEdits: boolean;\n\n\t/**\n\t * Is the record resolved by now?\n\t */\n\thasResolved: boolean;\n\n\t/** Resolution status */\n\tstatus: Status;\n}\n\nexport interface Options {\n\t/**\n\t * Whether to run the query or short-circuit and return null.\n\t *\n\t * @default true\n\t */\n\tenabled: boolean;\n}\n\nconst EMPTY_OBJECT = {};\n\n/**\n * Resolves the specified entity record.\n *\n * @since 6.1.0 Introduced in WordPress core.\n *\n * @param    kind     Kind of the entity, e.g. `root` or a `postType`. See rootEntitiesConfig in ../entities.ts for a list of available kinds.\n * @param    name     Name of the entity, e.g. `plugin` or a `post`. See rootEntitiesConfig in ../entities.ts for a list of available names.\n * @param    recordId ID of the requested entity record.\n * @param    options  Optional hook options.\n * @example\n * ```js\n * import { useEntityRecord } from '@wordpress/core-data';\n *\n * function PageTitleDisplay( { id } ) {\n *   const { record, isResolving } = useEntityRecord( 'postType', 'page', id );\n *\n *   if ( isResolving ) {\n *     return 'Loading...';\n *   }\n *\n *   return record.title;\n * }\n *\n * // Rendered in the application:\n * // <PageTitleDisplay id={ 1 } />\n * ```\n *\n * In the above example, when `PageTitleDisplay` is rendered into an\n * application, the page and the resolution details will be retrieved from\n * the store state using `getEntityRecord()`, or resolved if missing.\n *\n * @example\n * ```js\n * import { useCallback } from 'react';\n * import { useDispatch } from '@wordpress/data';\n * import { __ } from '@wordpress/i18n';\n * import { TextControl } from '@wordpress/components';\n * import { store as noticeStore } from '@wordpress/notices';\n * import { useEntityRecord } from '@wordpress/core-data';\n *\n * function PageRenameForm( { id } ) {\n * \tconst page = useEntityRecord( 'postType', 'page', id );\n * \tconst { createSuccessNotice, createErrorNotice } =\n * \t\tuseDispatch( noticeStore );\n *\n * \tconst setTitle = useCallback( ( title ) => {\n * \t\tpage.edit( { title } );\n * \t}, [ page.edit ] );\n *\n * \tif ( page.isResolving ) {\n * \t\treturn 'Loading...';\n * \t}\n *\n * \tasync function onRename( event ) {\n * \t\tevent.preventDefault();\n * \t\ttry {\n * \t\t\tawait page.save();\n * \t\t\tcreateSuccessNotice( __( 'Page renamed.' ), {\n * \t\t\t\ttype: 'snackbar',\n * \t\t\t} );\n * \t\t} catch ( error ) {\n * \t\t\tcreateErrorNotice( error.message, { type: 'snackbar' } );\n * \t\t}\n * \t}\n *\n * \treturn (\n * \t\t<form onSubmit={ onRename }>\n * \t\t\t<TextControl\n *\t\t\t\t__nextHasNoMarginBottom\n *\t\t\t\t__next40pxDefaultSize\n * \t\t\t\tlabel={ __( 'Name' ) }\n * \t\t\t\tvalue={ page.editedRecord.title }\n * \t\t\t\tonChange={ setTitle }\n * \t\t\t/>\n * \t\t\t<button type=\"submit\">{ __( 'Save' ) }</button>\n * \t\t</form>\n * \t);\n * }\n *\n * // Rendered in the application:\n * // <PageRenameForm id={ 1 } />\n * ```\n *\n * In the above example, updating and saving the page title is handled\n * via the `edit()` and `save()` mutation helpers provided by\n * `useEntityRecord()`;\n *\n * @return Entity record data.\n * @template RecordType\n */\nexport default function useEntityRecord< RecordType >(\n\tkind: string,\n\tname: string,\n\trecordId: string | number,\n\toptions: Options = { enabled: true }\n): EntityRecordResolution< RecordType > {\n\tconst { editEntityRecord, saveEditedEntityRecord } =\n\t\tuseDispatch( coreStore );\n\n\tconst mutations = useMemo(\n\t\t() => ( {\n\t\t\tedit: ( record, editOptions: any = {} ) =>\n\t\t\t\teditEntityRecord( kind, name, recordId, record, editOptions ),\n\t\t\tsave: ( saveOptions: any = {} ) =>\n\t\t\t\tsaveEditedEntityRecord( kind, name, recordId, {\n\t\t\t\t\tthrowOnError: true,\n\t\t\t\t\t...saveOptions,\n\t\t\t\t} ),\n\t\t} ),\n\t\t[ editEntityRecord, kind, name, recordId, saveEditedEntityRecord ]\n\t);\n\n\tconst { editedRecord, hasEdits, edits } = useSelect(\n\t\t( select ) => {\n\t\t\tif ( ! options.enabled ) {\n\t\t\t\treturn {\n\t\t\t\t\teditedRecord: EMPTY_OBJECT,\n\t\t\t\t\thasEdits: false,\n\t\t\t\t\tedits: EMPTY_OBJECT,\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\teditedRecord: select( coreStore ).getEditedEntityRecord(\n\t\t\t\t\tkind,\n\t\t\t\t\tname,\n\t\t\t\t\trecordId\n\t\t\t\t),\n\t\t\t\thasEdits: select( coreStore ).hasEditsForEntityRecord(\n\t\t\t\t\tkind,\n\t\t\t\t\tname,\n\t\t\t\t\trecordId\n\t\t\t\t),\n\t\t\t\tedits: select( coreStore ).getEntityRecordNonTransientEdits(\n\t\t\t\t\tkind,\n\t\t\t\t\tname,\n\t\t\t\t\trecordId\n\t\t\t\t),\n\t\t\t};\n\t\t},\n\t\t[ kind, name, recordId, options.enabled ]\n\t);\n\n\tconst { data: record, ...querySelectRest } = useQuerySelect(\n\t\t( query ) => {\n\t\t\tif ( ! options.enabled ) {\n\t\t\t\treturn {\n\t\t\t\t\tdata: null,\n\t\t\t\t};\n\t\t\t}\n\t\t\treturn query( coreStore ).getEntityRecord( kind, name, recordId );\n\t\t},\n\t\t[ kind, name, recordId, options.enabled ]\n\t);\n\n\treturn {\n\t\trecord,\n\t\teditedRecord,\n\t\thasEdits,\n\t\tedits,\n\t\t...querySelectRest,\n\t\t...mutations,\n\t};\n}\n\nexport function __experimentalUseEntityRecord(\n\tkind: string,\n\tname: string,\n\trecordId: any,\n\toptions: any\n) {\n\tdeprecated( `wp.data.__experimentalUseEntityRecord`, {\n\t\talternative: 'wp.data.useEntityRecord',\n\t\tsince: '6.1',\n\t} );\n\treturn useEntityRecord( kind, name, recordId, options );\n}\n","/**\n * WordPress dependencies\n */\nimport { addQueryArgs } from '@wordpress/url';\nimport deprecated from '@wordpress/deprecated';\nimport { useSelect } from '@wordpress/data';\nimport { useMemo } from '@wordpress/element';\n\n/**\n * Internal dependencies\n */\nimport useQuerySelect from './use-query-select';\nimport { store as coreStore } from '../';\nimport type { Options } from './use-entity-record';\nimport type { Status } from './constants';\nimport { unlock } from '../lock-unlock';\n\ninterface EntityRecordsResolution< RecordType > {\n\t/** The requested entity record */\n\trecords: RecordType[] | null;\n\n\t/**\n\t * Is the record still being resolved?\n\t */\n\tisResolving: boolean;\n\n\t/**\n\t * Is the record resolved by now?\n\t */\n\thasResolved: boolean;\n\n\t/** Resolution status */\n\tstatus: Status;\n\n\t/**\n\t * The total number of available items (if not paginated).\n\t */\n\ttotalItems: number | null;\n\n\t/**\n\t * The total number of pages.\n\t */\n\ttotalPages: number | null;\n}\n\nconst EMPTY_ARRAY = [];\n\n/**\n * Resolves the specified entity records.\n *\n * @since 6.1.0 Introduced in WordPress core.\n *\n * @param    kind      Kind of the entity, e.g. `root` or a `postType`. See rootEntitiesConfig in ../entities.ts for a list of available kinds.\n * @param    name      Name of the entity, e.g. `plugin` or a `post`. See rootEntitiesConfig in ../entities.ts for a list of available names.\n * @param    queryArgs Optional HTTP query description for how to fetch the data, passed to the requested API endpoint.\n * @param    options   Optional hook options.\n * @example\n * ```js\n * import { useEntityRecords } from '@wordpress/core-data';\n *\n * function PageTitlesList() {\n *   const { records, isResolving } = useEntityRecords( 'postType', 'page' );\n *\n *   if ( isResolving ) {\n *     return 'Loading...';\n *   }\n *\n *   return (\n *     <ul>\n *       {records.map(( page ) => (\n *         <li>{ page.title }</li>\n *       ))}\n *     </ul>\n *   );\n * }\n *\n * // Rendered in the application:\n * // <PageTitlesList />\n * ```\n *\n * In the above example, when `PageTitlesList` is rendered into an\n * application, the list of records and the resolution details will be retrieved from\n * the store state using `getEntityRecords()`, or resolved if missing.\n *\n * @return Entity records data.\n * @template RecordType\n */\nexport default function useEntityRecords< RecordType >(\n\tkind: string,\n\tname: string,\n\tqueryArgs: Record< string, unknown > = {},\n\toptions: Options = { enabled: true }\n): EntityRecordsResolution< RecordType > {\n\t// Serialize queryArgs to a string that can be safely used as a React dep.\n\t// We can't just pass queryArgs as one of the deps, because if it is passed\n\t// as an object literal, then it will be a different object on each call even\n\t// if the values remain the same.\n\tconst queryAsString = addQueryArgs( '', queryArgs );\n\n\tconst { data: records, ...rest } = useQuerySelect(\n\t\t( query ) => {\n\t\t\tif ( ! options.enabled ) {\n\t\t\t\treturn {\n\t\t\t\t\t// Avoiding returning a new reference on every execution.\n\t\t\t\t\tdata: EMPTY_ARRAY,\n\t\t\t\t};\n\t\t\t}\n\t\t\treturn query( coreStore ).getEntityRecords( kind, name, queryArgs );\n\t\t},\n\t\t[ kind, name, queryAsString, options.enabled ]\n\t);\n\n\tconst { totalItems, totalPages } = useSelect(\n\t\t( select ) => {\n\t\t\tif ( ! options.enabled ) {\n\t\t\t\treturn {\n\t\t\t\t\ttotalItems: null,\n\t\t\t\t\ttotalPages: null,\n\t\t\t\t};\n\t\t\t}\n\t\t\treturn {\n\t\t\t\ttotalItems: select( coreStore ).getEntityRecordsTotalItems(\n\t\t\t\t\tkind,\n\t\t\t\t\tname,\n\t\t\t\t\tqueryArgs\n\t\t\t\t),\n\t\t\t\ttotalPages: select( coreStore ).getEntityRecordsTotalPages(\n\t\t\t\t\tkind,\n\t\t\t\t\tname,\n\t\t\t\t\tqueryArgs\n\t\t\t\t),\n\t\t\t};\n\t\t},\n\t\t[ kind, name, queryAsString, options.enabled ]\n\t);\n\n\treturn {\n\t\trecords,\n\t\ttotalItems,\n\t\ttotalPages,\n\t\t...rest,\n\t};\n}\n\nexport function __experimentalUseEntityRecords(\n\tkind: string,\n\tname: string,\n\tqueryArgs: any,\n\toptions: any\n) {\n\tdeprecated( `wp.data.__experimentalUseEntityRecords`, {\n\t\talternative: 'wp.data.useEntityRecords',\n\t\tsince: '6.1',\n\t} );\n\treturn useEntityRecords( kind, name, queryArgs, options );\n}\n\nexport function useEntityRecordsWithPermissions< RecordType >(\n\tkind: string,\n\tname: string,\n\tqueryArgs: Record< string, unknown > = {},\n\toptions: Options = { enabled: true }\n): EntityRecordsResolution< RecordType > {\n\tconst entityConfig = useSelect(\n\t\t( select ) => select( coreStore ).getEntityConfig( kind, name ),\n\t\t[ kind, name ]\n\t);\n\tconst { records: data, ...ret } = useEntityRecords(\n\t\tkind,\n\t\tname,\n\t\tqueryArgs,\n\t\toptions\n\t);\n\tconst ids = useMemo(\n\t\t() =>\n\t\t\tdata?.map(\n\t\t\t\t// @ts-ignore\n\t\t\t\t( record: RecordType ) => record[ entityConfig?.key ?? 'id' ]\n\t\t\t) ?? [],\n\t\t[ data, entityConfig?.key ]\n\t);\n\n\tconst permissions = useSelect(\n\t\t( select ) => {\n\t\t\tconst { getEntityRecordsPermissions } = unlock(\n\t\t\t\tselect( coreStore )\n\t\t\t);\n\t\t\treturn getEntityRecordsPermissions( kind, name, ids );\n\t\t},\n\t\t[ ids, kind, name ]\n\t);\n\n\tconst dataWithPermissions = useMemo(\n\t\t() =>\n\t\t\tdata?.map( ( record, index ) => ( {\n\t\t\t\t// @ts-ignore\n\t\t\t\t...record,\n\t\t\t\tpermissions: permissions[ index ],\n\t\t\t} ) ) ?? [],\n\t\t[ data, permissions ]\n\t);\n\n\treturn { records: dataWithPermissions, ...ret };\n}\n","/**\n * WordPress dependencies\n */\nimport deprecated from '@wordpress/deprecated';\nimport warning from '@wordpress/warning';\n\n/**\n * Internal dependencies\n */\nimport { store as coreStore } from '../';\nimport { Status } from './constants';\nimport useQuerySelect from './use-query-select';\n\ninterface GlobalResourcePermissionsResolution {\n\t/** Can the current user create new resources of this type? */\n\tcanCreate: boolean;\n}\ninterface SpecificResourcePermissionsResolution {\n\t/** Can the current user update resources of this type? */\n\tcanUpdate: boolean;\n\t/** Can the current user delete resources of this type? */\n\tcanDelete: boolean;\n}\ninterface ResolutionDetails {\n\t/** Resolution status */\n\tstatus: Status;\n\t/**\n\t * Is the data still being resolved?\n\t */\n\tisResolving: boolean;\n}\n\n/**\n * Is the data resolved by now?\n */\ntype HasResolved = boolean;\n\ntype ResourcePermissionsResolution< IdType > = [\n\tHasResolved,\n\tResolutionDetails &\n\t\tGlobalResourcePermissionsResolution &\n\t\t( IdType extends void ? SpecificResourcePermissionsResolution : {} ),\n];\n\ntype EntityResource = { kind: string; name: string; id?: string | number };\n\nfunction useResourcePermissions< IdType = void >(\n\tresource: string,\n\tid?: IdType\n): ResourcePermissionsResolution< IdType >;\n\nfunction useResourcePermissions< IdType = void >(\n\tresource: EntityResource,\n\tid?: never\n): ResourcePermissionsResolution< IdType >;\n\n/**\n * Resolves resource permissions.\n *\n * @since 6.1.0 Introduced in WordPress core.\n *\n * @param    resource Entity resource to check. Accepts entity object `{ kind: 'root', name: 'media', id: 1 }`\n *                    or REST base as a string - `media`.\n * @param    id       Optional ID of the resource to check, e.g. 10. Note: This argument is discouraged\n *                    when using an entity object as a resource to check permissions and will be ignored.\n *\n * @example\n * ```js\n * import { useResourcePermissions } from '@wordpress/core-data';\n *\n * function PagesList() {\n *   const { canCreate, isResolving } = useResourcePermissions( { kind: 'postType', name: 'page' } );\n *\n *   if ( isResolving ) {\n *     return 'Loading ...';\n *   }\n *\n *   return (\n *     <div>\n *       {canCreate ? (<button>+ Create a new page</button>) : false}\n *       // ...\n *     </div>\n *   );\n * }\n *\n * // Rendered in the application:\n * // <PagesList />\n * ```\n *\n * @example\n * ```js\n * import { useResourcePermissions } from '@wordpress/core-data';\n *\n * function Page({ pageId }) {\n *   const {\n *     canCreate,\n *     canUpdate,\n *     canDelete,\n *     isResolving\n *   } = useResourcePermissions( { kind: 'postType', name: 'page', id: pageId } );\n *\n *   if ( isResolving ) {\n *     return 'Loading ...';\n *   }\n *\n *   return (\n *     <div>\n *       {canCreate ? (<button>+ Create a new page</button>) : false}\n *       {canUpdate ? (<button>Edit page</button>) : false}\n *       {canDelete ? (<button>Delete page</button>) : false}\n *       // ...\n *     </div>\n *   );\n * }\n *\n * // Rendered in the application:\n * // <Page pageId={ 15 } />\n * ```\n *\n * In the above example, when `PagesList` is rendered into an\n * application, the appropriate permissions and the resolution details will be retrieved from\n * the store state using `canUser()`, or resolved if missing.\n *\n * @return Entity records data.\n * @template IdType\n */\nfunction useResourcePermissions< IdType = void >(\n\tresource: string | EntityResource,\n\tid?: IdType\n): ResourcePermissionsResolution< IdType > {\n\t// Serialize `resource` to a string that can be safely used as a React dep.\n\t// We can't just pass `resource` as one of the deps, because if it is passed\n\t// as an object literal, then it will be a different object on each call even\n\t// if the values remain the same.\n\tconst isEntity = typeof resource === 'object';\n\tconst resourceAsString = isEntity ? JSON.stringify( resource ) : resource;\n\n\tif ( isEntity && typeof id !== 'undefined' ) {\n\t\twarning(\n\t\t\t`When 'resource' is an entity object, passing 'id' as a separate argument isn't supported.`\n\t\t);\n\t}\n\n\treturn useQuerySelect(\n\t\t( resolve ) => {\n\t\t\tconst hasId = isEntity ? !! resource.id : !! id;\n\t\t\tconst { canUser } = resolve( coreStore );\n\t\t\tconst create = canUser(\n\t\t\t\t'create',\n\t\t\t\tisEntity\n\t\t\t\t\t? { kind: resource.kind, name: resource.name }\n\t\t\t\t\t: resource\n\t\t\t);\n\n\t\t\tif ( ! hasId ) {\n\t\t\t\tconst read = canUser( 'read', resource );\n\n\t\t\t\tconst isResolving = create.isResolving || read.isResolving;\n\t\t\t\tconst hasResolved = create.hasResolved && read.hasResolved;\n\t\t\t\tlet status = Status.Idle;\n\t\t\t\tif ( isResolving ) {\n\t\t\t\t\tstatus = Status.Resolving;\n\t\t\t\t} else if ( hasResolved ) {\n\t\t\t\t\tstatus = Status.Success;\n\t\t\t\t}\n\n\t\t\t\treturn {\n\t\t\t\t\tstatus,\n\t\t\t\t\tisResolving,\n\t\t\t\t\thasResolved,\n\t\t\t\t\tcanCreate: create.hasResolved && create.data,\n\t\t\t\t\tcanRead: read.hasResolved && read.data,\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tconst read = canUser( 'read', resource, id );\n\t\t\tconst update = canUser( 'update', resource, id );\n\t\t\tconst _delete = canUser( 'delete', resource, id );\n\t\t\tconst isResolving =\n\t\t\t\tread.isResolving ||\n\t\t\t\tcreate.isResolving ||\n\t\t\t\tupdate.isResolving ||\n\t\t\t\t_delete.isResolving;\n\t\t\tconst hasResolved =\n\t\t\t\tread.hasResolved &&\n\t\t\t\tcreate.hasResolved &&\n\t\t\t\tupdate.hasResolved &&\n\t\t\t\t_delete.hasResolved;\n\n\t\t\tlet status = Status.Idle;\n\t\t\tif ( isResolving ) {\n\t\t\t\tstatus = Status.Resolving;\n\t\t\t} else if ( hasResolved ) {\n\t\t\t\tstatus = Status.Success;\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tstatus,\n\t\t\t\tisResolving,\n\t\t\t\thasResolved,\n\t\t\t\tcanRead: hasResolved && read.data,\n\t\t\t\tcanCreate: hasResolved && create.data,\n\t\t\t\tcanUpdate: hasResolved && update.data,\n\t\t\t\tcanDelete: hasResolved && _delete.data,\n\t\t\t};\n\t\t},\n\t\t[ resourceAsString, id ]\n\t);\n}\n\nexport default useResourcePermissions;\n\nexport function __experimentalUseResourcePermissions(\n\tresource: string,\n\tid?: unknown\n) {\n\tdeprecated( `wp.data.__experimentalUseResourcePermissions`, {\n\t\talternative: 'wp.data.useResourcePermissions',\n\t\tsince: '6.1',\n\t} );\n\treturn useResourcePermissions( resource, id );\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"warning\"];","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"blocks\"];","/**\n * WordPress dependencies\n */\nimport { useContext } from '@wordpress/element';\n\n/**\n * Internal dependencies\n */\nimport { EntityContext } from '../entity-context';\n\n/**\n * Hook that returns the ID for the nearest\n * provided entity of the specified type.\n *\n * @param {string} kind The entity kind.\n * @param {string} name The entity name.\n */\nexport default function useEntityId( kind, name ) {\n\tconst context = useContext( EntityContext );\n\treturn context?.[ kind ]?.[ name ];\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"blockEditor\"];","/**\n * WordPress dependencies\n */\nimport { privateApis as blockEditorPrivateApis } from '@wordpress/block-editor';\n\n/**\n * Internal dependencies\n */\nimport { unlock } from '../lock-unlock';\n\n// TODO: The following line should have been:\n//\n//   const unlockedApis = unlock( blockEditorPrivateApis );\n//\n// But there are hidden circular dependencies in RNMobile code, specifically in\n// certain native components in the `components` package that depend on\n// `block-editor`. What follows is a workaround that defers the `unlock` call\n// to prevent native code from failing.\n//\n// Fix once https://github.com/WordPress/gutenberg/issues/52692 is closed.\nlet unlockedApis;\n\nconst cache = new WeakMap();\n\nexport default function getRichTextValuesCached( block ) {\n\tif ( ! unlockedApis ) {\n\t\tunlockedApis = unlock( blockEditorPrivateApis );\n\t}\n\n\tif ( ! cache.has( block ) ) {\n\t\tconst values = unlockedApis.getRichTextValues( [ block ] );\n\t\tcache.set( block, values );\n\t}\n\treturn cache.get( block );\n}\n","/**\n * Internal dependencies\n */\nimport getRichTextValuesCached from './get-rich-text-values-cached';\n\nconst cache = new WeakMap();\n\nfunction getBlockFootnotesOrder( block ) {\n\tif ( ! cache.has( block ) ) {\n\t\tconst order = [];\n\t\tfor ( const value of getRichTextValuesCached( block ) ) {\n\t\t\tif ( ! value ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// replacements is a sparse array, use forEach to skip empty slots.\n\t\t\tvalue.replacements.forEach( ( { type, attributes } ) => {\n\t\t\t\tif ( type === 'core/footnote' ) {\n\t\t\t\t\torder.push( attributes[ 'data-fn' ] );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\t\tcache.set( block, order );\n\t}\n\n\treturn cache.get( block );\n}\n\nexport default function getFootnotesOrder( blocks ) {\n\t// We can only separate getting order from blocks at the root level. For\n\t// deeper inner blocks, this will not work since it's possible to have both\n\t// inner blocks and block attributes, so order needs to be computed from the\n\t// Edit functions as a whole.\n\treturn blocks.flatMap( getBlockFootnotesOrder );\n}\n","/**\n * WordPress dependencies\n */\nimport { RichTextData, create, toHTMLString } from '@wordpress/rich-text';\n\n/**\n * Internal dependencies\n */\nimport getFootnotesOrder from './get-footnotes-order';\n\nlet oldFootnotes = {};\n\nexport function updateFootnotesFromMeta( blocks, meta ) {\n\tconst output = { blocks };\n\tif ( ! meta ) {\n\t\treturn output;\n\t}\n\n\t// If meta.footnotes is empty, it means the meta is not registered.\n\tif ( meta.footnotes === undefined ) {\n\t\treturn output;\n\t}\n\n\tconst newOrder = getFootnotesOrder( blocks );\n\n\tconst footnotes = meta.footnotes ? JSON.parse( meta.footnotes ) : [];\n\tconst currentOrder = footnotes.map( ( fn ) => fn.id );\n\n\tif ( currentOrder.join( '' ) === newOrder.join( '' ) ) {\n\t\treturn output;\n\t}\n\n\tconst newFootnotes = newOrder.map(\n\t\t( fnId ) =>\n\t\t\tfootnotes.find( ( fn ) => fn.id === fnId ) ||\n\t\t\toldFootnotes[ fnId ] || {\n\t\t\t\tid: fnId,\n\t\t\t\tcontent: '',\n\t\t\t}\n\t);\n\n\tfunction updateAttributes( attributes ) {\n\t\t// Only attempt to update attributes, if attributes is an object.\n\t\tif (\n\t\t\t! attributes ||\n\t\t\tArray.isArray( attributes ) ||\n\t\t\ttypeof attributes !== 'object'\n\t\t) {\n\t\t\treturn attributes;\n\t\t}\n\n\t\tattributes = { ...attributes };\n\n\t\tfor ( const key in attributes ) {\n\t\t\tconst value = attributes[ key ];\n\n\t\t\tif ( Array.isArray( value ) ) {\n\t\t\t\tattributes[ key ] = value.map( updateAttributes );\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// To do, remove support for string values?\n\t\t\tif (\n\t\t\t\ttypeof value !== 'string' &&\n\t\t\t\t! ( value instanceof RichTextData )\n\t\t\t) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst richTextValue =\n\t\t\t\ttypeof value === 'string'\n\t\t\t\t\t? RichTextData.fromHTMLString( value )\n\t\t\t\t\t: new RichTextData( value );\n\n\t\t\tlet hasFootnotes = false;\n\n\t\t\trichTextValue.replacements.forEach( ( replacement ) => {\n\t\t\t\tif ( replacement.type === 'core/footnote' ) {\n\t\t\t\t\tconst id = replacement.attributes[ 'data-fn' ];\n\t\t\t\t\tconst index = newOrder.indexOf( id );\n\t\t\t\t\t// The innerHTML contains the count wrapped in a link.\n\t\t\t\t\tconst countValue = create( {\n\t\t\t\t\t\thtml: replacement.innerHTML,\n\t\t\t\t\t} );\n\t\t\t\t\tcountValue.text = String( index + 1 );\n\t\t\t\t\tcountValue.formats = Array.from(\n\t\t\t\t\t\t{ length: countValue.text.length },\n\t\t\t\t\t\t() => countValue.formats[ 0 ]\n\t\t\t\t\t);\n\t\t\t\t\tcountValue.replacements = Array.from(\n\t\t\t\t\t\t{ length: countValue.text.length },\n\t\t\t\t\t\t() => countValue.replacements[ 0 ]\n\t\t\t\t\t);\n\t\t\t\t\treplacement.innerHTML = toHTMLString( {\n\t\t\t\t\t\tvalue: countValue,\n\t\t\t\t\t} );\n\t\t\t\t\thasFootnotes = true;\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\tif ( hasFootnotes ) {\n\t\t\t\tattributes[ key ] =\n\t\t\t\t\ttypeof value === 'string'\n\t\t\t\t\t\t? richTextValue.toHTMLString()\n\t\t\t\t\t\t: richTextValue;\n\t\t\t}\n\t\t}\n\n\t\treturn attributes;\n\t}\n\n\tfunction updateBlocksAttributes( __blocks ) {\n\t\treturn __blocks.map( ( block ) => {\n\t\t\treturn {\n\t\t\t\t...block,\n\t\t\t\tattributes: updateAttributes( block.attributes ),\n\t\t\t\tinnerBlocks: updateBlocksAttributes( block.innerBlocks ),\n\t\t\t};\n\t\t} );\n\t}\n\n\t// We need to go through all block attributes deeply and update the\n\t// footnote anchor numbering (textContent) to match the new order.\n\tconst newBlocks = updateBlocksAttributes( blocks );\n\n\toldFootnotes = {\n\t\t...oldFootnotes,\n\t\t...footnotes.reduce( ( acc, fn ) => {\n\t\t\tif ( ! newOrder.includes( fn.id ) ) {\n\t\t\t\tacc[ fn.id ] = fn;\n\t\t\t}\n\t\t\treturn acc;\n\t\t}, {} ),\n\t};\n\n\treturn {\n\t\tmeta: {\n\t\t\t...meta,\n\t\t\tfootnotes: JSON.stringify( newFootnotes ),\n\t\t},\n\t\tblocks: newBlocks,\n\t};\n}\n","/**\n * WordPress dependencies\n */\nimport { useCallback, useMemo } from '@wordpress/element';\nimport { useDispatch, useSelect } from '@wordpress/data';\nimport { parse, __unstableSerializeAndClean } from '@wordpress/blocks';\n\n/**\n * Internal dependencies\n */\nimport { STORE_NAME } from '../name';\nimport useEntityId from './use-entity-id';\nimport { updateFootnotesFromMeta } from '../footnotes';\n\nconst EMPTY_ARRAY = [];\nconst parsedBlocksCache = new WeakMap();\n\n/**\n * Hook that returns block content getters and setters for\n * the nearest provided entity of the specified type.\n *\n * The return value has the shape `[ blocks, onInput, onChange ]`.\n * `onInput` is for block changes that don't create undo levels\n * or dirty the post, non-persistent changes, and `onChange` is for\n * persistent changes. They map directly to the props of a\n * `BlockEditorProvider` and are intended to be used with it,\n * or similar components or hooks.\n *\n * @param {string} kind         The entity kind.\n * @param {string} name         The entity name.\n * @param {Object} options\n * @param {string} [options.id] An entity ID to use instead of the context-provided one.\n *\n * @return {[unknown[], Function, Function]} The block array and setters.\n */\nexport default function useEntityBlockEditor( kind, name, { id: _id } = {} ) {\n\tconst providerId = useEntityId( kind, name );\n\tconst id = _id ?? providerId;\n\tconst { getEntityRecord, getEntityRecordEdits } = useSelect( STORE_NAME );\n\tconst { content, editedBlocks, meta } = useSelect(\n\t\t( select ) => {\n\t\t\tif ( ! id ) {\n\t\t\t\treturn {};\n\t\t\t}\n\t\t\tconst { getEditedEntityRecord } = select( STORE_NAME );\n\t\t\tconst editedRecord = getEditedEntityRecord( kind, name, id );\n\t\t\treturn {\n\t\t\t\teditedBlocks: editedRecord.blocks,\n\t\t\t\tcontent: editedRecord.content,\n\t\t\t\tmeta: editedRecord.meta,\n\t\t\t};\n\t\t},\n\t\t[ kind, name, id ]\n\t);\n\tconst { __unstableCreateUndoLevel, editEntityRecord } =\n\t\tuseDispatch( STORE_NAME );\n\n\tconst blocks = useMemo( () => {\n\t\tif ( ! id ) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tif ( editedBlocks ) {\n\t\t\treturn editedBlocks;\n\t\t}\n\n\t\tif ( ! content || typeof content !== 'string' ) {\n\t\t\treturn EMPTY_ARRAY;\n\t\t}\n\n\t\t// If there's an edit, cache the parsed blocks by the edit.\n\t\t// If not, cache by the original entity record.\n\t\tconst edits = getEntityRecordEdits( kind, name, id );\n\t\tconst isUnedited = ! edits || ! Object.keys( edits ).length;\n\t\tconst cackeKey = isUnedited ? getEntityRecord( kind, name, id ) : edits;\n\t\tlet _blocks = parsedBlocksCache.get( cackeKey );\n\n\t\tif ( ! _blocks ) {\n\t\t\t_blocks = parse( content );\n\t\t\tparsedBlocksCache.set( cackeKey, _blocks );\n\t\t}\n\n\t\treturn _blocks;\n\t}, [\n\t\tkind,\n\t\tname,\n\t\tid,\n\t\teditedBlocks,\n\t\tcontent,\n\t\tgetEntityRecord,\n\t\tgetEntityRecordEdits,\n\t] );\n\n\tconst onChange = useCallback(\n\t\t( newBlocks, options ) => {\n\t\t\tconst noChange = blocks === newBlocks;\n\t\t\tif ( noChange ) {\n\t\t\t\treturn __unstableCreateUndoLevel( kind, name, id );\n\t\t\t}\n\t\t\tconst { selection, ...rest } = options;\n\n\t\t\t// We create a new function here on every persistent edit\n\t\t\t// to make sure the edit makes the post dirty and creates\n\t\t\t// a new undo level.\n\t\t\tconst edits = {\n\t\t\t\tselection,\n\t\t\t\tcontent: ( { blocks: blocksForSerialization = [] } ) =>\n\t\t\t\t\t__unstableSerializeAndClean( blocksForSerialization ),\n\t\t\t\t...updateFootnotesFromMeta( newBlocks, meta ),\n\t\t\t};\n\n\t\t\teditEntityRecord( kind, name, id, edits, {\n\t\t\t\tisCached: false,\n\t\t\t\t...rest,\n\t\t\t} );\n\t\t},\n\t\t[\n\t\t\tkind,\n\t\t\tname,\n\t\t\tid,\n\t\t\tblocks,\n\t\t\tmeta,\n\t\t\t__unstableCreateUndoLevel,\n\t\t\teditEntityRecord,\n\t\t]\n\t);\n\n\tconst onInput = useCallback(\n\t\t( newBlocks, options ) => {\n\t\t\tconst { selection, ...rest } = options;\n\t\t\tconst footnotesChanges = updateFootnotesFromMeta( newBlocks, meta );\n\t\t\tconst edits = { selection, ...footnotesChanges };\n\n\t\t\teditEntityRecord( kind, name, id, edits, {\n\t\t\t\tisCached: true,\n\t\t\t\t...rest,\n\t\t\t} );\n\t\t},\n\t\t[ kind, name, id, meta, editEntityRecord ]\n\t);\n\n\treturn [ blocks, onInput, onChange ];\n}\n","/**\n * WordPress dependencies\n */\nimport { useCallback } from '@wordpress/element';\nimport { useDispatch, useSelect } from '@wordpress/data';\n\n/**\n * Internal dependencies\n */\nimport { STORE_NAME } from '../name';\nimport useEntityId from './use-entity-id';\n\n/**\n * Hook that returns the value and a setter for the\n * specified property of the nearest provided\n * entity of the specified type.\n *\n * @param {string}        kind  The entity kind.\n * @param {string}        name  The entity name.\n * @param {string}        prop  The property name.\n * @param {number|string} [_id] An entity ID to use instead of the context-provided one.\n *\n * @return {[*, Function, *]} An array where the first item is the\n *                            property value, the second is the\n *                            setter and the third is the full value\n * \t\t\t\t\t\t\t  object from REST API containing more\n * \t\t\t\t\t\t\t  information like `raw`, `rendered` and\n * \t\t\t\t\t\t\t  `protected` props.\n */\nexport default function useEntityProp( kind, name, prop, _id ) {\n\tconst providerId = useEntityId( kind, name );\n\tconst id = _id ?? providerId;\n\n\tconst { value, fullValue } = useSelect(\n\t\t( select ) => {\n\t\t\tconst { getEntityRecord, getEditedEntityRecord } =\n\t\t\t\tselect( STORE_NAME );\n\t\t\tconst record = getEntityRecord( kind, name, id ); // Trigger resolver.\n\t\t\tconst editedRecord = getEditedEntityRecord( kind, name, id );\n\t\t\treturn record && editedRecord\n\t\t\t\t? {\n\t\t\t\t\t\tvalue: editedRecord[ prop ],\n\t\t\t\t\t\tfullValue: record[ prop ],\n\t\t\t\t  }\n\t\t\t\t: {};\n\t\t},\n\t\t[ kind, name, id, prop ]\n\t);\n\tconst { editEntityRecord } = useDispatch( STORE_NAME );\n\tconst setValue = useCallback(\n\t\t( newValue ) => {\n\t\t\teditEntityRecord( kind, name, id, {\n\t\t\t\t[ prop ]: newValue,\n\t\t\t} );\n\t\t},\n\t\t[ editEntityRecord, kind, name, id, prop ]\n\t);\n\n\treturn [ value, setValue, fullValue ];\n}\n","/**\n * Internal dependencies\n */\nimport { useEntityRecordsWithPermissions } from './hooks/use-entity-records';\nimport { RECEIVE_INTERMEDIATE_RESULTS } from './utils';\nimport { lock } from './lock-unlock';\n\nexport const privateApis = {};\nlock( privateApis, {\n\tuseEntityRecordsWithPermissions,\n\tRECEIVE_INTERMEDIATE_RESULTS,\n} );\n","/**\n * WordPress dependencies\n */\nimport { createReduxStore, register } from '@wordpress/data';\n\n/**\n * Internal dependencies\n */\nimport reducer from './reducer';\nimport * as selectors from './selectors';\nimport * as privateSelectors from './private-selectors';\nimport * as actions from './actions';\nimport * as privateActions from './private-actions';\nimport * as resolvers from './resolvers';\nimport createLocksActions from './locks/actions';\nimport {\n\trootEntitiesConfig,\n\tadditionalEntityConfigLoaders,\n\tgetMethodName,\n} from './entities';\nimport { STORE_NAME } from './name';\nimport { unlock } from './lock-unlock';\nimport { dynamicActions, dynamicSelectors } from './dynamic-entities';\n\n// The entity selectors/resolvers and actions are shortcuts to their generic equivalents\n// (getEntityRecord, getEntityRecords, updateEntityRecord, updateEntityRecords)\n// Instead of getEntityRecord, the consumer could use more user-friendly named selector: getPostType, getTaxonomy...\n// The \"kind\" and the \"name\" of the entity are combined to generate these shortcuts.\nconst entitiesConfig = [\n\t...rootEntitiesConfig,\n\t...additionalEntityConfigLoaders.filter( ( config ) => !! config.name ),\n];\n\nconst entitySelectors = entitiesConfig.reduce( ( result, entity ) => {\n\tconst { kind, name, plural } = entity;\n\tresult[ getMethodName( kind, name ) ] = ( state, key, query ) =>\n\t\tselectors.getEntityRecord( state, kind, name, key, query );\n\n\tif ( plural ) {\n\t\tresult[ getMethodName( kind, plural, 'get' ) ] = ( state, query ) =>\n\t\t\tselectors.getEntityRecords( state, kind, name, query );\n\t}\n\treturn result;\n}, {} );\n\nconst entityResolvers = entitiesConfig.reduce( ( result, entity ) => {\n\tconst { kind, name, plural } = entity;\n\tresult[ getMethodName( kind, name ) ] = ( key, query ) =>\n\t\tresolvers.getEntityRecord( kind, name, key, query );\n\n\tif ( plural ) {\n\t\tconst pluralMethodName = getMethodName( kind, plural, 'get' );\n\t\tresult[ pluralMethodName ] = ( ...args ) =>\n\t\t\tresolvers.getEntityRecords( kind, name, ...args );\n\t\tresult[ pluralMethodName ].shouldInvalidate = ( action ) =>\n\t\t\tresolvers.getEntityRecords.shouldInvalidate( action, kind, name );\n\t}\n\treturn result;\n}, {} );\n\nconst entityActions = entitiesConfig.reduce( ( result, entity ) => {\n\tconst { kind, name } = entity;\n\tresult[ getMethodName( kind, name, 'save' ) ] = ( record, options ) =>\n\t\tactions.saveEntityRecord( kind, name, record, options );\n\tresult[ getMethodName( kind, name, 'delete' ) ] = ( key, query, options ) =>\n\t\tactions.deleteEntityRecord( kind, name, key, query, options );\n\treturn result;\n}, {} );\n\nconst storeConfig = () => ( {\n\treducer,\n\tactions: {\n\t\t...dynamicActions,\n\t\t...actions,\n\t\t...entityActions,\n\t\t...createLocksActions(),\n\t},\n\tselectors: {\n\t\t...dynamicSelectors,\n\t\t...selectors,\n\t\t...entitySelectors,\n\t},\n\tresolvers: { ...resolvers, ...entityResolvers },\n} );\n\n/**\n * Store definition for the code data namespace.\n *\n * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore\n */\nexport const store = createReduxStore( STORE_NAME, storeConfig() );\nunlock( store ).registerPrivateSelectors( privateSelectors );\nunlock( store ).registerPrivateActions( privateActions );\nregister( store ); // Register store after unlocking private selectors to allow resolvers to use them.\n\nexport { default as EntityProvider } from './entity-provider';\nexport * from './entity-provider';\nexport * from './entity-types';\nexport * from './fetch';\nexport * from './hooks';\nexport * from './private-apis';\n","/**\n * Internal dependencies\n */\nimport createLocks from './engine';\n\nexport default function createLocksActions() {\n\tconst locks = createLocks();\n\n\tfunction __unstableAcquireStoreLock( store, path, { exclusive } ) {\n\t\treturn () => locks.acquire( store, path, exclusive );\n\t}\n\n\tfunction __unstableReleaseStoreLock( lock ) {\n\t\treturn () => locks.release( lock );\n\t}\n\n\treturn { __unstableAcquireStoreLock, __unstableReleaseStoreLock };\n}\n"],"names":["_typeof","obj","Symbol","iterator","constructor","prototype","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","getValuePair","instance","_map","_arrayTreeMap","_objectTreeMap","has","get","properties","keys","sort","map","Array","isArray","property","undefined","propertyValue","valuePair","delete","set","EquivalentKeyMap","iterable","Constructor","TypeError","_classCallCheck","this","clear","iterablePairs","forEach","value","push","protoProps","previousValuePair","callback","_this","thisArg","arguments","call","Map","size","module","exports","equal","a","b","entries","Set","ArrayBuffer","isView","RegExp","source","flags","valueOf","toString","hasOwnProperty","t","n","r","Math","floor","abs","pow","d","s","e","o","c","Error","code","indexOf","join","byteLength","toByteArray","l","p","f","u","charCodeAt","fromByteArray","Uint8Array","g","String","fromCharCode","min","RangeError","__proto__","isEncoding","write","slice","K","buffer","_","from","isBuffer","m","copy","type","data","X","h","toPrimitive","H","z","toLowerCase","y","P","x","D","I","A","M","C","R","E","lastIndexOf","readUInt16BE","w","parseInt","substr","S","G","T","Y","v","k","L","V","$","N","apply","W","O","F","B","U","J","j","split","trim","replace","Q","q","name","Buffer","SlowBuffer","alloc","INSPECT_MAX_BYTES","kMaxLength","TYPED_ARRAY_SUPPORT","foo","console","error","byteOffset","species","poolSize","fill","allocUnsafe","allocUnsafeSlow","_isBuffer","compare","offset","concat","swap16","swap32","swap64","toLocaleString","equals","inspect","includes","isFinite","toJSON","_arr","subarray","readUIntLE","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","read","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","copyWithin","ieee754","formatArgs","useColors","namespace","humanize","diff","color","splice","save","storage","setItem","removeItem","load","getItem","env","DEBUG","window","process","__nwjs","navigator","userAgent","match","document","documentElement","style","WebkitAppearance","firebug","exception","table","$1","localStorage","destroy","warn","colors","log","debug","formatters","JSON","stringify","message","_process","enabled","Date","prev","curr","coerce","unshift","selectColor","extend","init","substring","default","stack","disable","names","skips","enable","test","ms","create","getPrototypeOf","_maxListeners","defaultMaxListeners","_events","_eventsCount","newListener","emit","listener","warned","emitter","count","fired","removeListener","wrapFn","bind","on","once","addEventListener","removeEventListener","Reflect","Function","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","Number","isNaN","Promise","EventEmitter","setMaxListeners","getMaxListeners","context","addListener","prependListener","prependOnceListener","shift","pop","off","removeAllListeners","listeners","rawListeners","listenerCount","eventNames","globalThis","RTCPeerConnection","mozRTCPeerConnection","webkitRTCPeerConnection","RTCSessionDescription","mozRTCSessionDescription","webkitRTCSessionDescription","RTCIceCandidate","mozRTCIceCandidate","webkitRTCIceCandidate","NaN","LN2","super_","round","exec","parseFloat","long","setTimeout","run","clearTimeout","fun","array","nextTick","title","browser","argv","version","versions","binding","cwd","chdir","umask","queueMicrotask","resolve","then","catch","self","crypto","msCrypto","getRandomValues","codes","allowHalfOpen","readable","_writableState","ended","end","highWaterMark","getBuffer","_readableState","destroyed","inherits","_transform","objectMode","readableObjectMode","pipes","pipesCount","flowing","endEmitted","reading","sync","needReadable","emittedReadable","readableListening","resumeScheduled","paused","emitClose","autoDestroy","defaultEncoding","awaitDrain","readingMore","decoder","encoding","StringDecoder","_read","_destroy","head","resume","first","consume","finished","ReadableState","debuglog","getHighWaterMark","ERR_INVALID_ARG_TYPE","ERR_STREAM_PUSH_AFTER_EOF","ERR_METHOD_NOT_IMPLEMENTED","ERR_STREAM_UNSHIFT_AFTER_END_EVENT","errorOrDestroy","_undestroy","undestroy","isPaused","setEncoding","next","pipe","hasUnpiped","needDrain","pause","unpipe","stdout","stderr","wrap","asyncIterator","_fromList","events","util","_transformState","transforming","writecb","writechunk","afterTransform","needTransform","writeencoding","transform","flush","_flush","ERR_MULTIPLE_CALLBACK","ERR_TRANSFORM_ALREADY_TRANSFORMING","ERR_TRANSFORM_WITH_LENGTH_0","_write","entry","finish","pendingcb","corkedRequestsFree","writableObjectMode","finalCalled","ending","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","bufferedRequest","lastBufferedRequest","prefinished","errorEmitted","bufferedRequestCount","writev","_writev","final","_final","chunk","isBuf","allBuffers","WritableState","deprecate","ERR_STREAM_CANNOT_PIPE","ERR_STREAM_DESTROYED","ERR_STREAM_NULL_VALUES","ERR_STREAM_WRITE_AFTER_END","ERR_UNKNOWN_ENCODING","hasInstance","cork","uncork","setDefaultEncoding","done","setPrototypeOf","stream","reject","filter","getOwnPropertyDescriptor","custom","tail","_getString","_getBuffer","getOwnPropertyDescriptors","defineProperties","depth","customInspect","ERR_STREAM_PREMATURE_CLOSE","req","setHeader","abort","ERR_MISSING_ARGS","reduce","ERR_INVALID_OPT_VALUE","Stream","Readable","Writable","Duplex","Transform","PassThrough","pipeline","text","fillLast","lastNeed","lastTotal","lastChar","trace","super","assign","_id","_debug","channelName","initiator","channelConfig","channelNegotiated","negotiated","config","offerOptions","answerOptions","sdpTransform","streams","trickle","allowHalfTrickle","iceCompleteTimeout","destroying","_connected","remoteAddress","remoteFamily","remotePort","localAddress","localFamily","localPort","_wrtc","wrtc","_pcReady","_channelReady","_iceComplete","_iceCompleteTimer","_channel","_pendingCandidates","_isNegotiating","_firstNegotiation","_batchedNegotiation","_queuedNegotiation","_sendersAwaitingStable","_senderMap","_closingInterval","_remoteTracks","_remoteStreams","_chunk","_cb","_interval","_pc","_isReactNativeWebrtc","_peerConnectionId","oniceconnectionstatechange","_onIceStateChange","onicegatheringstatechange","onconnectionstatechange","_onConnectionStateChange","onsignalingstatechange","_onSignalingStateChange","onicecandidate","_onIceCandidate","peerIdentity","_setupData","channel","createDataChannel","ondatachannel","addStream","ontrack","_onTrack","_needsNegotiation","_onFinishBound","_onFinish","bufferSize","bufferedAmount","connected","readyState","address","port","family","signal","parse","renegotiate","transceiverRequest","addTransceiver","kind","candidate","remoteDescription","_addIceCandidate","sdp","setRemoteDescription","_createAnswer","addIceCandidate","endsWith","send","getTracks","addTrack","removed","replaceTrack","removeTrack","removeStream","negotiate","_createOffer","clearInterval","close","onmessage","onopen","onclose","onerror","binaryType","bufferedAmountLowThreshold","label","_onChannelMessage","onbufferedamountlow","_onChannelBufferedAmountLow","_onChannelOpen","_onChannelClose","filename","lineno","colno","setInterval","_startIceCompleteTimeout","createOffer","localDescription","setLocalDescription","_requestMissingTransceivers","getTransceivers","mid","sender","track","requested","createAnswer","connectionState","iceConnectionState","iceGatheringState","_maybeReady","getStats","values","result","stat","id","timestamp","_connecting","localCandidateId","ip","ipAddress","portNumber","googLocalAddress","remoteCandidateId","googRemoteAddress","selectedCandidatePairId","googActiveConnection","selected","_onInterval","unref","signalingState","sdpMLineIndex","sdpMid","some","WEBRTC_SUPPORT","iceServers","urls","sdpSemantics","randombytes","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","definition","prop","toStringTag","mergeHistoryChanges","changes1","changes2","newChanges","to","addHistoryChangesIntoRecord","record","changes","existingChangesIndex","findIndex","recordIdentifier","isShallowEqual","nextRecord","isMatch","reducer","state","action","replacer","actionProperty","nextKeyState","__assign","lowerCase","str","SuppressedError","DEFAULT_SPLIT_REGEXP","DEFAULT_STRIP_REGEXP","noCase","input","options","splitRegexp","stripRegexp","delimiter","start","charAt","re","capitalCaseTransform","toUpperCase","upperCaseFirst","pascalCaseTransform","index","firstChar","lowerChars","pascalCase","DEFAULT_ENTITY_KEY","POST_RAW_ATTRIBUTES","rootEntitiesConfig","__","baseURL","baseURLParams","_fields","plural","syncConfig","fetch","async","apiFetch","path","applyChangesToDoc","doc","getMap","fromCRDTDoc","syncObjectType","getSyncObjectId","rawAttributes","supportsPagination","transientEdits","blocks","getTitle","rendered","getRevisionsUrl","parentId","revisionId","additionalEntityConfigLoaders","loadEntities","postTypes","postType","_postType$rest_namesp","isTemplate","rest_namespace","rest_base","selection","mergedEdits","meta","_record$slug","slug","__unstablePrePersist","prePersistPostType","__unstable_rest_base","serialisableBlocksCache","makeBlocksSerializable","revisionKey","taxonomies","taxonomy","_taxonomy$rest_namesp","_site$schema$properti","entity","site","method","labels","schema","persistedRecord","edits","newEdits","status","WeakMap","makeBlockAttributesSerializable","attributes","newAttributes","RichTextData","block","innerBlocks","rest","getMethodName","prefix","fn","cache","query","parts","stableKey","page","perPage","fields","include","_getNormalizedCommaSe","_getNormalizedCommaSe2","getNormalizedCommaSeparable","addQueryArgs","getContextFromAction","getQueryParts","getMergedItemIds","itemIds","nextItemIds","_itemIds$length","nextItemIdsStartIndex","max","mergedItemIds","isInNextItemsRange","removeEntitiesById","entities","ids","fromEntries","itemId","isInteger","receiveQueries","compose","ifMatchingAction","replaceAction","onSubKey","items","item","Boolean","combineReducers","accumulator","nextItem","hasChanges","fastDeepEqual","conservativeMapItem","contextState","itemIsComplete","queryParts","isCompleteQuery","queries","removedItems","queryGroup","contextQueries","queryItems","queryId","withMultiEntityRecordEdits","newState","recordId","acc","entityConfig","queriedData","queriedDataReducer","_action$query$context","nextState","nextEdits","_record$key$raw","raw","persistedEdits","saving","pending","isAutosave","deleting","revisions","recordKey","terms","users","byId","newUsers","user","queryID","currentTheme","stylesheet","currentGlobalStylesId","currentUser","themeGlobalStyleVariations","variations","themeBaseGlobalStyles","globalStyles","themeGlobalStyleRevisions","currentId","newConfig","entitiesConfig","entitiesDataReducer","entitiesByKind","memo","subEntities","kindReducer","kindMemo","newData","records","editsReference","undoManager","history","stagedRecord","dropPendingRedos","appendStagedRecordToLatestHistoryRecord","_history$index","latestRecord","addRecord","isStaged","isEmpty","isRecordEmpty","undo","undoRecord","redo","redoRecord","hasUndo","hasRedo","createUndoManager","embedPreviews","url","preview","userPermissions","isAllowed","permissions","autosaves","postId","autosavesData","blockPatterns","patterns","blockPatternCategories","categories","userPatternCategories","patternCategories","navigationFallbackId","fallbackId","defaultTemplates","templateId","registeredPostMeta","STORE_NAME","setNestedValue","object","normalizedPath","idx","queriedItemsCacheByState","getQueriedItems","createSelector","queriedItemsCache","queriedItems","startOffset","endOffset","filteredItem","field","fieldName","getQueriedItemsUncached","getQueriedTotalItems","_state$queries$contex","totalItems","ALLOWED_RESOURCE_ACTIONS","getUserPermissionsFromAllowHeader","allowedMethods","methods","update","actionName","methodName","getUserPermissionCacheKey","resource","EMPTY_OBJECT","isRequestingEmbedPreview","createRegistrySelector","select","isResolving","getAuthors","deprecated","since","alternative","getUserQueryResults","getCurrentUser","_state$users$queries$","getEntitiesByKind","getEntitiesConfig","getEntity","getEntityConfig","find","getEntityRecord","_query$context","queriedState","_query$context2","__experimentalGetEntityRecordNoResolver","__unstableNormalizeArgs","args","newArgs","isNumericID","getRawEntityRecord","_key","attribute","isRawAttribute","_query$context3","hasEntityRecords","getEntityRecords","getEntityRecordsTotalItems","getEntityRecordsTotalPages","per_page","ceil","_state$queries$contex2","totalPages","getQueriedTotalPages","__experimentalGetDirtyEntityRecords","dirtyRecords","primaryKeys","primaryKey","hasEditsForEntityRecord","entityRecord","getEditedEntityRecord","__experimentalGetEntitiesBeingSaved","recordsBeingSaved","isSavingEntityRecord","getEntityRecordEdits","getEntityRecordNonTransientEdits","edited","_query$context4","isAutosavingEntityRecord","_state$entities$recor","_state$entities$recor2","isDeletingEntityRecord","_state$entities$recor3","getLastEntitySaveError","getLastEntityDeleteError","getUndoEdit","getRedoEdit","getCurrentTheme","__experimentalGetCurrentGlobalStylesId","getThemeSupports","_getCurrentTheme$them","theme_supports","getEmbedPreview","isPreviewEmbedFallback","oEmbedLinkCheck","html","canUser","canUserEditEntityRecord","getAutosaves","getAutosave","authorId","autosave","author","hasFetchedAutosaves","hasFinishedResolution","getReferenceByDistinctEdits","__experimentalGetCurrentThemeBaseGlobalStyles","__experimentalGetCurrentThemeGlobalStylesVariations","getBlockPatterns","getBlockPatternCategories","getUserPatternCategories","getCurrentThemeGlobalStylesRevisions","getDefaultTemplateId","getRevisions","queriedStateRevisions","getRevision","_query$context5","_query$context6","lock","unlock","__dangerousOptInToUnstableAPIsOnlyForCoreModules","getUndoManager","getNavigationFallbackId","getBlockPatternsForPostType","getEntityRecordsPermissions","getEntityRecordPermissions","getRegisteredPostMeta","_state$registeredPost","normalizePageId","getHomePage","siteData","homepageId","show_on_front","page_on_front","getPostsPageId","page_for_posts","getTemplateId","homepage","templates","editedEntity","postsPageId","currentTemplateSlug","template","currentTemplate","slugToCheck","rnds8","rng","byteToHex","arr","uuid","buf","rnds","random","getNestedValue","defaultValue","receiveItems","maxItems","defaultProcessor","requests","preflightResponse","endpoints","results","batchRequests","chunkSize","tmp","batchResponse","validation","request","body","headers","batchResults","failed","responses","response","output","createBatch","processor","lastId","queue","ObservableSet","add","inputOrThunk","finally","unsubscribe","subscribe","isSuccess","queueItem","_result$output","subscribers","subscriber","setIfUndefined","createT","last","appendTo","dest","src","Observable","_observers","_f","observers","log10","imul","log2","sqrt","isNegativeZero","sign","trimLeftRegex","fromCodePoint","fromCamelCaseRegex","fromCamelCase","separator","trimLeft","utf8TextEncoder","TextEncoder","encodeUtf8","encode","encodedString","unescape","encodeURIComponent","len","codePointAt","utf8TextDecoder","TextDecoder","fatal","ignoreBOM","decode","_localStorage","newValue","usePolyfill","varStorage","hasProperty","callAll","fs","nop","equalityDeep","equalityStrict","isNode","release","isBrowser","params","platform","hasParam","pargs","currParamName","parg","location","search","kv","computeParams","getVariable","forceColor","FORCE_COLOR","supportsColor","isTTY","createUint8ArrayFromLen","createUint8ArrayViewFromArrayBuffer","toBase64","bytes","btoa","fromBase64","atob","BIT7","BIT8","BITS7","MAX_SAFE_INTEGER","MIN_SAFE_INTEGER","num","Encoder","cpos","cbuf","bufs","createEncoder","toUint8Array","encoder","uint8arr","curPos","bufferLen","writeUint8","writeVarUint","writeVarInt","isNegative","_strBuffer","_maxStrBSize","writeVarString","encodeInto","written","writeVarUint8Array","writeUint8Array","uint8Array","leftCopyLen","rightCopyLen","writeOnDataView","verifyLen","dview","DataView","floatTestBed","writeAny","setFloat32","getFloat32","writeFloat32","setFloat64","writeFloat64","setBigInt64","writeBigInt64","RleEncoder","writer","flushUintOptRleEncoder","UintOptRleEncoder","flushIntDiffOptRleEncoder","encodedDiff","IntDiffOptRleEncoder","StringEncoder","sarr","lensE","string","methodUnimplemented","unexpectedCase","errorUnexpectedEndOfArray","errorIntegerOutOfRange","Decoder","pos","createDecoder","readVarUint8Array","view","readUint8Array","readVarUint","readUint8","mult","readVarInt","readVarString","remainingLen","nextLen","decodeURIComponent","escape","readFromDataView","dv","readAnyLookupTable","getFloat64","getBigInt64","readAny","RleDecoder","reader","UintOptRleDecoder","IntDiffOptRleDecoder","hasCount","spos","res","subtle","rand","uint32","Uint32Array","uuidv4Template","uuidv4","all","Pair","left","right","DOMParser","ELEMENT_NODE","TEXT_NODE","CDATA_SECTION_NODE","COMMENT_NODE","DOCUMENT_NODE","DOCUMENT_TYPE_NODE","DOCUMENT_FRAGMENT_NODE","getUnixTime","now","BOLD","UNBOLD","BLUE","GREY","GREEN","RED","PURPLE","ORANGE","UNCOLOR","loggingColors","nextColor","lastLoggingTime","_browserStyleMap","computeLoggingArgs","strBuilder","styles","currentStyle","logArgs","arg","print","vconsoles","vc","createIterator","iteratorMap","fmap","DeleteItem","clock","DeleteSet","clients","iterateDeletedStructs","transaction","ds","deletes","clientid","structs","store","del","iterateStructs","isDeleted","dis","client","midindex","midclock","findIndexDS","sortAndMergeDeleteSet","dels","addToDeleteSet","createDeleteSet","writeDeleteSet","restEncoder","dsitems","resetDsCurVal","writeDsClock","writeDsLen","readDeleteSet","numClients","restDecoder","numberOfDeletes","dsField","readDsClock","readDsLen","readAndApplyDeleteSet","unappliedDS","getState","clockEnd","findIndexSS","struct","deleted","splitItem","UpdateEncoderV2","generateNewClientId","Doc","guid","collectionid","gc","gcFilter","autoLoad","shouldLoad","clientID","share","StructStore","_transaction","_transactionCleanups","subdocs","_item","isLoaded","isSynced","whenLoaded","provideSyncedPromise","eventHandler","whenSynced","transact","subdocsLoaded","getSubdocs","getSubdocGuids","origin","TypeConstructor","AbstractType","_integrate","Constr","parent","_start","_length","getArray","YArray","getText","YText","YMap","getXmlFragment","YXmlFragment","subdoc","content","opts","subdocsAdded","subdocsRemoved","eventName","DSDecoderV1","UpdateDecoderV1","readLeftID","createID","readRightID","readClient","readInfo","readString","readParentInfo","readTypeRef","readLen","readBuf","newBuf","readJSON","readKey","DSDecoderV2","dsCurrVal","UpdateDecoderV2","keyClockDecoder","clientDecoder","leftClockDecoder","rightClockDecoder","infoDecoder","stringDecoder","parentInfoDecoder","typeRefDecoder","lenDecoder","ID","keyClock","DSEncoderV1","UpdateEncoderV1","writeLeftID","writeRightID","writeClient","writeInfo","info","writeString","writeParentInfo","isYKey","writeTypeRef","writeLen","any","writeBuf","writeJSON","embed","writeKey","DSEncoderV2","keyMap","keyClockEncoder","clientEncoder","leftClockEncoder","rightClockEncoder","infoEncoder","stringEncoder","parentInfoEncoder","typeRefEncoder","lenEncoder","writeClientsStructs","_sm","sm","getStateVector","_clock","startNewStructs","firstStruct","writeStructs","applyUpdateV2","ydoc","transactionOrigin","YDecoder","structDecoder","local","retry","ss","clientRefs","numOfStateUpdates","numberOfStructs","refs","GC","Skip","cantCopyParentInfo","Item","readItemContent","readClientsStructRefs","restStructs","clientsStructRefs","clientsStructRefsIds","getNextStructTarget","nextStructsTarget","curStructsTarget","missingSV","updateMissingSv","mclock","stackHead","addStackToRestSS","unapplicableItems","missing","getMissing","structRefs","integrate","integrateStructs","pendingStructs","mergeUpdatesV2","dsRest","pendingDs","pendingDSUpdate","dsRest2","readUpdateV2","applyUpdate","encodeStateAsUpdateV2","encodedTargetStateVector","targetStateVector","createDeleteSetFromStructStore","writeStateAsUpdate","decodeStateVector","updates","diffUpdateV2","mergeUpdates","convertUpdateFormatV2ToV1","encodeStateAsUpdate","decodedState","ssLength","readStateVector","writeStateVector","sv","EventHandler","createEventHandler","addEventHandlerListener","removeEventHandlerListener","callEventHandlerListeners","arg0","arg1","compareIDs","Snapshot","isVisible","snapshot","splitSnapshotAffectedStructs","getItemCleanStart","lastStruct","addStruct","findIndexCleanStart","getItemCleanEnd","clockStart","Transaction","deleteSet","beforeState","afterState","changed","changedParentTypes","_mergeStructs","_needFormattingCleanup","writeUpdateMessageFromTransaction","writeStructsFromTransaction","addChangedTypeToTransaction","parentSub","tryToMergeWithLefts","mergeWith","merged","cleanupTransactions","transactionCleanups","mergeStructs","subs","itemtype","_callObserver","_dEH","event","currentTarget","_path","event1","event2","cleanupYTextAfterTransaction","deleteItems","di","deleteItem","endDeleteItemClock","si","keep","tryGcDeleteSet","tryMergeDeleteSet","beforeClock","firstChangePos","replacedStructPos","loaded","added","initialCall","finishCleanup","LazyStructReader","filterSkips","gen","lazyStructReaderGenerator","LazyStructWriter","currClient","startClock","clientStructs","sliceStruct","leftItem","rightOrigin","YEncoder","updateDecoders","lazyStructDecoders","currWrite","updateEncoder","lazyStructEncoder","dec","dec1","dec2","clockDiff","currDecoder","firstClient","iterated","writeStructToLazyStructWriter","finishLazyStructWriting","dss","dssI","delsLeft","mergeDeleteSets","lazyStructWriter","svClock","flushLazyStructWriter","lazyWriter","partStructs","blockTransformer","updateDecoder","lazyDecoder","convertUpdateFormat","errorComputeChanges","YEvent","_changes","_keys","_delta","getPathTo","oldValue","adds","getContent","delta","lastOp","packOp","insert","retain","child","globalSearchMarkerTimestamp","ArraySearchMarker","marker","overwriteMarker","findMarker","yarray","_searchMarker","pindex","refreshMarkerTimestamp","countable","searchMarker","pm","markPosition","updateMarkerChanges","callTypeObservers","changedType","_eH","_copy","clone","_encoder","_first","_parentSubs","observe","observeDeep","unobserve","unobserveDeep","typeListSlice","cs","typeListToArray","typeListForEach","typeListMap","typeListCreateIterator","currentContent","currentContentIndex","typeListGet","typeListInsertGenericsAfter","referenceItem","ownClientId","jsonContent","packJsonContent","ContentAny","ContentBinary","ContentDoc","ContentType","lengthExceeded","typeListInsertGenerics","startIndex","typeListDelete","startLength","typeMapDelete","typeMapSet","typeMapGet","val","typeMapGetAll","typeMapHas","createMapIterator","YArrayEvent","_prelimContent","toArray","el","parentSubs","maxMarker","currMarker","typeListPushGenerics","YArrayRefID","YMapEvent","ymap","keysChanged","_value","YMapRefID","equalAttrs","ItemTextListPosition","currentAttributes","forward","ContentFormat","updateCurrentAttributes","findNextPosition","findPosition","insertNegatedAttributes","currPos","negatedAttributes","nextFormat","format","minimizeAttributeChanges","insertAttributes","currentVal","insertText","_val","ContentString","ContentEmbed","getLength","formatText","iterationLoop","attr","newlines","cleanupFormattingGap","startAttributes","currAttributes","endFormats","cf","cleanups","reachedCurr","startAttrValue","cleanupYTextFormatting","needFullCleanup","afterClock","attrs","cleanupContextlessFormattingGap","yText","deleteText","startAttrs","YTextEvent","ytext","childListChanged","sub","oldAttributes","deleteLen","addOp","op","_k","curVal","_pending","_hasFormatting","applyDelta","toDelta","sanitize","ins","prevSnapshot","computeYChange","ops","packStr","addAttributes","computeDelta","cur","insertEmbed","removeAttribute","attributeName","setAttribute","attributeValue","getAttribute","getAttributes","YTextRefID","YXmlTreeWalker","root","_filter","_root","_currentNode","_firstCall","YXmlElement","firstChild","createTreeWalker","querySelector","element","nodeName","querySelectorAll","YXmlEvent","xml","toDOM","_document","hooks","fragment","createDocumentFragment","_createAssociation","xmlType","insertBefore","insertAfter","ref","refItem","pc","YXmlFragmentRefID","_prelimAttrs","nextSibling","prevSibling","stringBuilder","keysLen","toLocaleLowerCase","hasAttribute","dom","createElement","yxml","appendChild","YXmlElementRefID","attributesChanged","YXmlHook","hookName","hook","createDom","YXmlHookRefID","YXmlText","createTextNode","nestedNodes","node","YXmlTextRefID","AbstractStruct","encodingRef","isCountable","getRef","ContentDeleted","markDeleted","createDocFromOpts","_offset","_right","ContentJSON","firstCharCode","typeRefs","_decoder","rightItem","redone","isMarked","doKeep","doDelete","parentItem","conflictingItems","itemsBeforeOrigin","parentGCd","newStruct","replaceStruct","ykey","findRootTypeKey","contentRefs","glo","global","importIdentifier","rtop","onsuccess","db","stores","access","getStore","range","addAutoKey","iterateKeys","keyrange","direction","cursor","continue","iterateOnRequest","openKeyCursor","objectStore","customStoreName","updatesStoreName","fetchUpdates","idbPersistence","beforeApplyUpdatesCallback","afterApplyUpdatesCallback","updatesStore","limit","getAll","lower","_dbref","IDBKeyRange","lowerBound","_destroyed","queryFirst","lastKey","cnt","_dbsize","IndexeddbPersistence","synced","_db","indexedDB","open","onupgradeneeded","autoIncrement","createObjectStore","onversionchange","_storeTimeout","_storeTimeoutId","_storeUpdate","forceStore","upper","upperBound","storeState","clearData","deleteDatabase","put","connectIndexDb","objectId","objectType","provider","setupWS","wsclient","shouldConnect","ws","websocket","WebSocket","pingTimeout","connecting","lastMessageReceived","sendPing","messageReconnectTimeout","unsuccessfulReconnects","WebsocketClient","_checkInterval","disconnect","connect","channels","BC","BroadcastChannel","room","_onChange","postMessage","getChannel","bc","writeSyncStep1","writeDocumentStateVector","encodeStateVectorV2","writeSyncStep2","encodedStateVector","readSyncStep2","Awareness","states","getLocalState","outdatedTimeout","lastUpdated","setLocalState","remove","removeAwarenessStates","currLocalMeta","prevState","updated","filteredUpdated","setLocalStateField","getStates","awareness","curMeta","encodeAwarenessUpdate","encrypt","promise","iv","cipher","encryptedDataEncoder","decrypt","dataDecoder","decoding","reason","decryptJson","decryptedValue","_print","moduleName","debugRegexVar","doLogging","timeNow","timeDiff","signalingConns","rooms","checkIsSynced","webrtcConns","peer","logging","readMessage","syncedCallback","messageType","sendReply","syncMessageType","readSyncStep1","syncProtocol","awarenessProtocol","clientMeta","currClock","peerName","peerId","bcConns","webrtcPeers","bcPeers","broadcastBcPeerId","sendWebrtcConn","webrtcConn","remotePeerId","WebrtcConn","signalingConn","glareToken","closed","Peer","peerOpts","publishSignalingMessage","token","awarenessStates","announceSignalingInfo","err","answer","readPeerMessage","peerConn","broadcastBcMessage","cryptoutils","mux","broadcastRoomMessage","bcconnected","broadcastWebrtcConn","conn","topics","maxConns","filterBcConns","encoderPeerIdBc","Room","createMutex","_bcSubscriber","reply","_docUpdateHandler","_awarenessUpdateHandler","changedClients","encoderAwareness","_beforeUnloadHandler","encoderSync","encoderState","encoderAwarenessQuery","encoderAwarenessState","unsubscribed","encryptJson","dataEncoder","topic","SignalingConn","providers","roomName","execMessage","emitPeerChange","existingConn","remoteToken","localToken","WebrtcProvider","signaling","password","math","signalingUrls","deriveKey","secret","secretBuffer","salt","importKey","keyMaterial","iterations","hash","openRoom","setupHttpSignal","httpClient","subscriberId","eventSource","EventSource","subscriber_id","messages","onSingleMessage","OPEN","URLSearchParams","HttpSignalingConn","signalCon","setupSignalEventHandlers","WebrtcProviderWithHttpSignaling","startsWith","syncProvider","getSyncProvider","createSyncProvider","connectLocal","connectRemote","docs","register","objectConfig","bootstrap","handleChanges","updateHandler","destroyLocalConnection","loadRemotely","discard","createWebRTCConnection","wp","ajax","settings","__experimentalCollaborativeEditingSecret","receiveUserQuery","receiveCurrentUser","addEntities","receiveEntityRecords","invalidateCache","receiveQueriedItems","receiveCurrentTheme","__experimentalReceiveCurrentGlobalStylesId","__experimentalReceiveThemeBaseGlobalStyles","__experimentalReceiveThemeGlobalStyleVariations","receiveThemeSupports","receiveThemeGlobalStyleRevisions","receiveEmbedPreview","deleteEntityRecord","__unstableFetch","throwOnError","dispatch","resolveSelect","deletedRecord","__unstableAcquireStoreLock","exclusive","hasError","removeItems","_error","__unstableReleaseStoreLock","editEntityRecord","editedRecord","edit","recordValue","editedRecordValue","__experimentalEnableSync","undoIgnore","isCached","__unstableCreateUndoLevel","saveEntityRecord","entityIdKey","evaluatedValue","updatedRecord","currentUserId","autosavePost","newRecord","receiveAutosaves","__experimentalBatch","batch","api","saveEditedEntityRecord","resultPromises","__experimentalSaveSpecifiedEntityEdits","itemsToSave","editsToSave","receiveUploadPermissions","hasUploadPermissions","receiveUserPermission","receiveUserPermissions","receiveNavigationFallbackId","receiveDefaultTemplateId","receiveRevisions","receiveRegisteredPostMeta","camelCaseTransform","camelCase","resolverName","RECEIVE_INTERMEDIATE_RESULTS","fetchLinkSuggestions","searchOptions","editorSettings","searchOptionsToUse","isInitialSuggestions","initialSuggestionsSearchOptions","subtype","disablePostFormats","decodeEntities","source_url","flat","searchTokens","tokenize","scores","titleTokens","exactMatchingTokens","titleToken","searchToken","subMatchingTokens","exactMatchScore","subMatchScore","sortResults","CACHE","prependHTTP","isURL","protocol","getProtocol","isValidProtocol","fetchBlockPatterns","restPatterns","pattern","registry","json","canUserResolutionsArgs","receiveUserPermissionArgs","finishResolutions","forwardResolver","getResolutionsArgs","pageRecords","targetHints","_links","allow","targetHint","shouldInvalidate","activeThemes","embedProxyResponse","requestedAction","hasStartedResolution","relatedAction","resourcePath","finishResolution","restBase","restNamespace","supports","getPostType","globalStylesURL","href","matches","themeGlobalStyles","globalStylesId","revisionsURL","resetRevisions","revision","userCategory","fallback","_embed","_embedded","invalidateNavigationQueries","isPaginated","resolutionsArgs","loader","configs","deepCopyLocksTreePath","tree","newTree","currentNode","branchName","children","locks","getNode","nextNode","hasConflictingLock","DEFAULT_STATE","storePath","isLockAvailable","iteratePath","descendant","childNode","iterateDescendants","createLocks","processPendingLockRequests","getPendingLockRequests","notifyAcquired","acquire","EntityContext","createContext","EntityProvider","useContext","childContext","useMemo","_jsx","Provider","Status","META_SELECTORS","useQuerySelect","mapQuerySelect","deps","useSelect","enrichSelectors","memoized","searchCache","maxSize","memoize","selectors","resolvers","selectorName","resolutionStatus","getResolutionState","Resolving","Success","Idle","hasStarted","hasResolved","useEntityRecord","useDispatch","coreStore","mutations","editOptions","saveOptions","hasEdits","querySelectRest","__experimentalUseEntityRecord","EMPTY_ARRAY","useEntityRecords","queryArgs","queryAsString","__experimentalUseEntityRecords","useResourcePermissions","isEntity","hasId","canCreate","canRead","_delete","canUpdate","canDelete","__experimentalUseResourcePermissions","useEntityId","unlockedApis","getBlockFootnotesOrder","order","blockEditorPrivateApis","getRichTextValues","getRichTextValuesCached","replacements","oldFootnotes","updateFootnotesFromMeta","footnotes","newOrder","flatMap","getFootnotesOrder","newFootnotes","fnId","updateAttributes","richTextValue","fromHTMLString","hasFootnotes","replacement","countValue","innerHTML","formats","toHTMLString","newBlocks","updateBlocksAttributes","__blocks","parsedBlocksCache","useEntityBlockEditor","providerId","editedBlocks","cackeKey","_blocks","onChange","useCallback","blocksForSerialization","__unstableSerializeAndClean","onInput","useEntityProp","fullValue","privateApis","useEntityRecordsWithPermissions","ret","_data$map","_entityConfig$key","_data$map2","entitySelectors","entityResolvers","pluralMethodName","entityActions","actions","createReduxStore","createLocksActions","registerPrivateSelectors","privateSelectors","registerPrivateActions","privateActions"],"sourceRoot":""}