@nostrwatch/utils 0.2.0

package/dist/browser/node_modules/.pnpm/deep-eql@4.1.4/node_modules/deep-eql/index.amd.js

@@ -0,0 +1,127 @@
+define(["exports","../../../../../_virtual/index.amd10","../../../../../_virtual/index.amd8"],(function(e,r,t){"use strict";var n;e.__require=function requireDeepEql(){if(n)return r.__module.exports;n=1;
+/*!
+  	 * deep-eql
+  	 * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
+  	 * MIT Licensed
+  	 */
+var e=t.default;function FakeMap(){this._key="chai/deep-eql__"+Math.random()+Date.now()}FakeMap.prototype={get:function get(e){return e[this._key]},set:function set(e,r){Object.isExtensible(e)&&Object.defineProperty(e,this._key,{value:r,configurable:!0})}};var a="function"==typeof WeakMap?WeakMap:FakeMap;
+/*!
+  	 * Check to see if the MemoizeMap has recorded a result of the two operands
+  	 *
+  	 * @param {Mixed} leftHandOperand
+  	 * @param {Mixed} rightHandOperand
+  	 * @param {MemoizeMap} memoizeMap
+  	 * @returns {Boolean|null} result
+  	*/function memoizeCompare(e,r,t){if(!t||isPrimitive(e)||isPrimitive(r))return null;var n=t.get(e);if(n){var a=n.get(r);if("boolean"==typeof a)return a}return null}
+/*!
+  	 * Set the result of the equality into the MemoizeMap
+  	 *
+  	 * @param {Mixed} leftHandOperand
+  	 * @param {Mixed} rightHandOperand
+  	 * @param {MemoizeMap} memoizeMap
+  	 * @param {Boolean} result
+  	*/function memoizeSet(e,r,t,n){if(t&&!isPrimitive(e)&&!isPrimitive(r)){var i=t.get(e);i?i.set(r,n):((i=new a).set(r,n),t.set(e,i))}}
+/*!
+  	 * Primary Export
+  	 */function deepEqual(e,r,t){if(t&&t.comparator)return extensiveDeepEqual(e,r,t);var n=simpleEqual(e,r);return null!==n?n:extensiveDeepEqual(e,r,t)}function simpleEqual(e,r){return e===r?0!==e||1/e==1/r:e!=e&&r!=r||!isPrimitive(e)&&!isPrimitive(r)&&null}
+/*!
+  	 * The main logic of the `deepEqual` function.
+  	 *
+  	 * @param {Mixed} leftHandOperand
+  	 * @param {Mixed} rightHandOperand
+  	 * @param {Object} [options] (optional) Additional options
+  	 * @param {Array} [options.comparator] (optional) Override default algorithm, determining custom equality.
+  	 * @param {Array} [options.memoize] (optional) Provide a custom memoization object which will cache the results of
+  	    complex objects for a speed boost. By passing `false` you can disable memoization, but this will cause circular
+  	    references to blow the stack.
+  	 * @return {Boolean} equal match
+  	*/function extensiveDeepEqual(r,t,n){(n=n||{}).memoize=!1!==n.memoize&&(n.memoize||new a);var i=n&&n.comparator,o=memoizeCompare(r,t,n.memoize);if(null!==o)return o;var u=memoizeCompare(t,r,n.memoize);if(null!==u)return u;if(i){var l=i(r,t);if(!1===l||!0===l)return memoizeSet(r,t,n.memoize,l),l;var s=simpleEqual(r,t);if(null!==s)return s}var m=e(r);if(m!==e(t))return memoizeSet(r,t,n.memoize,!1),!1;memoizeSet(r,t,n.memoize,!0);var c=function extensiveDeepEqualByType(e,r,t,n){switch(t){case"String":case"Number":case"Boolean":case"Date":return deepEqual(e.valueOf(),r.valueOf());case"Promise":case"Symbol":case"function":case"WeakMap":case"WeakSet":return e===r;case"Error":return keysEqual(e,r,["name","message","code"],n);case"Arguments":case"Int8Array":case"Uint8Array":case"Uint8ClampedArray":case"Int16Array":case"Uint16Array":case"Int32Array":case"Uint32Array":case"Float32Array":case"Float64Array":case"Array":return iterableEqual(e,r,n);case"RegExp":
+/*!
+  	 * Compare two Regular Expressions for equality.
+  	 *
+  	 * @param {RegExp} leftHandOperand
+  	 * @param {RegExp} rightHandOperand
+  	 * @return {Boolean} result
+  	 */
+return function regexpEqual(e,r){return e.toString()===r.toString()}
+/*!
+  	 * Compare two Sets/Maps for equality. Faster than other equality functions.
+  	 *
+  	 * @param {Set} leftHandOperand
+  	 * @param {Set} rightHandOperand
+  	 * @param {Object} [options] (Optional)
+  	 * @return {Boolean} result
+  	 */(e,r);case"Generator":
+/*!
+  	 * Simple equality for generator objects such as those returned by generator functions.
+  	 *
+  	 * @param {Iterable} leftHandOperand
+  	 * @param {Iterable} rightHandOperand
+  	 * @param {Object} [options] (Optional)
+  	 * @return {Boolean} result
+  	 */
+return function generatorEqual(e,r,t){return iterableEqual(getGeneratorEntries(e),getGeneratorEntries(r),t)}
+/*!
+  	 * Determine if the given object has an @@iterator function.
+  	 *
+  	 * @param {Object} target
+  	 * @return {Boolean} `true` if the object has an @@iterator function.
+  	 */(e,r,n);case"DataView":return iterableEqual(new Uint8Array(e.buffer),new Uint8Array(r.buffer),n);case"ArrayBuffer":return iterableEqual(new Uint8Array(e),new Uint8Array(r),n);case"Set":case"Map":return entriesEqual(e,r,n);case"Temporal.PlainDate":case"Temporal.PlainTime":case"Temporal.PlainDateTime":case"Temporal.Instant":case"Temporal.ZonedDateTime":case"Temporal.PlainYearMonth":case"Temporal.PlainMonthDay":return e.equals(r);case"Temporal.Duration":return e.total("nanoseconds")===r.total("nanoseconds");case"Temporal.TimeZone":case"Temporal.Calendar":return e.toString()===r.toString();default:
+/*!
+  	 * Recursively check the equality of two Objects. Once basic sameness has been established it will defer to `deepEqual`
+  	 * for each enumerable key in the object.
+  	 *
+  	 * @param {Mixed} leftHandOperand
+  	 * @param {Mixed} rightHandOperand
+  	 * @param {Object} [options] (Optional)
+  	 * @return {Boolean} result
+  	 */
+return function objectEqual(e,r,t){var n=getEnumerableKeys(e),a=getEnumerableKeys(r),i=getEnumerableSymbols(e),o=getEnumerableSymbols(r);if(n=n.concat(i),a=a.concat(o),n.length&&n.length===a.length)return!1!==iterableEqual(mapSymbols(n).sort(),mapSymbols(a).sort())&&keysEqual(e,r,n,t);var u=getIteratorEntries(e),l=getIteratorEntries(r);if(u.length&&u.length===l.length)return u.sort(),l.sort(),iterableEqual(u,l,t);if(0===n.length&&0===u.length&&0===a.length&&0===l.length)return!0;return!1}
+/*!
+  	 * Returns true if the argument is a primitive.
+  	 *
+  	 * This intentionally returns true for all objects that can be compared by reference,
+  	 * including functions and symbols.
+  	 *
+  	 * @param {Mixed} value
+  	 * @return {Boolean} result
+  	 */(e,r,n)}}(r,t,m,n);return memoizeSet(r,t,n.memoize,c),c}function entriesEqual(e,r,t){try{if(e.size!==r.size)return!1;if(0===e.size)return!0}catch(e){return!1}var n=[],a=[];return e.forEach((function gatherEntries(e,r){n.push([e,r])})),r.forEach((function gatherEntries(e,r){a.push([e,r])})),iterableEqual(n.sort(),a.sort(),t)}
+/*!
+  	 * Simple equality for flat iterable objects such as Arrays, TypedArrays or Node.js buffers.
+  	 *
+  	 * @param {Iterable} leftHandOperand
+  	 * @param {Iterable} rightHandOperand
+  	 * @param {Object} [options] (Optional)
+  	 * @return {Boolean} result
+  	 */function iterableEqual(e,r,t){var n=e.length;if(n!==r.length)return!1;if(0===n)return!0;for(var a=-1;++a<n;)if(!1===deepEqual(e[a],r[a],t))return!1;return!0}
+/*!
+  	 * Gets all iterator entries from the given Object. If the Object has no @@iterator function, returns an empty array.
+  	 * This will consume the iterator - which could have side effects depending on the @@iterator implementation.
+  	 *
+  	 * @param {Object} target
+  	 * @returns {Array} an array of entries from the @@iterator function
+  	 */
+function getIteratorEntries(e){if(function hasIteratorFunction(e){return"undefined"!=typeof Symbol&&"object"==typeof e&&void 0!==Symbol.iterator&&"function"==typeof e[Symbol.iterator]}(e))try{return getGeneratorEntries(e[Symbol.iterator]())}catch(e){return[]}return[]}
+/*!
+  	 * Gets all entries from a Generator. This will consume the generator - which could have side effects.
+  	 *
+  	 * @param {Generator} target
+  	 * @returns {Array} an array of entries from the Generator.
+  	 */function getGeneratorEntries(e){for(var r=e.next(),t=[r.value];!1===r.done;)r=e.next(),t.push(r.value);return t}
+/*!
+  	 * Gets all own and inherited enumerable keys from a target.
+  	 *
+  	 * @param {Object} target
+  	 * @returns {Array} an array of own and inherited enumerable keys from the target.
+  	 */function getEnumerableKeys(e){var r=[];for(var t in e)r.push(t);return r}function getEnumerableSymbols(e){for(var r=[],t=Object.getOwnPropertySymbols(e),n=0;n<t.length;n+=1){var a=t[n];Object.getOwnPropertyDescriptor(e,a).enumerable&&r.push(a)}return r}
+/*!
+  	 * Determines if two objects have matching values, given a set of keys. Defers to deepEqual for the equality check of
+  	 * each key. If any value of the given key is not equal, the function will return false (early).
+  	 *
+  	 * @param {Mixed} leftHandOperand
+  	 * @param {Mixed} rightHandOperand
+  	 * @param {Array} keys An array of keys to compare the values of leftHandOperand and rightHandOperand against
+  	 * @param {Object} [options] (Optional)
+  	 * @return {Boolean} result
+  	 */function keysEqual(e,r,t,n){var a=t.length;if(0===a)return!0;for(var i=0;i<a;i+=1)if(!1===deepEqual(e[t[i]],r[t[i]],n))return!1;return!0}function isPrimitive(e){return null===e||"object"!=typeof e}function mapSymbols(e){return e.map((function mapSymbol(e){return"symbol"==typeof e?e.toString():e}))}return r.__module.exports=deepEqual,r.__module.exports.MemoizeMap=a,r.__module.exports}}));
+//# sourceMappingURL=index.amd.js.map

package/dist/browser/node_modules/.pnpm/deep-eql@4.1.4/node_modules/deep-eql/index.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.amd.js","sources":["../../../../../../../../../node_modules/.pnpm/deep-eql@4.1.4/node_modules/deep-eql/index.js"],"sourcesContent":["'use strict';\n/* globals Symbol: false, Uint8Array: false, WeakMap: false */\n/*!\n * deep-eql\n * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar type = require('type-detect');\nfunction FakeMap() {\n  this._key = 'chai/deep-eql__' + Math.random() + Date.now();\n}\n\nFakeMap.prototype = {\n  get: function get(key) {\n    return key[this._key];\n  },\n  set: function set(key, value) {\n    if (Object.isExtensible(key)) {\n      Object.defineProperty(key, this._key, {\n        value: value,\n        configurable: true,\n      });\n    }\n  },\n};\n\nvar MemoizeMap = typeof WeakMap === 'function' ? WeakMap : FakeMap;\n/*!\n * Check to see if the MemoizeMap has recorded a result of the two operands\n *\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @param {MemoizeMap} memoizeMap\n * @returns {Boolean|null} result\n*/\nfunction memoizeCompare(leftHandOperand, rightHandOperand, memoizeMap) {\n  // Technically, WeakMap keys can *only* be objects, not primitives.\n  if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {\n    return null;\n  }\n  var leftHandMap = memoizeMap.get(leftHandOperand);\n  if (leftHandMap) {\n    var result = leftHandMap.get(rightHandOperand);\n    if (typeof result === 'boolean') {\n      return result;\n    }\n  }\n  return null;\n}\n\n/*!\n * Set the result of the equality into the MemoizeMap\n *\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @param {MemoizeMap} memoizeMap\n * @param {Boolean} result\n*/\nfunction memoizeSet(leftHandOperand, rightHandOperand, memoizeMap, result) {\n  // Technically, WeakMap keys can *only* be objects, not primitives.\n  if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {\n    return;\n  }\n  var leftHandMap = memoizeMap.get(leftHandOperand);\n  if (leftHandMap) {\n    leftHandMap.set(rightHandOperand, result);\n  } else {\n    leftHandMap = new MemoizeMap();\n    leftHandMap.set(rightHandOperand, result);\n    memoizeMap.set(leftHandOperand, leftHandMap);\n  }\n}\n\n/*!\n * Primary Export\n */\n\nmodule.exports = deepEqual;\nmodule.exports.MemoizeMap = MemoizeMap;\n\n/**\n * Assert deeply nested sameValue equality between two objects of any type.\n *\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @param {Object} [options] (optional) Additional options\n * @param {Array} [options.comparator] (optional) Override default algorithm, determining custom equality.\n * @param {Array} [options.memoize] (optional) Provide a custom memoization object which will cache the results of\n    complex objects for a speed boost. By passing `false` you can disable memoization, but this will cause circular\n    references to blow the stack.\n * @return {Boolean} equal match\n */\nfunction deepEqual(leftHandOperand, rightHandOperand, options) {\n  // If we have a comparator, we can't assume anything; so bail to its check first.\n  if (options && options.comparator) {\n    return extensiveDeepEqual(leftHandOperand, rightHandOperand, options);\n  }\n\n  var simpleResult = simpleEqual(leftHandOperand, rightHandOperand);\n  if (simpleResult !== null) {\n    return simpleResult;\n  }\n\n  // Deeper comparisons are pushed through to a larger function\n  return extensiveDeepEqual(leftHandOperand, rightHandOperand, options);\n}\n\n/**\n * Many comparisons can be canceled out early via simple equality or primitive checks.\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @return {Boolean|null} equal match\n */\nfunction simpleEqual(leftHandOperand, rightHandOperand) {\n  // Equal references (except for Numbers) can be returned early\n  if (leftHandOperand === rightHandOperand) {\n    // Handle +-0 cases\n    return leftHandOperand !== 0 || 1 / leftHandOperand === 1 / rightHandOperand;\n  }\n\n  // handle NaN cases\n  if (\n    leftHandOperand !== leftHandOperand && // eslint-disable-line no-self-compare\n    rightHandOperand !== rightHandOperand // eslint-disable-line no-self-compare\n  ) {\n    return true;\n  }\n\n  // Anything that is not an 'object', i.e. symbols, functions, booleans, numbers,\n  // strings, and undefined, can be compared by reference.\n  if (isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {\n    // Easy out b/c it would have passed the first equality check\n    return false;\n  }\n  return null;\n}\n\n/*!\n * The main logic of the `deepEqual` function.\n *\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @param {Object} [options] (optional) Additional options\n * @param {Array} [options.comparator] (optional) Override default algorithm, determining custom equality.\n * @param {Array} [options.memoize] (optional) Provide a custom memoization object which will cache the results of\n    complex objects for a speed boost. By passing `false` you can disable memoization, but this will cause circular\n    references to blow the stack.\n * @return {Boolean} equal match\n*/\nfunction extensiveDeepEqual(leftHandOperand, rightHandOperand, options) {\n  options = options || {};\n  options.memoize = options.memoize === false ? false : options.memoize || new MemoizeMap();\n  var comparator = options && options.comparator;\n\n  // Check if a memoized result exists.\n  var memoizeResultLeft = memoizeCompare(leftHandOperand, rightHandOperand, options.memoize);\n  if (memoizeResultLeft !== null) {\n    return memoizeResultLeft;\n  }\n  var memoizeResultRight = memoizeCompare(rightHandOperand, leftHandOperand, options.memoize);\n  if (memoizeResultRight !== null) {\n    return memoizeResultRight;\n  }\n\n  // If a comparator is present, use it.\n  if (comparator) {\n    var comparatorResult = comparator(leftHandOperand, rightHandOperand);\n    // Comparators may return null, in which case we want to go back to default behavior.\n    if (comparatorResult === false || comparatorResult === true) {\n      memoizeSet(leftHandOperand, rightHandOperand, options.memoize, comparatorResult);\n      return comparatorResult;\n    }\n    // To allow comparators to override *any* behavior, we ran them first. Since it didn't decide\n    // what to do, we need to make sure to return the basic tests first before we move on.\n    var simpleResult = simpleEqual(leftHandOperand, rightHandOperand);\n    if (simpleResult !== null) {\n      // Don't memoize this, it takes longer to set/retrieve than to just compare.\n      return simpleResult;\n    }\n  }\n\n  var leftHandType = type(leftHandOperand);\n  if (leftHandType !== type(rightHandOperand)) {\n    memoizeSet(leftHandOperand, rightHandOperand, options.memoize, false);\n    return false;\n  }\n\n  // Temporarily set the operands in the memoize object to prevent blowing the stack\n  memoizeSet(leftHandOperand, rightHandOperand, options.memoize, true);\n\n  var result = extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options);\n  memoizeSet(leftHandOperand, rightHandOperand, options.memoize, result);\n  return result;\n}\n\nfunction extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options) {\n  switch (leftHandType) {\n    case 'String':\n    case 'Number':\n    case 'Boolean':\n    case 'Date':\n      // If these types are their instance types (e.g. `new Number`) then re-deepEqual against their values\n      return deepEqual(leftHandOperand.valueOf(), rightHandOperand.valueOf());\n    case 'Promise':\n    case 'Symbol':\n    case 'function':\n    case 'WeakMap':\n    case 'WeakSet':\n      return leftHandOperand === rightHandOperand;\n    case 'Error':\n      return keysEqual(leftHandOperand, rightHandOperand, [ 'name', 'message', 'code' ], options);\n    case 'Arguments':\n    case 'Int8Array':\n    case 'Uint8Array':\n    case 'Uint8ClampedArray':\n    case 'Int16Array':\n    case 'Uint16Array':\n    case 'Int32Array':\n    case 'Uint32Array':\n    case 'Float32Array':\n    case 'Float64Array':\n    case 'Array':\n      return iterableEqual(leftHandOperand, rightHandOperand, options);\n    case 'RegExp':\n      return regexpEqual(leftHandOperand, rightHandOperand);\n    case 'Generator':\n      return generatorEqual(leftHandOperand, rightHandOperand, options);\n    case 'DataView':\n      return iterableEqual(new Uint8Array(leftHandOperand.buffer), new Uint8Array(rightHandOperand.buffer), options);\n    case 'ArrayBuffer':\n      return iterableEqual(new Uint8Array(leftHandOperand), new Uint8Array(rightHandOperand), options);\n    case 'Set':\n      return entriesEqual(leftHandOperand, rightHandOperand, options);\n    case 'Map':\n      return entriesEqual(leftHandOperand, rightHandOperand, options);\n    case 'Temporal.PlainDate':\n    case 'Temporal.PlainTime':\n    case 'Temporal.PlainDateTime':\n    case 'Temporal.Instant':\n    case 'Temporal.ZonedDateTime':\n    case 'Temporal.PlainYearMonth':\n    case 'Temporal.PlainMonthDay':\n      return leftHandOperand.equals(rightHandOperand);\n    case 'Temporal.Duration':\n      return leftHandOperand.total('nanoseconds') === rightHandOperand.total('nanoseconds');\n    case 'Temporal.TimeZone':\n    case 'Temporal.Calendar':\n      return leftHandOperand.toString() === rightHandOperand.toString();\n    default:\n      return objectEqual(leftHandOperand, rightHandOperand, options);\n  }\n}\n\n/*!\n * Compare two Regular Expressions for equality.\n *\n * @param {RegExp} leftHandOperand\n * @param {RegExp} rightHandOperand\n * @return {Boolean} result\n */\n\nfunction regexpEqual(leftHandOperand, rightHandOperand) {\n  return leftHandOperand.toString() === rightHandOperand.toString();\n}\n\n/*!\n * Compare two Sets/Maps for equality. Faster than other equality functions.\n *\n * @param {Set} leftHandOperand\n * @param {Set} rightHandOperand\n * @param {Object} [options] (Optional)\n * @return {Boolean} result\n */\n\nfunction entriesEqual(leftHandOperand, rightHandOperand, options) {\n  try {\n    // IE11 doesn't support Set#entries or Set#@@iterator, so we need manually populate using Set#forEach\n    if (leftHandOperand.size !== rightHandOperand.size) {\n      return false;\n    }\n    if (leftHandOperand.size === 0) {\n      return true;\n    }\n  } catch (sizeError) {\n    // things that aren't actual Maps or Sets will throw here\n    return false;\n  }\n  var leftHandItems = [];\n  var rightHandItems = [];\n  leftHandOperand.forEach(function gatherEntries(key, value) {\n    leftHandItems.push([ key, value ]);\n  });\n  rightHandOperand.forEach(function gatherEntries(key, value) {\n    rightHandItems.push([ key, value ]);\n  });\n  return iterableEqual(leftHandItems.sort(), rightHandItems.sort(), options);\n}\n\n/*!\n * Simple equality for flat iterable objects such as Arrays, TypedArrays or Node.js buffers.\n *\n * @param {Iterable} leftHandOperand\n * @param {Iterable} rightHandOperand\n * @param {Object} [options] (Optional)\n * @return {Boolean} result\n */\n\nfunction iterableEqual(leftHandOperand, rightHandOperand, options) {\n  var length = leftHandOperand.length;\n  if (length !== rightHandOperand.length) {\n    return false;\n  }\n  if (length === 0) {\n    return true;\n  }\n  var index = -1;\n  while (++index < length) {\n    if (deepEqual(leftHandOperand[index], rightHandOperand[index], options) === false) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/*!\n * Simple equality for generator objects such as those returned by generator functions.\n *\n * @param {Iterable} leftHandOperand\n * @param {Iterable} rightHandOperand\n * @param {Object} [options] (Optional)\n * @return {Boolean} result\n */\n\nfunction generatorEqual(leftHandOperand, rightHandOperand, options) {\n  return iterableEqual(getGeneratorEntries(leftHandOperand), getGeneratorEntries(rightHandOperand), options);\n}\n\n/*!\n * Determine if the given object has an @@iterator function.\n *\n * @param {Object} target\n * @return {Boolean} `true` if the object has an @@iterator function.\n */\nfunction hasIteratorFunction(target) {\n  return typeof Symbol !== 'undefined' &&\n    typeof target === 'object' &&\n    typeof Symbol.iterator !== 'undefined' &&\n    typeof target[Symbol.iterator] === 'function';\n}\n\n/*!\n * Gets all iterator entries from the given Object. If the Object has no @@iterator function, returns an empty array.\n * This will consume the iterator - which could have side effects depending on the @@iterator implementation.\n *\n * @param {Object} target\n * @returns {Array} an array of entries from the @@iterator function\n */\nfunction getIteratorEntries(target) {\n  if (hasIteratorFunction(target)) {\n    try {\n      return getGeneratorEntries(target[Symbol.iterator]());\n    } catch (iteratorError) {\n      return [];\n    }\n  }\n  return [];\n}\n\n/*!\n * Gets all entries from a Generator. This will consume the generator - which could have side effects.\n *\n * @param {Generator} target\n * @returns {Array} an array of entries from the Generator.\n */\nfunction getGeneratorEntries(generator) {\n  var generatorResult = generator.next();\n  var accumulator = [ generatorResult.value ];\n  while (generatorResult.done === false) {\n    generatorResult = generator.next();\n    accumulator.push(generatorResult.value);\n  }\n  return accumulator;\n}\n\n/*!\n * Gets all own and inherited enumerable keys from a target.\n *\n * @param {Object} target\n * @returns {Array} an array of own and inherited enumerable keys from the target.\n */\nfunction getEnumerableKeys(target) {\n  var keys = [];\n  for (var key in target) {\n    keys.push(key);\n  }\n  return keys;\n}\n\nfunction getEnumerableSymbols(target) {\n  var keys = [];\n  var allKeys = Object.getOwnPropertySymbols(target);\n  for (var i = 0; i < allKeys.length; i += 1) {\n    var key = allKeys[i];\n    if (Object.getOwnPropertyDescriptor(target, key).enumerable) {\n      keys.push(key);\n    }\n  }\n  return keys;\n}\n\n/*!\n * Determines if two objects have matching values, given a set of keys. Defers to deepEqual for the equality check of\n * each key. If any value of the given key is not equal, the function will return false (early).\n *\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @param {Array} keys An array of keys to compare the values of leftHandOperand and rightHandOperand against\n * @param {Object} [options] (Optional)\n * @return {Boolean} result\n */\nfunction keysEqual(leftHandOperand, rightHandOperand, keys, options) {\n  var length = keys.length;\n  if (length === 0) {\n    return true;\n  }\n  for (var i = 0; i < length; i += 1) {\n    if (deepEqual(leftHandOperand[keys[i]], rightHandOperand[keys[i]], options) === false) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/*!\n * Recursively check the equality of two Objects. Once basic sameness has been established it will defer to `deepEqual`\n * for each enumerable key in the object.\n *\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @param {Object} [options] (Optional)\n * @return {Boolean} result\n */\nfunction objectEqual(leftHandOperand, rightHandOperand, options) {\n  var leftHandKeys = getEnumerableKeys(leftHandOperand);\n  var rightHandKeys = getEnumerableKeys(rightHandOperand);\n  var leftHandSymbols = getEnumerableSymbols(leftHandOperand);\n  var rightHandSymbols = getEnumerableSymbols(rightHandOperand);\n  leftHandKeys = leftHandKeys.concat(leftHandSymbols);\n  rightHandKeys = rightHandKeys.concat(rightHandSymbols);\n\n  if (leftHandKeys.length && leftHandKeys.length === rightHandKeys.length) {\n    if (iterableEqual(mapSymbols(leftHandKeys).sort(), mapSymbols(rightHandKeys).sort()) === false) {\n      return false;\n    }\n    return keysEqual(leftHandOperand, rightHandOperand, leftHandKeys, options);\n  }\n\n  var leftHandEntries = getIteratorEntries(leftHandOperand);\n  var rightHandEntries = getIteratorEntries(rightHandOperand);\n  if (leftHandEntries.length && leftHandEntries.length === rightHandEntries.length) {\n    leftHandEntries.sort();\n    rightHandEntries.sort();\n    return iterableEqual(leftHandEntries, rightHandEntries, options);\n  }\n\n  if (leftHandKeys.length === 0 &&\n      leftHandEntries.length === 0 &&\n      rightHandKeys.length === 0 &&\n      rightHandEntries.length === 0) {\n    return true;\n  }\n\n  return false;\n}\n\n/*!\n * Returns true if the argument is a primitive.\n *\n * This intentionally returns true for all objects that can be compared by reference,\n * including functions and symbols.\n *\n * @param {Mixed} value\n * @return {Boolean} result\n */\nfunction isPrimitive(value) {\n  return value === null || typeof value !== 'object';\n}\n\nfunction mapSymbols(arr) {\n  return arr.map(function mapSymbol(entry) {\n    if (typeof entry === 'symbol') {\n      return entry.toString();\n    }\n\n    return entry;\n  });\n}\n"],"names":["type","require$$0","default","FakeMap","this","_key","Math","random","Date","now","prototype","get","key","set","value","Object","isExtensible","defineProperty","configurable","MemoizeMap","WeakMap","memoizeCompare","leftHandOperand","rightHandOperand","memoizeMap","isPrimitive","leftHandMap","result","memoizeSet","deepEqual","options","comparator","extensiveDeepEqual","simpleResult","simpleEqual","memoize","memoizeResultLeft","memoizeResultRight","comparatorResult","leftHandType","extensiveDeepEqualByType","valueOf","keysEqual","iterableEqual","regexpEqual","toString","generatorEqual","getGeneratorEntries","Uint8Array","buffer","entriesEqual","equals","total","objectEqual","leftHandKeys","getEnumerableKeys","rightHandKeys","leftHandSymbols","getEnumerableSymbols","rightHandSymbols","concat","length","mapSymbols","sort","leftHandEntries","getIteratorEntries","rightHandEntries","size","sizeError","leftHandItems","rightHandItems","forEach","gatherEntries","push","index","target","hasIteratorFunction","Symbol","iterator","iteratorError","generator","generatorResult","next","accumulator","done","keys","allKeys","getOwnPropertySymbols","i","getOwnPropertyDescriptor","enumerable","arr","map","mapSymbol","entry","deepEqlModule","__module","exports"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/deep-eql@4.1.4/node_modules/deep-eql/index.esm.js

@@ -0,0 +1,127 @@
+import{__module as e}from"../../../../../_virtual/index.esm10.js";import r from"../../../../../_virtual/index.esm8.js";var t;function requireDeepEql(){if(t)return e.exports;t=1;
+/*!
+	 * deep-eql
+	 * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
+	 * MIT Licensed
+	 */
+var n=r;function FakeMap(){this._key="chai/deep-eql__"+Math.random()+Date.now()}FakeMap.prototype={get:function get(e){return e[this._key]},set:function set(e,r){Object.isExtensible(e)&&Object.defineProperty(e,this._key,{value:r,configurable:!0})}};var a="function"==typeof WeakMap?WeakMap:FakeMap;
+/*!
+	 * Check to see if the MemoizeMap has recorded a result of the two operands
+	 *
+	 * @param {Mixed} leftHandOperand
+	 * @param {Mixed} rightHandOperand
+	 * @param {MemoizeMap} memoizeMap
+	 * @returns {Boolean|null} result
+	*/function memoizeCompare(e,r,t){if(!t||isPrimitive(e)||isPrimitive(r))return null;var n=t.get(e);if(n){var a=n.get(r);if("boolean"==typeof a)return a}return null}
+/*!
+	 * Set the result of the equality into the MemoizeMap
+	 *
+	 * @param {Mixed} leftHandOperand
+	 * @param {Mixed} rightHandOperand
+	 * @param {MemoizeMap} memoizeMap
+	 * @param {Boolean} result
+	*/function memoizeSet(e,r,t,n){if(t&&!isPrimitive(e)&&!isPrimitive(r)){var i=t.get(e);i?i.set(r,n):((i=new a).set(r,n),t.set(e,i))}}
+/*!
+	 * Primary Export
+	 */function deepEqual(e,r,t){if(t&&t.comparator)return extensiveDeepEqual(e,r,t);var n=simpleEqual(e,r);return null!==n?n:extensiveDeepEqual(e,r,t)}function simpleEqual(e,r){return e===r?0!==e||1/e==1/r:e!=e&&r!=r||!isPrimitive(e)&&!isPrimitive(r)&&null}
+/*!
+	 * The main logic of the `deepEqual` function.
+	 *
+	 * @param {Mixed} leftHandOperand
+	 * @param {Mixed} rightHandOperand
+	 * @param {Object} [options] (optional) Additional options
+	 * @param {Array} [options.comparator] (optional) Override default algorithm, determining custom equality.
+	 * @param {Array} [options.memoize] (optional) Provide a custom memoization object which will cache the results of
+	    complex objects for a speed boost. By passing `false` you can disable memoization, but this will cause circular
+	    references to blow the stack.
+	 * @return {Boolean} equal match
+	*/function extensiveDeepEqual(e,r,t){(t=t||{}).memoize=!1!==t.memoize&&(t.memoize||new a);var i=t&&t.comparator,o=memoizeCompare(e,r,t.memoize);if(null!==o)return o;var u=memoizeCompare(r,e,t.memoize);if(null!==u)return u;if(i){var l=i(e,r);if(!1===l||!0===l)return memoizeSet(e,r,t.memoize,l),l;var s=simpleEqual(e,r);if(null!==s)return s}var m=n(e);if(m!==n(r))return memoizeSet(e,r,t.memoize,!1),!1;memoizeSet(e,r,t.memoize,!0);var c=function extensiveDeepEqualByType(e,r,t,n){switch(t){case"String":case"Number":case"Boolean":case"Date":return deepEqual(e.valueOf(),r.valueOf());case"Promise":case"Symbol":case"function":case"WeakMap":case"WeakSet":return e===r;case"Error":return keysEqual(e,r,["name","message","code"],n);case"Arguments":case"Int8Array":case"Uint8Array":case"Uint8ClampedArray":case"Int16Array":case"Uint16Array":case"Int32Array":case"Uint32Array":case"Float32Array":case"Float64Array":case"Array":return iterableEqual(e,r,n);case"RegExp":
+/*!
+	 * Compare two Regular Expressions for equality.
+	 *
+	 * @param {RegExp} leftHandOperand
+	 * @param {RegExp} rightHandOperand
+	 * @return {Boolean} result
+	 */
+return function regexpEqual(e,r){return e.toString()===r.toString()}
+/*!
+	 * Compare two Sets/Maps for equality. Faster than other equality functions.
+	 *
+	 * @param {Set} leftHandOperand
+	 * @param {Set} rightHandOperand
+	 * @param {Object} [options] (Optional)
+	 * @return {Boolean} result
+	 */(e,r);case"Generator":
+/*!
+	 * Simple equality for generator objects such as those returned by generator functions.
+	 *
+	 * @param {Iterable} leftHandOperand
+	 * @param {Iterable} rightHandOperand
+	 * @param {Object} [options] (Optional)
+	 * @return {Boolean} result
+	 */
+return function generatorEqual(e,r,t){return iterableEqual(getGeneratorEntries(e),getGeneratorEntries(r),t)}
+/*!
+	 * Determine if the given object has an @@iterator function.
+	 *
+	 * @param {Object} target
+	 * @return {Boolean} `true` if the object has an @@iterator function.
+	 */(e,r,n);case"DataView":return iterableEqual(new Uint8Array(e.buffer),new Uint8Array(r.buffer),n);case"ArrayBuffer":return iterableEqual(new Uint8Array(e),new Uint8Array(r),n);case"Set":case"Map":return entriesEqual(e,r,n);case"Temporal.PlainDate":case"Temporal.PlainTime":case"Temporal.PlainDateTime":case"Temporal.Instant":case"Temporal.ZonedDateTime":case"Temporal.PlainYearMonth":case"Temporal.PlainMonthDay":return e.equals(r);case"Temporal.Duration":return e.total("nanoseconds")===r.total("nanoseconds");case"Temporal.TimeZone":case"Temporal.Calendar":return e.toString()===r.toString();default:
+/*!
+	 * Recursively check the equality of two Objects. Once basic sameness has been established it will defer to `deepEqual`
+	 * for each enumerable key in the object.
+	 *
+	 * @param {Mixed} leftHandOperand
+	 * @param {Mixed} rightHandOperand
+	 * @param {Object} [options] (Optional)
+	 * @return {Boolean} result
+	 */
+return function objectEqual(e,r,t){var n=getEnumerableKeys(e),a=getEnumerableKeys(r),i=getEnumerableSymbols(e),o=getEnumerableSymbols(r);if(n=n.concat(i),a=a.concat(o),n.length&&n.length===a.length)return!1!==iterableEqual(mapSymbols(n).sort(),mapSymbols(a).sort())&&keysEqual(e,r,n,t);var u=getIteratorEntries(e),l=getIteratorEntries(r);if(u.length&&u.length===l.length)return u.sort(),l.sort(),iterableEqual(u,l,t);if(0===n.length&&0===u.length&&0===a.length&&0===l.length)return!0;return!1}
+/*!
+	 * Returns true if the argument is a primitive.
+	 *
+	 * This intentionally returns true for all objects that can be compared by reference,
+	 * including functions and symbols.
+	 *
+	 * @param {Mixed} value
+	 * @return {Boolean} result
+	 */(e,r,n)}}(e,r,m,t);return memoizeSet(e,r,t.memoize,c),c}function entriesEqual(e,r,t){try{if(e.size!==r.size)return!1;if(0===e.size)return!0}catch(e){return!1}var n=[],a=[];return e.forEach((function gatherEntries(e,r){n.push([e,r])})),r.forEach((function gatherEntries(e,r){a.push([e,r])})),iterableEqual(n.sort(),a.sort(),t)}
+/*!
+	 * Simple equality for flat iterable objects such as Arrays, TypedArrays or Node.js buffers.
+	 *
+	 * @param {Iterable} leftHandOperand
+	 * @param {Iterable} rightHandOperand
+	 * @param {Object} [options] (Optional)
+	 * @return {Boolean} result
+	 */function iterableEqual(e,r,t){var n=e.length;if(n!==r.length)return!1;if(0===n)return!0;for(var a=-1;++a<n;)if(!1===deepEqual(e[a],r[a],t))return!1;return!0}
+/*!
+	 * Gets all iterator entries from the given Object. If the Object has no @@iterator function, returns an empty array.
+	 * This will consume the iterator - which could have side effects depending on the @@iterator implementation.
+	 *
+	 * @param {Object} target
+	 * @returns {Array} an array of entries from the @@iterator function
+	 */
+function getIteratorEntries(e){if(function hasIteratorFunction(e){return"undefined"!=typeof Symbol&&"object"==typeof e&&void 0!==Symbol.iterator&&"function"==typeof e[Symbol.iterator]}(e))try{return getGeneratorEntries(e[Symbol.iterator]())}catch(e){return[]}return[]}
+/*!
+	 * Gets all entries from a Generator. This will consume the generator - which could have side effects.
+	 *
+	 * @param {Generator} target
+	 * @returns {Array} an array of entries from the Generator.
+	 */function getGeneratorEntries(e){for(var r=e.next(),t=[r.value];!1===r.done;)r=e.next(),t.push(r.value);return t}
+/*!
+	 * Gets all own and inherited enumerable keys from a target.
+	 *
+	 * @param {Object} target
+	 * @returns {Array} an array of own and inherited enumerable keys from the target.
+	 */function getEnumerableKeys(e){var r=[];for(var t in e)r.push(t);return r}function getEnumerableSymbols(e){for(var r=[],t=Object.getOwnPropertySymbols(e),n=0;n<t.length;n+=1){var a=t[n];Object.getOwnPropertyDescriptor(e,a).enumerable&&r.push(a)}return r}
+/*!
+	 * Determines if two objects have matching values, given a set of keys. Defers to deepEqual for the equality check of
+	 * each key. If any value of the given key is not equal, the function will return false (early).
+	 *
+	 * @param {Mixed} leftHandOperand
+	 * @param {Mixed} rightHandOperand
+	 * @param {Array} keys An array of keys to compare the values of leftHandOperand and rightHandOperand against
+	 * @param {Object} [options] (Optional)
+	 * @return {Boolean} result
+	 */function keysEqual(e,r,t,n){var a=t.length;if(0===a)return!0;for(var i=0;i<a;i+=1)if(!1===deepEqual(e[t[i]],r[t[i]],n))return!1;return!0}function isPrimitive(e){return null===e||"object"!=typeof e}function mapSymbols(e){return e.map((function mapSymbol(e){return"symbol"==typeof e?e.toString():e}))}return e.exports=deepEqual,e.exports.MemoizeMap=a,e.exports}export{requireDeepEql as __require};
+//# sourceMappingURL=index.esm.js.map

package/dist/browser/node_modules/.pnpm/deep-eql@4.1.4/node_modules/deep-eql/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":["../../../../../../../../../node_modules/.pnpm/deep-eql@4.1.4/node_modules/deep-eql/index.js"],"sourcesContent":["'use strict';\n/* globals Symbol: false, Uint8Array: false, WeakMap: false */\n/*!\n * deep-eql\n * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar type = require('type-detect');\nfunction FakeMap() {\n  this._key = 'chai/deep-eql__' + Math.random() + Date.now();\n}\n\nFakeMap.prototype = {\n  get: function get(key) {\n    return key[this._key];\n  },\n  set: function set(key, value) {\n    if (Object.isExtensible(key)) {\n      Object.defineProperty(key, this._key, {\n        value: value,\n        configurable: true,\n      });\n    }\n  },\n};\n\nvar MemoizeMap = typeof WeakMap === 'function' ? WeakMap : FakeMap;\n/*!\n * Check to see if the MemoizeMap has recorded a result of the two operands\n *\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @param {MemoizeMap} memoizeMap\n * @returns {Boolean|null} result\n*/\nfunction memoizeCompare(leftHandOperand, rightHandOperand, memoizeMap) {\n  // Technically, WeakMap keys can *only* be objects, not primitives.\n  if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {\n    return null;\n  }\n  var leftHandMap = memoizeMap.get(leftHandOperand);\n  if (leftHandMap) {\n    var result = leftHandMap.get(rightHandOperand);\n    if (typeof result === 'boolean') {\n      return result;\n    }\n  }\n  return null;\n}\n\n/*!\n * Set the result of the equality into the MemoizeMap\n *\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @param {MemoizeMap} memoizeMap\n * @param {Boolean} result\n*/\nfunction memoizeSet(leftHandOperand, rightHandOperand, memoizeMap, result) {\n  // Technically, WeakMap keys can *only* be objects, not primitives.\n  if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {\n    return;\n  }\n  var leftHandMap = memoizeMap.get(leftHandOperand);\n  if (leftHandMap) {\n    leftHandMap.set(rightHandOperand, result);\n  } else {\n    leftHandMap = new MemoizeMap();\n    leftHandMap.set(rightHandOperand, result);\n    memoizeMap.set(leftHandOperand, leftHandMap);\n  }\n}\n\n/*!\n * Primary Export\n */\n\nmodule.exports = deepEqual;\nmodule.exports.MemoizeMap = MemoizeMap;\n\n/**\n * Assert deeply nested sameValue equality between two objects of any type.\n *\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @param {Object} [options] (optional) Additional options\n * @param {Array} [options.comparator] (optional) Override default algorithm, determining custom equality.\n * @param {Array} [options.memoize] (optional) Provide a custom memoization object which will cache the results of\n    complex objects for a speed boost. By passing `false` you can disable memoization, but this will cause circular\n    references to blow the stack.\n * @return {Boolean} equal match\n */\nfunction deepEqual(leftHandOperand, rightHandOperand, options) {\n  // If we have a comparator, we can't assume anything; so bail to its check first.\n  if (options && options.comparator) {\n    return extensiveDeepEqual(leftHandOperand, rightHandOperand, options);\n  }\n\n  var simpleResult = simpleEqual(leftHandOperand, rightHandOperand);\n  if (simpleResult !== null) {\n    return simpleResult;\n  }\n\n  // Deeper comparisons are pushed through to a larger function\n  return extensiveDeepEqual(leftHandOperand, rightHandOperand, options);\n}\n\n/**\n * Many comparisons can be canceled out early via simple equality or primitive checks.\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @return {Boolean|null} equal match\n */\nfunction simpleEqual(leftHandOperand, rightHandOperand) {\n  // Equal references (except for Numbers) can be returned early\n  if (leftHandOperand === rightHandOperand) {\n    // Handle +-0 cases\n    return leftHandOperand !== 0 || 1 / leftHandOperand === 1 / rightHandOperand;\n  }\n\n  // handle NaN cases\n  if (\n    leftHandOperand !== leftHandOperand && // eslint-disable-line no-self-compare\n    rightHandOperand !== rightHandOperand // eslint-disable-line no-self-compare\n  ) {\n    return true;\n  }\n\n  // Anything that is not an 'object', i.e. symbols, functions, booleans, numbers,\n  // strings, and undefined, can be compared by reference.\n  if (isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {\n    // Easy out b/c it would have passed the first equality check\n    return false;\n  }\n  return null;\n}\n\n/*!\n * The main logic of the `deepEqual` function.\n *\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @param {Object} [options] (optional) Additional options\n * @param {Array} [options.comparator] (optional) Override default algorithm, determining custom equality.\n * @param {Array} [options.memoize] (optional) Provide a custom memoization object which will cache the results of\n    complex objects for a speed boost. By passing `false` you can disable memoization, but this will cause circular\n    references to blow the stack.\n * @return {Boolean} equal match\n*/\nfunction extensiveDeepEqual(leftHandOperand, rightHandOperand, options) {\n  options = options || {};\n  options.memoize = options.memoize === false ? false : options.memoize || new MemoizeMap();\n  var comparator = options && options.comparator;\n\n  // Check if a memoized result exists.\n  var memoizeResultLeft = memoizeCompare(leftHandOperand, rightHandOperand, options.memoize);\n  if (memoizeResultLeft !== null) {\n    return memoizeResultLeft;\n  }\n  var memoizeResultRight = memoizeCompare(rightHandOperand, leftHandOperand, options.memoize);\n  if (memoizeResultRight !== null) {\n    return memoizeResultRight;\n  }\n\n  // If a comparator is present, use it.\n  if (comparator) {\n    var comparatorResult = comparator(leftHandOperand, rightHandOperand);\n    // Comparators may return null, in which case we want to go back to default behavior.\n    if (comparatorResult === false || comparatorResult === true) {\n      memoizeSet(leftHandOperand, rightHandOperand, options.memoize, comparatorResult);\n      return comparatorResult;\n    }\n    // To allow comparators to override *any* behavior, we ran them first. Since it didn't decide\n    // what to do, we need to make sure to return the basic tests first before we move on.\n    var simpleResult = simpleEqual(leftHandOperand, rightHandOperand);\n    if (simpleResult !== null) {\n      // Don't memoize this, it takes longer to set/retrieve than to just compare.\n      return simpleResult;\n    }\n  }\n\n  var leftHandType = type(leftHandOperand);\n  if (leftHandType !== type(rightHandOperand)) {\n    memoizeSet(leftHandOperand, rightHandOperand, options.memoize, false);\n    return false;\n  }\n\n  // Temporarily set the operands in the memoize object to prevent blowing the stack\n  memoizeSet(leftHandOperand, rightHandOperand, options.memoize, true);\n\n  var result = extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options);\n  memoizeSet(leftHandOperand, rightHandOperand, options.memoize, result);\n  return result;\n}\n\nfunction extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options) {\n  switch (leftHandType) {\n    case 'String':\n    case 'Number':\n    case 'Boolean':\n    case 'Date':\n      // If these types are their instance types (e.g. `new Number`) then re-deepEqual against their values\n      return deepEqual(leftHandOperand.valueOf(), rightHandOperand.valueOf());\n    case 'Promise':\n    case 'Symbol':\n    case 'function':\n    case 'WeakMap':\n    case 'WeakSet':\n      return leftHandOperand === rightHandOperand;\n    case 'Error':\n      return keysEqual(leftHandOperand, rightHandOperand, [ 'name', 'message', 'code' ], options);\n    case 'Arguments':\n    case 'Int8Array':\n    case 'Uint8Array':\n    case 'Uint8ClampedArray':\n    case 'Int16Array':\n    case 'Uint16Array':\n    case 'Int32Array':\n    case 'Uint32Array':\n    case 'Float32Array':\n    case 'Float64Array':\n    case 'Array':\n      return iterableEqual(leftHandOperand, rightHandOperand, options);\n    case 'RegExp':\n      return regexpEqual(leftHandOperand, rightHandOperand);\n    case 'Generator':\n      return generatorEqual(leftHandOperand, rightHandOperand, options);\n    case 'DataView':\n      return iterableEqual(new Uint8Array(leftHandOperand.buffer), new Uint8Array(rightHandOperand.buffer), options);\n    case 'ArrayBuffer':\n      return iterableEqual(new Uint8Array(leftHandOperand), new Uint8Array(rightHandOperand), options);\n    case 'Set':\n      return entriesEqual(leftHandOperand, rightHandOperand, options);\n    case 'Map':\n      return entriesEqual(leftHandOperand, rightHandOperand, options);\n    case 'Temporal.PlainDate':\n    case 'Temporal.PlainTime':\n    case 'Temporal.PlainDateTime':\n    case 'Temporal.Instant':\n    case 'Temporal.ZonedDateTime':\n    case 'Temporal.PlainYearMonth':\n    case 'Temporal.PlainMonthDay':\n      return leftHandOperand.equals(rightHandOperand);\n    case 'Temporal.Duration':\n      return leftHandOperand.total('nanoseconds') === rightHandOperand.total('nanoseconds');\n    case 'Temporal.TimeZone':\n    case 'Temporal.Calendar':\n      return leftHandOperand.toString() === rightHandOperand.toString();\n    default:\n      return objectEqual(leftHandOperand, rightHandOperand, options);\n  }\n}\n\n/*!\n * Compare two Regular Expressions for equality.\n *\n * @param {RegExp} leftHandOperand\n * @param {RegExp} rightHandOperand\n * @return {Boolean} result\n */\n\nfunction regexpEqual(leftHandOperand, rightHandOperand) {\n  return leftHandOperand.toString() === rightHandOperand.toString();\n}\n\n/*!\n * Compare two Sets/Maps for equality. Faster than other equality functions.\n *\n * @param {Set} leftHandOperand\n * @param {Set} rightHandOperand\n * @param {Object} [options] (Optional)\n * @return {Boolean} result\n */\n\nfunction entriesEqual(leftHandOperand, rightHandOperand, options) {\n  try {\n    // IE11 doesn't support Set#entries or Set#@@iterator, so we need manually populate using Set#forEach\n    if (leftHandOperand.size !== rightHandOperand.size) {\n      return false;\n    }\n    if (leftHandOperand.size === 0) {\n      return true;\n    }\n  } catch (sizeError) {\n    // things that aren't actual Maps or Sets will throw here\n    return false;\n  }\n  var leftHandItems = [];\n  var rightHandItems = [];\n  leftHandOperand.forEach(function gatherEntries(key, value) {\n    leftHandItems.push([ key, value ]);\n  });\n  rightHandOperand.forEach(function gatherEntries(key, value) {\n    rightHandItems.push([ key, value ]);\n  });\n  return iterableEqual(leftHandItems.sort(), rightHandItems.sort(), options);\n}\n\n/*!\n * Simple equality for flat iterable objects such as Arrays, TypedArrays or Node.js buffers.\n *\n * @param {Iterable} leftHandOperand\n * @param {Iterable} rightHandOperand\n * @param {Object} [options] (Optional)\n * @return {Boolean} result\n */\n\nfunction iterableEqual(leftHandOperand, rightHandOperand, options) {\n  var length = leftHandOperand.length;\n  if (length !== rightHandOperand.length) {\n    return false;\n  }\n  if (length === 0) {\n    return true;\n  }\n  var index = -1;\n  while (++index < length) {\n    if (deepEqual(leftHandOperand[index], rightHandOperand[index], options) === false) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/*!\n * Simple equality for generator objects such as those returned by generator functions.\n *\n * @param {Iterable} leftHandOperand\n * @param {Iterable} rightHandOperand\n * @param {Object} [options] (Optional)\n * @return {Boolean} result\n */\n\nfunction generatorEqual(leftHandOperand, rightHandOperand, options) {\n  return iterableEqual(getGeneratorEntries(leftHandOperand), getGeneratorEntries(rightHandOperand), options);\n}\n\n/*!\n * Determine if the given object has an @@iterator function.\n *\n * @param {Object} target\n * @return {Boolean} `true` if the object has an @@iterator function.\n */\nfunction hasIteratorFunction(target) {\n  return typeof Symbol !== 'undefined' &&\n    typeof target === 'object' &&\n    typeof Symbol.iterator !== 'undefined' &&\n    typeof target[Symbol.iterator] === 'function';\n}\n\n/*!\n * Gets all iterator entries from the given Object. If the Object has no @@iterator function, returns an empty array.\n * This will consume the iterator - which could have side effects depending on the @@iterator implementation.\n *\n * @param {Object} target\n * @returns {Array} an array of entries from the @@iterator function\n */\nfunction getIteratorEntries(target) {\n  if (hasIteratorFunction(target)) {\n    try {\n      return getGeneratorEntries(target[Symbol.iterator]());\n    } catch (iteratorError) {\n      return [];\n    }\n  }\n  return [];\n}\n\n/*!\n * Gets all entries from a Generator. This will consume the generator - which could have side effects.\n *\n * @param {Generator} target\n * @returns {Array} an array of entries from the Generator.\n */\nfunction getGeneratorEntries(generator) {\n  var generatorResult = generator.next();\n  var accumulator = [ generatorResult.value ];\n  while (generatorResult.done === false) {\n    generatorResult = generator.next();\n    accumulator.push(generatorResult.value);\n  }\n  return accumulator;\n}\n\n/*!\n * Gets all own and inherited enumerable keys from a target.\n *\n * @param {Object} target\n * @returns {Array} an array of own and inherited enumerable keys from the target.\n */\nfunction getEnumerableKeys(target) {\n  var keys = [];\n  for (var key in target) {\n    keys.push(key);\n  }\n  return keys;\n}\n\nfunction getEnumerableSymbols(target) {\n  var keys = [];\n  var allKeys = Object.getOwnPropertySymbols(target);\n  for (var i = 0; i < allKeys.length; i += 1) {\n    var key = allKeys[i];\n    if (Object.getOwnPropertyDescriptor(target, key).enumerable) {\n      keys.push(key);\n    }\n  }\n  return keys;\n}\n\n/*!\n * Determines if two objects have matching values, given a set of keys. Defers to deepEqual for the equality check of\n * each key. If any value of the given key is not equal, the function will return false (early).\n *\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @param {Array} keys An array of keys to compare the values of leftHandOperand and rightHandOperand against\n * @param {Object} [options] (Optional)\n * @return {Boolean} result\n */\nfunction keysEqual(leftHandOperand, rightHandOperand, keys, options) {\n  var length = keys.length;\n  if (length === 0) {\n    return true;\n  }\n  for (var i = 0; i < length; i += 1) {\n    if (deepEqual(leftHandOperand[keys[i]], rightHandOperand[keys[i]], options) === false) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/*!\n * Recursively check the equality of two Objects. Once basic sameness has been established it will defer to `deepEqual`\n * for each enumerable key in the object.\n *\n * @param {Mixed} leftHandOperand\n * @param {Mixed} rightHandOperand\n * @param {Object} [options] (Optional)\n * @return {Boolean} result\n */\nfunction objectEqual(leftHandOperand, rightHandOperand, options) {\n  var leftHandKeys = getEnumerableKeys(leftHandOperand);\n  var rightHandKeys = getEnumerableKeys(rightHandOperand);\n  var leftHandSymbols = getEnumerableSymbols(leftHandOperand);\n  var rightHandSymbols = getEnumerableSymbols(rightHandOperand);\n  leftHandKeys = leftHandKeys.concat(leftHandSymbols);\n  rightHandKeys = rightHandKeys.concat(rightHandSymbols);\n\n  if (leftHandKeys.length && leftHandKeys.length === rightHandKeys.length) {\n    if (iterableEqual(mapSymbols(leftHandKeys).sort(), mapSymbols(rightHandKeys).sort()) === false) {\n      return false;\n    }\n    return keysEqual(leftHandOperand, rightHandOperand, leftHandKeys, options);\n  }\n\n  var leftHandEntries = getIteratorEntries(leftHandOperand);\n  var rightHandEntries = getIteratorEntries(rightHandOperand);\n  if (leftHandEntries.length && leftHandEntries.length === rightHandEntries.length) {\n    leftHandEntries.sort();\n    rightHandEntries.sort();\n    return iterableEqual(leftHandEntries, rightHandEntries, options);\n  }\n\n  if (leftHandKeys.length === 0 &&\n      leftHandEntries.length === 0 &&\n      rightHandKeys.length === 0 &&\n      rightHandEntries.length === 0) {\n    return true;\n  }\n\n  return false;\n}\n\n/*!\n * Returns true if the argument is a primitive.\n *\n * This intentionally returns true for all objects that can be compared by reference,\n * including functions and symbols.\n *\n * @param {Mixed} value\n * @return {Boolean} result\n */\nfunction isPrimitive(value) {\n  return value === null || typeof value !== 'object';\n}\n\nfunction mapSymbols(arr) {\n  return arr.map(function mapSymbol(entry) {\n    if (typeof entry === 'symbol') {\n      return entry.toString();\n    }\n\n    return entry;\n  });\n}\n"],"names":["type","require$$0","FakeMap","this","_key","Math","random","Date","now","prototype","get","key","set","value","Object","isExtensible","defineProperty","configurable","MemoizeMap","WeakMap","memoizeCompare","leftHandOperand","rightHandOperand","memoizeMap","isPrimitive","leftHandMap","result","memoizeSet","deepEqual","options","comparator","extensiveDeepEqual","simpleResult","simpleEqual","memoize","memoizeResultLeft","memoizeResultRight","comparatorResult","leftHandType","extensiveDeepEqualByType","valueOf","keysEqual","iterableEqual","regexpEqual","toString","generatorEqual","getGeneratorEntries","Uint8Array","buffer","entriesEqual","equals","total","objectEqual","leftHandKeys","getEnumerableKeys","rightHandKeys","leftHandSymbols","getEnumerableSymbols","rightHandSymbols","concat","length","mapSymbols","sort","leftHandEntries","getIteratorEntries","rightHandEntries","size","sizeError","leftHandItems","rightHandItems","forEach","gatherEntries","push","index","target","hasIteratorFunction","Symbol","iterator","iteratorError","generator","generatorResult","next","accumulator","done","keys","allKeys","getOwnPropertySymbols","i","getOwnPropertyDescriptor","enumerable","arr","map","mapSymbol","entry","deepEqlModule","exports"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/diff-sequences@29.6.3/node_modules/diff-sequences/build/index.amd.js

@@ -0,0 +1,2 @@
+define(["exports","../../../../../../_virtual/index.amd5"],(function(n,o){"use strict";var e;n.__require=function requireBuild(){if(e)return o.__exports;e=1,Object.defineProperty(o.__exports,"__esModule",{value:!0}),o.__exports.default=function diffSequence(n,o,e,t){validateLength("aLength",n),validateLength("bLength",o),validateCallback("isCommon",e),validateCallback("foundSubsequence",t);const i=countCommonItemsF(0,n,0,o,e);0!==i&&t(i,0,0);if(n!==i||o!==i){const l=i,g=i,c=countCommonItemsR(l,n-1,g,o-1,e),a=n-c,m=o-c,s=i+c;if(n!==s&&o!==s){findSubsequences(0,l,a,g,m,!1,[{foundSubsequence:t,isCommon:e}],[r],[r],{aCommonFollowing:r,aCommonPreceding:r,aEndPreceding:r,aStartFollowing:r,bCommonFollowing:r,bCommonPreceding:r,bEndPreceding:r,bStartFollowing:r,nChangeFollowing:r,nChangePreceding:r,nCommonFollowing:r,nCommonPreceding:r})}0!==c&&t(c,a,m)}};const n="diff-sequences",r=0,countCommonItemsF=(n,o,e,r,t)=>{let i=0;for(;n<o&&e<r&&t(n,e);)n+=1,e+=1,i+=1;return i},countCommonItemsR=(n,o,e,r,t)=>{let i=0;for(;n<=o&&e<=r&&t(o,r);)o-=1,r-=1,i+=1;return i},extendPathsF=(n,o,e,r,t,i,l)=>{let g=0,c=-n,a=i[g],m=a;i[g]+=countCommonItemsF(a+1,o,r+a-c+1,e,t);const s=n<l?n:l;for(g+=1,c+=2;g<=s;g+=1,c+=2){if(g!==n&&m<i[g])a=i[g];else if(a=m+1,o<=a)return g-1;m=i[g],i[g]=a+countCommonItemsF(a+1,o,r+a-c+1,e,t)}return l},extendPathsR=(n,o,e,r,t,i,l)=>{let g=0,c=n,a=i[g],m=a;i[g]-=countCommonItemsR(o,a-1,e,r+a-c-1,t);const s=n<l?n:l;for(g+=1,c-=2;g<=s;g+=1,c-=2){if(g!==n&&i[g]<m)a=i[g];else if(a=m-1,a<o)return g-1;m=i[g],i[g]=a-countCommonItemsR(o,a-1,e,r+a-c-1,t)}return l},extendOverlappablePathsF=(n,o,e,t,i,l,g,c,a,m,s)=>{const d=t-o,f=i-t-(e-o),u=-f-(n-1),w=n-1-f;let C=r;const b=n<c?n:c;for(let r=0,c=-n;r<=b;r+=1,c+=2){const b=0===r||r!==n&&C<g[r],F=b?g[r]:C,P=b?F:F+1,S=d+P-c,E=countCommonItemsF(P+1,e,S+1,i,l),$=P+E;if(C=g[r],g[r]=$,u<=c&&c<=w){const r=(n-1-(c+f))/2;if(r<=m&&a[r]-1<=$){const r=d+F-(b?c+1:c-1),g=countCommonItemsR(o,F,t,r,l),a=F-g+1,m=r-g+1;s.nChangePreceding=n-1,n-1==a+m-o-t?(s.aEndPreceding=o,s.bEndPreceding=t):(s.aEndPreceding=a,s.bEndPreceding=m),s.nCommonPreceding=g,0!==g&&(s.aCommonPreceding=a,s.bCommonPreceding=m),s.nCommonFollowing=E,0!==E&&(s.aCommonFollowing=P+1,s.bCommonFollowing=S+1);const f=$+1,u=S+E+1;return s.nChangeFollowing=n-1,n-1==e+i-f-u?(s.aStartFollowing=e,s.bStartFollowing=i):(s.aStartFollowing=f,s.bStartFollowing=u),!0}}}return!1},extendOverlappablePathsR=(n,o,e,t,i,l,g,c,a,m,s)=>{const d=i-e,f=i-t-(e-o),u=f-n,w=f+n;let C=r;const b=n<m?n:m;for(let r=0,m=n;r<=b;r+=1,m-=2){const b=0===r||r!==n&&a[r]<C,F=b?a[r]:C,P=b?F:F-1,S=d+P-m,E=countCommonItemsR(o,P-1,t,S-1,l),$=P-E;if(C=a[r],a[r]=$,u<=m&&m<=w){const r=(n+(m-f))/2;if(r<=c&&$-1<=g[r]){const r=S-E;if(s.nChangePreceding=n,n===$+r-o-t?(s.aEndPreceding=o,s.bEndPreceding=t):(s.aEndPreceding=$,s.bEndPreceding=r),s.nCommonPreceding=E,0!==E&&(s.aCommonPreceding=$,s.bCommonPreceding=r),s.nChangeFollowing=n-1,1===n)s.nCommonFollowing=0,s.aStartFollowing=e,s.bStartFollowing=i;else{const o=d+F-(b?m-1:m+1),r=countCommonItemsF(F,e,o,i,l);s.nCommonFollowing=r,0!==r&&(s.aCommonFollowing=F,s.bCommonFollowing=o);const t=F+r,g=o+r;n-1==e+i-t-g?(s.aStartFollowing=e,s.bStartFollowing=i):(s.aStartFollowing=t,s.bStartFollowing=g)}return!0}}}return!1},findSubsequences=(o,e,r,t,i,l,g,c,a,m)=>{if(i-t<r-e){if((l=!l)&&1===g.length){const{foundSubsequence:n,isCommon:o}=g[0];g[1]={foundSubsequence:(o,e,r)=>{n(o,r,e)},isCommon:(n,e)=>o(e,n)}}const n=e,o=r;e=t,r=i,t=n,i=o}const{foundSubsequence:s,isCommon:d}=g[l?1:0];((o,e,r,t,i,l,g,c,a)=>{const m=t-e,s=i-r,d=r-e,f=i-t,u=f-d;let w=d,C=d;if(g[0]=e-1,c[0]=r,u%2==0){const n=(o||u)/2,b=(d+f)/2;for(let o=1;o<=b;o+=1)if(w=extendPathsF(o,r,i,m,l,g,w),o<n)C=extendPathsR(o,e,t,s,l,c,C);else if(extendOverlappablePathsR(o,e,r,t,i,l,g,w,c,C,a))return}else{const n=((o||u)+1)/2,b=(d+f+1)/2;let F=1;for(w=extendPathsF(F,r,i,m,l,g,w),F+=1;F<=b;F+=1)if(C=extendPathsR(F-1,e,t,s,l,c,C),F<n)w=extendPathsF(F,r,i,m,l,g,w);else if(extendOverlappablePathsF(F,e,r,t,i,l,g,w,c,C,a))return}throw new Error(`${n}: no overlap aStart=${e} aEnd=${r} bStart=${t} bEnd=${i}`)})(o,e,r,t,i,d,c,a,m);const{nChangePreceding:f,aEndPreceding:u,bEndPreceding:w,nCommonPreceding:C,aCommonPreceding:b,bCommonPreceding:F,nCommonFollowing:P,aCommonFollowing:S,bCommonFollowing:E,nChangeFollowing:$,aStartFollowing:h,bStartFollowing:p}=m;e<u&&t<w&&findSubsequences(f,e,u,t,w,l,g,c,a,m),0!==C&&s(C,b,F),0!==P&&s(P,S,E),h<r&&p<i&&findSubsequences($,h,r,p,i,l,g,c,a,m)},validateLength=(o,e)=>{if("number"!=typeof e)throw new TypeError(`${n}: ${o} typeof ${typeof e} is not a number`);if(!Number.isSafeInteger(e))throw new RangeError(`${n}: ${o} value ${e} is not a safe integer`);if(e<0)throw new RangeError(`${n}: ${o} value ${e} is a negative integer`)},validateCallback=(o,e)=>{const r=typeof e;if("function"!==r)throw new TypeError(`${n}: ${o} typeof ${r} is not a function`)};return o.__exports}}));
+//# sourceMappingURL=index.amd.js.map

package/dist/browser/node_modules/.pnpm/diff-sequences@29.6.3/node_modules/diff-sequences/build/index.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.amd.js","sources":["../../../../../../../../../../node_modules/.pnpm/diff-sequences@29.6.3/node_modules/diff-sequences/build/index.js"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nexports.default = diffSequence;\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n// This diff-sequences package implements the linear space variation in\n// An O(ND) Difference Algorithm and Its Variations by Eugene W. Myers\n\n// Relationship in notation between Myers paper and this package:\n// A is a\n// N is aLength, aEnd - aStart, and so on\n// x is aIndex, aFirst, aLast, and so on\n// B is b\n// M is bLength, bEnd - bStart, and so on\n// y is bIndex, bFirst, bLast, and so on\n// Δ = N - M is negative of baDeltaLength = bLength - aLength\n// D is d\n// k is kF\n// k + Δ is kF = kR - baDeltaLength\n// V is aIndexesF or aIndexesR (see comment below about Indexes type)\n// index intervals [1, N] and [1, M] are [0, aLength) and [0, bLength)\n// starting point in forward direction (0, 0) is (-1, -1)\n// starting point in reverse direction (N + 1, M + 1) is (aLength, bLength)\n\n// The “edit graph” for sequences a and b corresponds to items:\n// in a on the horizontal axis\n// in b on the vertical axis\n//\n// Given a-coordinate of a point in a diagonal, you can compute b-coordinate.\n//\n// Forward diagonals kF:\n// zero diagonal intersects top left corner\n// positive diagonals intersect top edge\n// negative diagonals insersect left edge\n//\n// Reverse diagonals kR:\n// zero diagonal intersects bottom right corner\n// positive diagonals intersect right edge\n// negative diagonals intersect bottom edge\n\n// The graph contains a directed acyclic graph of edges:\n// horizontal: delete an item from a\n// vertical: insert an item from b\n// diagonal: common item in a and b\n//\n// The algorithm solves dual problems in the graph analogy:\n// Find longest common subsequence: path with maximum number of diagonal edges\n// Find shortest edit script: path with minimum number of non-diagonal edges\n\n// Input callback function compares items at indexes in the sequences.\n\n// Output callback function receives the number of adjacent items\n// and starting indexes of each common subsequence.\n// Either original functions or wrapped to swap indexes if graph is transposed.\n// Indexes in sequence a of last point of forward or reverse paths in graph.\n// Myers algorithm indexes by diagonal k which for negative is bad deopt in V8.\n// This package indexes by iF and iR which are greater than or equal to zero.\n// and also updates the index arrays in place to cut memory in half.\n// kF = 2 * iF - d\n// kR = d - 2 * iR\n// Division of index intervals in sequences a and b at the middle change.\n// Invariant: intervals do not have common items at the start or end.\nconst pkg = 'diff-sequences'; // for error messages\nconst NOT_YET_SET = 0; // small int instead of undefined to avoid deopt in V8\n\n// Return the number of common items that follow in forward direction.\n// The length of what Myers paper calls a “snake” in a forward path.\nconst countCommonItemsF = (aIndex, aEnd, bIndex, bEnd, isCommon) => {\n  let nCommon = 0;\n  while (aIndex < aEnd && bIndex < bEnd && isCommon(aIndex, bIndex)) {\n    aIndex += 1;\n    bIndex += 1;\n    nCommon += 1;\n  }\n  return nCommon;\n};\n\n// Return the number of common items that precede in reverse direction.\n// The length of what Myers paper calls a “snake” in a reverse path.\nconst countCommonItemsR = (aStart, aIndex, bStart, bIndex, isCommon) => {\n  let nCommon = 0;\n  while (aStart <= aIndex && bStart <= bIndex && isCommon(aIndex, bIndex)) {\n    aIndex -= 1;\n    bIndex -= 1;\n    nCommon += 1;\n  }\n  return nCommon;\n};\n\n// A simple function to extend forward paths from (d - 1) to d changes\n// when forward and reverse paths cannot yet overlap.\nconst extendPathsF = (\n  d,\n  aEnd,\n  bEnd,\n  bF,\n  isCommon,\n  aIndexesF,\n  iMaxF // return the value because optimization might decrease it\n) => {\n  // Unroll the first iteration.\n  let iF = 0;\n  let kF = -d; // kF = 2 * iF - d\n  let aFirst = aIndexesF[iF]; // in first iteration always insert\n  let aIndexPrev1 = aFirst; // prev value of [iF - 1] in next iteration\n  aIndexesF[iF] += countCommonItemsF(\n    aFirst + 1,\n    aEnd,\n    bF + aFirst - kF + 1,\n    bEnd,\n    isCommon\n  );\n\n  // Optimization: skip diagonals in which paths cannot ever overlap.\n  const nF = d < iMaxF ? d : iMaxF;\n\n  // The diagonals kF are odd when d is odd and even when d is even.\n  for (iF += 1, kF += 2; iF <= nF; iF += 1, kF += 2) {\n    // To get first point of path segment, move one change in forward direction\n    // from last point of previous path segment in an adjacent diagonal.\n    // In last possible iteration when iF === d and kF === d always delete.\n    if (iF !== d && aIndexPrev1 < aIndexesF[iF]) {\n      aFirst = aIndexesF[iF]; // vertical to insert from b\n    } else {\n      aFirst = aIndexPrev1 + 1; // horizontal to delete from a\n\n      if (aEnd <= aFirst) {\n        // Optimization: delete moved past right of graph.\n        return iF - 1;\n      }\n    }\n\n    // To get last point of path segment, move along diagonal of common items.\n    aIndexPrev1 = aIndexesF[iF];\n    aIndexesF[iF] =\n      aFirst +\n      countCommonItemsF(aFirst + 1, aEnd, bF + aFirst - kF + 1, bEnd, isCommon);\n  }\n  return iMaxF;\n};\n\n// A simple function to extend reverse paths from (d - 1) to d changes\n// when reverse and forward paths cannot yet overlap.\nconst extendPathsR = (\n  d,\n  aStart,\n  bStart,\n  bR,\n  isCommon,\n  aIndexesR,\n  iMaxR // return the value because optimization might decrease it\n) => {\n  // Unroll the first iteration.\n  let iR = 0;\n  let kR = d; // kR = d - 2 * iR\n  let aFirst = aIndexesR[iR]; // in first iteration always insert\n  let aIndexPrev1 = aFirst; // prev value of [iR - 1] in next iteration\n  aIndexesR[iR] -= countCommonItemsR(\n    aStart,\n    aFirst - 1,\n    bStart,\n    bR + aFirst - kR - 1,\n    isCommon\n  );\n\n  // Optimization: skip diagonals in which paths cannot ever overlap.\n  const nR = d < iMaxR ? d : iMaxR;\n\n  // The diagonals kR are odd when d is odd and even when d is even.\n  for (iR += 1, kR -= 2; iR <= nR; iR += 1, kR -= 2) {\n    // To get first point of path segment, move one change in reverse direction\n    // from last point of previous path segment in an adjacent diagonal.\n    // In last possible iteration when iR === d and kR === -d always delete.\n    if (iR !== d && aIndexesR[iR] < aIndexPrev1) {\n      aFirst = aIndexesR[iR]; // vertical to insert from b\n    } else {\n      aFirst = aIndexPrev1 - 1; // horizontal to delete from a\n\n      if (aFirst < aStart) {\n        // Optimization: delete moved past left of graph.\n        return iR - 1;\n      }\n    }\n\n    // To get last point of path segment, move along diagonal of common items.\n    aIndexPrev1 = aIndexesR[iR];\n    aIndexesR[iR] =\n      aFirst -\n      countCommonItemsR(\n        aStart,\n        aFirst - 1,\n        bStart,\n        bR + aFirst - kR - 1,\n        isCommon\n      );\n  }\n  return iMaxR;\n};\n\n// A complete function to extend forward paths from (d - 1) to d changes.\n// Return true if a path overlaps reverse path of (d - 1) changes in its diagonal.\nconst extendOverlappablePathsF = (\n  d,\n  aStart,\n  aEnd,\n  bStart,\n  bEnd,\n  isCommon,\n  aIndexesF,\n  iMaxF,\n  aIndexesR,\n  iMaxR,\n  division // update prop values if return true\n) => {\n  const bF = bStart - aStart; // bIndex = bF + aIndex - kF\n  const aLength = aEnd - aStart;\n  const bLength = bEnd - bStart;\n  const baDeltaLength = bLength - aLength; // kF = kR - baDeltaLength\n\n  // Range of diagonals in which forward and reverse paths might overlap.\n  const kMinOverlapF = -baDeltaLength - (d - 1); // -(d - 1) <= kR\n  const kMaxOverlapF = -baDeltaLength + (d - 1); // kR <= (d - 1)\n\n  let aIndexPrev1 = NOT_YET_SET; // prev value of [iF - 1] in next iteration\n\n  // Optimization: skip diagonals in which paths cannot ever overlap.\n  const nF = d < iMaxF ? d : iMaxF;\n\n  // The diagonals kF = 2 * iF - d are odd when d is odd and even when d is even.\n  for (let iF = 0, kF = -d; iF <= nF; iF += 1, kF += 2) {\n    // To get first point of path segment, move one change in forward direction\n    // from last point of previous path segment in an adjacent diagonal.\n    // In first iteration when iF === 0 and kF === -d always insert.\n    // In last possible iteration when iF === d and kF === d always delete.\n    const insert = iF === 0 || (iF !== d && aIndexPrev1 < aIndexesF[iF]);\n    const aLastPrev = insert ? aIndexesF[iF] : aIndexPrev1;\n    const aFirst = insert\n      ? aLastPrev // vertical to insert from b\n      : aLastPrev + 1; // horizontal to delete from a\n\n    // To get last point of path segment, move along diagonal of common items.\n    const bFirst = bF + aFirst - kF;\n    const nCommonF = countCommonItemsF(\n      aFirst + 1,\n      aEnd,\n      bFirst + 1,\n      bEnd,\n      isCommon\n    );\n    const aLast = aFirst + nCommonF;\n    aIndexPrev1 = aIndexesF[iF];\n    aIndexesF[iF] = aLast;\n    if (kMinOverlapF <= kF && kF <= kMaxOverlapF) {\n      // Solve for iR of reverse path with (d - 1) changes in diagonal kF:\n      // kR = kF + baDeltaLength\n      // kR = (d - 1) - 2 * iR\n      const iR = (d - 1 - (kF + baDeltaLength)) / 2;\n\n      // If this forward path overlaps the reverse path in this diagonal,\n      // then this is the middle change of the index intervals.\n      if (iR <= iMaxR && aIndexesR[iR] - 1 <= aLast) {\n        // Unlike the Myers algorithm which finds only the middle “snake”\n        // this package can find two common subsequences per division.\n        // Last point of previous path segment is on an adjacent diagonal.\n        const bLastPrev = bF + aLastPrev - (insert ? kF + 1 : kF - 1);\n\n        // Because of invariant that intervals preceding the middle change\n        // cannot have common items at the end,\n        // move in reverse direction along a diagonal of common items.\n        const nCommonR = countCommonItemsR(\n          aStart,\n          aLastPrev,\n          bStart,\n          bLastPrev,\n          isCommon\n        );\n        const aIndexPrevFirst = aLastPrev - nCommonR;\n        const bIndexPrevFirst = bLastPrev - nCommonR;\n        const aEndPreceding = aIndexPrevFirst + 1;\n        const bEndPreceding = bIndexPrevFirst + 1;\n        division.nChangePreceding = d - 1;\n        if (d - 1 === aEndPreceding + bEndPreceding - aStart - bStart) {\n          // Optimization: number of preceding changes in forward direction\n          // is equal to number of items in preceding interval,\n          // therefore it cannot contain any common items.\n          division.aEndPreceding = aStart;\n          division.bEndPreceding = bStart;\n        } else {\n          division.aEndPreceding = aEndPreceding;\n          division.bEndPreceding = bEndPreceding;\n        }\n        division.nCommonPreceding = nCommonR;\n        if (nCommonR !== 0) {\n          division.aCommonPreceding = aEndPreceding;\n          division.bCommonPreceding = bEndPreceding;\n        }\n        division.nCommonFollowing = nCommonF;\n        if (nCommonF !== 0) {\n          division.aCommonFollowing = aFirst + 1;\n          division.bCommonFollowing = bFirst + 1;\n        }\n        const aStartFollowing = aLast + 1;\n        const bStartFollowing = bFirst + nCommonF + 1;\n        division.nChangeFollowing = d - 1;\n        if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {\n          // Optimization: number of changes in reverse direction\n          // is equal to number of items in following interval,\n          // therefore it cannot contain any common items.\n          division.aStartFollowing = aEnd;\n          division.bStartFollowing = bEnd;\n        } else {\n          division.aStartFollowing = aStartFollowing;\n          division.bStartFollowing = bStartFollowing;\n        }\n        return true;\n      }\n    }\n  }\n  return false;\n};\n\n// A complete function to extend reverse paths from (d - 1) to d changes.\n// Return true if a path overlaps forward path of d changes in its diagonal.\nconst extendOverlappablePathsR = (\n  d,\n  aStart,\n  aEnd,\n  bStart,\n  bEnd,\n  isCommon,\n  aIndexesF,\n  iMaxF,\n  aIndexesR,\n  iMaxR,\n  division // update prop values if return true\n) => {\n  const bR = bEnd - aEnd; // bIndex = bR + aIndex - kR\n  const aLength = aEnd - aStart;\n  const bLength = bEnd - bStart;\n  const baDeltaLength = bLength - aLength; // kR = kF + baDeltaLength\n\n  // Range of diagonals in which forward and reverse paths might overlap.\n  const kMinOverlapR = baDeltaLength - d; // -d <= kF\n  const kMaxOverlapR = baDeltaLength + d; // kF <= d\n\n  let aIndexPrev1 = NOT_YET_SET; // prev value of [iR - 1] in next iteration\n\n  // Optimization: skip diagonals in which paths cannot ever overlap.\n  const nR = d < iMaxR ? d : iMaxR;\n\n  // The diagonals kR = d - 2 * iR are odd when d is odd and even when d is even.\n  for (let iR = 0, kR = d; iR <= nR; iR += 1, kR -= 2) {\n    // To get first point of path segment, move one change in reverse direction\n    // from last point of previous path segment in an adjacent diagonal.\n    // In first iteration when iR === 0 and kR === d always insert.\n    // In last possible iteration when iR === d and kR === -d always delete.\n    const insert = iR === 0 || (iR !== d && aIndexesR[iR] < aIndexPrev1);\n    const aLastPrev = insert ? aIndexesR[iR] : aIndexPrev1;\n    const aFirst = insert\n      ? aLastPrev // vertical to insert from b\n      : aLastPrev - 1; // horizontal to delete from a\n\n    // To get last point of path segment, move along diagonal of common items.\n    const bFirst = bR + aFirst - kR;\n    const nCommonR = countCommonItemsR(\n      aStart,\n      aFirst - 1,\n      bStart,\n      bFirst - 1,\n      isCommon\n    );\n    const aLast = aFirst - nCommonR;\n    aIndexPrev1 = aIndexesR[iR];\n    aIndexesR[iR] = aLast;\n    if (kMinOverlapR <= kR && kR <= kMaxOverlapR) {\n      // Solve for iF of forward path with d changes in diagonal kR:\n      // kF = kR - baDeltaLength\n      // kF = 2 * iF - d\n      const iF = (d + (kR - baDeltaLength)) / 2;\n\n      // If this reverse path overlaps the forward path in this diagonal,\n      // then this is a middle change of the index intervals.\n      if (iF <= iMaxF && aLast - 1 <= aIndexesF[iF]) {\n        const bLast = bFirst - nCommonR;\n        division.nChangePreceding = d;\n        if (d === aLast + bLast - aStart - bStart) {\n          // Optimization: number of changes in reverse direction\n          // is equal to number of items in preceding interval,\n          // therefore it cannot contain any common items.\n          division.aEndPreceding = aStart;\n          division.bEndPreceding = bStart;\n        } else {\n          division.aEndPreceding = aLast;\n          division.bEndPreceding = bLast;\n        }\n        division.nCommonPreceding = nCommonR;\n        if (nCommonR !== 0) {\n          // The last point of reverse path segment is start of common subsequence.\n          division.aCommonPreceding = aLast;\n          division.bCommonPreceding = bLast;\n        }\n        division.nChangeFollowing = d - 1;\n        if (d === 1) {\n          // There is no previous path segment.\n          division.nCommonFollowing = 0;\n          division.aStartFollowing = aEnd;\n          division.bStartFollowing = bEnd;\n        } else {\n          // Unlike the Myers algorithm which finds only the middle “snake”\n          // this package can find two common subsequences per division.\n          // Last point of previous path segment is on an adjacent diagonal.\n          const bLastPrev = bR + aLastPrev - (insert ? kR - 1 : kR + 1);\n\n          // Because of invariant that intervals following the middle change\n          // cannot have common items at the start,\n          // move in forward direction along a diagonal of common items.\n          const nCommonF = countCommonItemsF(\n            aLastPrev,\n            aEnd,\n            bLastPrev,\n            bEnd,\n            isCommon\n          );\n          division.nCommonFollowing = nCommonF;\n          if (nCommonF !== 0) {\n            // The last point of reverse path segment is start of common subsequence.\n            division.aCommonFollowing = aLastPrev;\n            division.bCommonFollowing = bLastPrev;\n          }\n          const aStartFollowing = aLastPrev + nCommonF; // aFirstPrev\n          const bStartFollowing = bLastPrev + nCommonF; // bFirstPrev\n\n          if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {\n            // Optimization: number of changes in forward direction\n            // is equal to number of items in following interval,\n            // therefore it cannot contain any common items.\n            division.aStartFollowing = aEnd;\n            division.bStartFollowing = bEnd;\n          } else {\n            division.aStartFollowing = aStartFollowing;\n            division.bStartFollowing = bStartFollowing;\n          }\n        }\n        return true;\n      }\n    }\n  }\n  return false;\n};\n\n// Given index intervals and input function to compare items at indexes,\n// divide at the middle change.\n//\n// DO NOT CALL if start === end, because interval cannot contain common items\n// and because this function will throw the “no overlap” error.\nconst divide = (\n  nChange,\n  aStart,\n  aEnd,\n  bStart,\n  bEnd,\n  isCommon,\n  aIndexesF,\n  aIndexesR,\n  division // output\n) => {\n  const bF = bStart - aStart; // bIndex = bF + aIndex - kF\n  const bR = bEnd - aEnd; // bIndex = bR + aIndex - kR\n  const aLength = aEnd - aStart;\n  const bLength = bEnd - bStart;\n\n  // Because graph has square or portrait orientation,\n  // length difference is minimum number of items to insert from b.\n  // Corresponding forward and reverse diagonals in graph\n  // depend on length difference of the sequences:\n  // kF = kR - baDeltaLength\n  // kR = kF + baDeltaLength\n  const baDeltaLength = bLength - aLength;\n\n  // Optimization: max diagonal in graph intersects corner of shorter side.\n  let iMaxF = aLength;\n  let iMaxR = aLength;\n\n  // Initialize no changes yet in forward or reverse direction:\n  aIndexesF[0] = aStart - 1; // at open start of interval, outside closed start\n  aIndexesR[0] = aEnd; // at open end of interval\n\n  if (baDeltaLength % 2 === 0) {\n    // The number of changes in paths is 2 * d if length difference is even.\n    const dMin = (nChange || baDeltaLength) / 2;\n    const dMax = (aLength + bLength) / 2;\n    for (let d = 1; d <= dMax; d += 1) {\n      iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);\n      if (d < dMin) {\n        iMaxR = extendPathsR(d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR);\n      } else if (\n        // If a reverse path overlaps a forward path in the same diagonal,\n        // return a division of the index intervals at the middle change.\n        extendOverlappablePathsR(\n          d,\n          aStart,\n          aEnd,\n          bStart,\n          bEnd,\n          isCommon,\n          aIndexesF,\n          iMaxF,\n          aIndexesR,\n          iMaxR,\n          division\n        )\n      ) {\n        return;\n      }\n    }\n  } else {\n    // The number of changes in paths is 2 * d - 1 if length difference is odd.\n    const dMin = ((nChange || baDeltaLength) + 1) / 2;\n    const dMax = (aLength + bLength + 1) / 2;\n\n    // Unroll first half iteration so loop extends the relevant pairs of paths.\n    // Because of invariant that intervals have no common items at start or end,\n    // and limitation not to call divide with empty intervals,\n    // therefore it cannot be called if a forward path with one change\n    // would overlap a reverse path with no changes, even if dMin === 1.\n    let d = 1;\n    iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);\n    for (d += 1; d <= dMax; d += 1) {\n      iMaxR = extendPathsR(\n        d - 1,\n        aStart,\n        bStart,\n        bR,\n        isCommon,\n        aIndexesR,\n        iMaxR\n      );\n      if (d < dMin) {\n        iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);\n      } else if (\n        // If a forward path overlaps a reverse path in the same diagonal,\n        // return a division of the index intervals at the middle change.\n        extendOverlappablePathsF(\n          d,\n          aStart,\n          aEnd,\n          bStart,\n          bEnd,\n          isCommon,\n          aIndexesF,\n          iMaxF,\n          aIndexesR,\n          iMaxR,\n          division\n        )\n      ) {\n        return;\n      }\n    }\n  }\n\n  /* istanbul ignore next */\n  throw new Error(\n    `${pkg}: no overlap aStart=${aStart} aEnd=${aEnd} bStart=${bStart} bEnd=${bEnd}`\n  );\n};\n\n// Given index intervals and input function to compare items at indexes,\n// return by output function the number of adjacent items and starting indexes\n// of each common subsequence. Divide and conquer with only linear space.\n//\n// The index intervals are half open [start, end) like array slice method.\n// DO NOT CALL if start === end, because interval cannot contain common items\n// and because divide function will throw the “no overlap” error.\nconst findSubsequences = (\n  nChange,\n  aStart,\n  aEnd,\n  bStart,\n  bEnd,\n  transposed,\n  callbacks,\n  aIndexesF,\n  aIndexesR,\n  division // temporary memory, not input nor output\n) => {\n  if (bEnd - bStart < aEnd - aStart) {\n    // Transpose graph so it has portrait instead of landscape orientation.\n    // Always compare shorter to longer sequence for consistency and optimization.\n    transposed = !transposed;\n    if (transposed && callbacks.length === 1) {\n      // Lazily wrap callback functions to swap args if graph is transposed.\n      const {foundSubsequence, isCommon} = callbacks[0];\n      callbacks[1] = {\n        foundSubsequence: (nCommon, bCommon, aCommon) => {\n          foundSubsequence(nCommon, aCommon, bCommon);\n        },\n        isCommon: (bIndex, aIndex) => isCommon(aIndex, bIndex)\n      };\n    }\n    const tStart = aStart;\n    const tEnd = aEnd;\n    aStart = bStart;\n    aEnd = bEnd;\n    bStart = tStart;\n    bEnd = tEnd;\n  }\n  const {foundSubsequence, isCommon} = callbacks[transposed ? 1 : 0];\n\n  // Divide the index intervals at the middle change.\n  divide(\n    nChange,\n    aStart,\n    aEnd,\n    bStart,\n    bEnd,\n    isCommon,\n    aIndexesF,\n    aIndexesR,\n    division\n  );\n  const {\n    nChangePreceding,\n    aEndPreceding,\n    bEndPreceding,\n    nCommonPreceding,\n    aCommonPreceding,\n    bCommonPreceding,\n    nCommonFollowing,\n    aCommonFollowing,\n    bCommonFollowing,\n    nChangeFollowing,\n    aStartFollowing,\n    bStartFollowing\n  } = division;\n\n  // Unless either index interval is empty, they might contain common items.\n  if (aStart < aEndPreceding && bStart < bEndPreceding) {\n    // Recursely find and return common subsequences preceding the division.\n    findSubsequences(\n      nChangePreceding,\n      aStart,\n      aEndPreceding,\n      bStart,\n      bEndPreceding,\n      transposed,\n      callbacks,\n      aIndexesF,\n      aIndexesR,\n      division\n    );\n  }\n\n  // Return common subsequences that are adjacent to the middle change.\n  if (nCommonPreceding !== 0) {\n    foundSubsequence(nCommonPreceding, aCommonPreceding, bCommonPreceding);\n  }\n  if (nCommonFollowing !== 0) {\n    foundSubsequence(nCommonFollowing, aCommonFollowing, bCommonFollowing);\n  }\n\n  // Unless either index interval is empty, they might contain common items.\n  if (aStartFollowing < aEnd && bStartFollowing < bEnd) {\n    // Recursely find and return common subsequences following the division.\n    findSubsequences(\n      nChangeFollowing,\n      aStartFollowing,\n      aEnd,\n      bStartFollowing,\n      bEnd,\n      transposed,\n      callbacks,\n      aIndexesF,\n      aIndexesR,\n      division\n    );\n  }\n};\nconst validateLength = (name, arg) => {\n  if (typeof arg !== 'number') {\n    throw new TypeError(`${pkg}: ${name} typeof ${typeof arg} is not a number`);\n  }\n  if (!Number.isSafeInteger(arg)) {\n    throw new RangeError(`${pkg}: ${name} value ${arg} is not a safe integer`);\n  }\n  if (arg < 0) {\n    throw new RangeError(`${pkg}: ${name} value ${arg} is a negative integer`);\n  }\n};\nconst validateCallback = (name, arg) => {\n  const type = typeof arg;\n  if (type !== 'function') {\n    throw new TypeError(`${pkg}: ${name} typeof ${type} is not a function`);\n  }\n};\n\n// Compare items in two sequences to find a longest common subsequence.\n// Given lengths of sequences and input function to compare items at indexes,\n// return by output function the number of adjacent items and starting indexes\n// of each common subsequence.\nfunction diffSequence(aLength, bLength, isCommon, foundSubsequence) {\n  validateLength('aLength', aLength);\n  validateLength('bLength', bLength);\n  validateCallback('isCommon', isCommon);\n  validateCallback('foundSubsequence', foundSubsequence);\n\n  // Count common items from the start in the forward direction.\n  const nCommonF = countCommonItemsF(0, aLength, 0, bLength, isCommon);\n  if (nCommonF !== 0) {\n    foundSubsequence(nCommonF, 0, 0);\n  }\n\n  // Unless both sequences consist of common items only,\n  // find common items in the half-trimmed index intervals.\n  if (aLength !== nCommonF || bLength !== nCommonF) {\n    // Invariant: intervals do not have common items at the start.\n    // The start of an index interval is closed like array slice method.\n    const aStart = nCommonF;\n    const bStart = nCommonF;\n\n    // Count common items from the end in the reverse direction.\n    const nCommonR = countCommonItemsR(\n      aStart,\n      aLength - 1,\n      bStart,\n      bLength - 1,\n      isCommon\n    );\n\n    // Invariant: intervals do not have common items at the end.\n    // The end of an index interval is open like array slice method.\n    const aEnd = aLength - nCommonR;\n    const bEnd = bLength - nCommonR;\n\n    // Unless one sequence consists of common items only,\n    // therefore the other trimmed index interval consists of changes only,\n    // find common items in the trimmed index intervals.\n    const nCommonFR = nCommonF + nCommonR;\n    if (aLength !== nCommonFR && bLength !== nCommonFR) {\n      const nChange = 0; // number of change items is not yet known\n      const transposed = false; // call the original unwrapped functions\n      const callbacks = [\n        {\n          foundSubsequence,\n          isCommon\n        }\n      ];\n\n      // Indexes in sequence a of last points in furthest reaching paths\n      // from outside the start at top left in the forward direction:\n      const aIndexesF = [NOT_YET_SET];\n      // from the end at bottom right in the reverse direction:\n      const aIndexesR = [NOT_YET_SET];\n\n      // Initialize one object as output of all calls to divide function.\n      const division = {\n        aCommonFollowing: NOT_YET_SET,\n        aCommonPreceding: NOT_YET_SET,\n        aEndPreceding: NOT_YET_SET,\n        aStartFollowing: NOT_YET_SET,\n        bCommonFollowing: NOT_YET_SET,\n        bCommonPreceding: NOT_YET_SET,\n        bEndPreceding: NOT_YET_SET,\n        bStartFollowing: NOT_YET_SET,\n        nChangeFollowing: NOT_YET_SET,\n        nChangePreceding: NOT_YET_SET,\n        nCommonFollowing: NOT_YET_SET,\n        nCommonPreceding: NOT_YET_SET\n      };\n\n      // Find and return common subsequences in the trimmed index intervals.\n      findSubsequences(\n        nChange,\n        aStart,\n        aEnd,\n        bStart,\n        bEnd,\n        transposed,\n        callbacks,\n        aIndexesF,\n        aIndexesR,\n        division\n      );\n    }\n    if (nCommonR !== 0) {\n      foundSubsequence(nCommonR, aEnd, bEnd);\n    }\n  }\n}\n"],"names":["Object","defineProperty","build","__exports","value","default","diffSequence","aLength","bLength","isCommon","foundSubsequence","validateLength","validateCallback","nCommonF","countCommonItemsF","aStart","bStart","nCommonR","countCommonItemsR","aEnd","bEnd","nCommonFR","findSubsequences","NOT_YET_SET","aCommonFollowing","aCommonPreceding","aEndPreceding","aStartFollowing","bCommonFollowing","bCommonPreceding","bEndPreceding","bStartFollowing","nChangeFollowing","nChangePreceding","nCommonFollowing","nCommonPreceding","pkg","aIndex","bIndex","nCommon","extendPathsF","d","bF","aIndexesF","iMaxF","iF","kF","aFirst","aIndexPrev1","nF","extendPathsR","bR","aIndexesR","iMaxR","iR","kR","nR","extendOverlappablePathsF","division","baDeltaLength","kMinOverlapF","kMaxOverlapF","insert","aLastPrev","bFirst","aLast","bLastPrev","extendOverlappablePathsR","kMinOverlapR","kMaxOverlapR","bLast","nChange","transposed","callbacks","length","bCommon","aCommon","tStart","tEnd","dMin","dMax","Error","divide","name","arg","TypeError","Number","isSafeInteger","RangeError","type"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/diff-sequences@29.6.3/node_modules/diff-sequences/build/index.esm.js

@@ -0,0 +1,2 @@
+import{__exports as n}from"../../../../../../_virtual/index.esm5.js";var o;function requireBuild(){if(o)return n;o=1,Object.defineProperty(n,"__esModule",{value:!0}),n.default=function diffSequence(n,o,e,t){validateLength("aLength",n),validateLength("bLength",o),validateCallback("isCommon",e),validateCallback("foundSubsequence",t);const i=countCommonItemsF(0,n,0,o,e);0!==i&&t(i,0,0);if(n!==i||o!==i){const l=i,g=i,a=countCommonItemsR(l,n-1,g,o-1,e),c=n-a,m=o-a,s=i+a;if(n!==s&&o!==s){findSubsequences(0,l,c,g,m,!1,[{foundSubsequence:t,isCommon:e}],[r],[r],{aCommonFollowing:r,aCommonPreceding:r,aEndPreceding:r,aStartFollowing:r,bCommonFollowing:r,bCommonPreceding:r,bEndPreceding:r,bStartFollowing:r,nChangeFollowing:r,nChangePreceding:r,nCommonFollowing:r,nCommonPreceding:r})}0!==a&&t(a,c,m)}};const e="diff-sequences",r=0,countCommonItemsF=(n,o,e,r,t)=>{let i=0;for(;n<o&&e<r&&t(n,e);)n+=1,e+=1,i+=1;return i},countCommonItemsR=(n,o,e,r,t)=>{let i=0;for(;n<=o&&e<=r&&t(o,r);)o-=1,r-=1,i+=1;return i},extendPathsF=(n,o,e,r,t,i,l)=>{let g=0,a=-n,c=i[g],m=c;i[g]+=countCommonItemsF(c+1,o,r+c-a+1,e,t);const s=n<l?n:l;for(g+=1,a+=2;g<=s;g+=1,a+=2){if(g!==n&&m<i[g])c=i[g];else if(c=m+1,o<=c)return g-1;m=i[g],i[g]=c+countCommonItemsF(c+1,o,r+c-a+1,e,t)}return l},extendPathsR=(n,o,e,r,t,i,l)=>{let g=0,a=n,c=i[g],m=c;i[g]-=countCommonItemsR(o,c-1,e,r+c-a-1,t);const s=n<l?n:l;for(g+=1,a-=2;g<=s;g+=1,a-=2){if(g!==n&&i[g]<m)c=i[g];else if(c=m-1,c<o)return g-1;m=i[g],i[g]=c-countCommonItemsR(o,c-1,e,r+c-a-1,t)}return l},extendOverlappablePathsF=(n,o,e,t,i,l,g,a,c,m,s)=>{const d=t-o,f=i-t-(e-o),u=-f-(n-1),w=n-1-f;let C=r;const b=n<a?n:a;for(let r=0,a=-n;r<=b;r+=1,a+=2){const b=0===r||r!==n&&C<g[r],F=b?g[r]:C,P=b?F:F+1,S=d+P-a,E=countCommonItemsF(P+1,e,S+1,i,l),$=P+E;if(C=g[r],g[r]=$,u<=a&&a<=w){const r=(n-1-(a+f))/2;if(r<=m&&c[r]-1<=$){const r=d+F-(b?a+1:a-1),g=countCommonItemsR(o,F,t,r,l),c=F-g+1,m=r-g+1;s.nChangePreceding=n-1,n-1==c+m-o-t?(s.aEndPreceding=o,s.bEndPreceding=t):(s.aEndPreceding=c,s.bEndPreceding=m),s.nCommonPreceding=g,0!==g&&(s.aCommonPreceding=c,s.bCommonPreceding=m),s.nCommonFollowing=E,0!==E&&(s.aCommonFollowing=P+1,s.bCommonFollowing=S+1);const f=$+1,u=S+E+1;return s.nChangeFollowing=n-1,n-1==e+i-f-u?(s.aStartFollowing=e,s.bStartFollowing=i):(s.aStartFollowing=f,s.bStartFollowing=u),!0}}}return!1},extendOverlappablePathsR=(n,o,e,t,i,l,g,a,c,m,s)=>{const d=i-e,f=i-t-(e-o),u=f-n,w=f+n;let C=r;const b=n<m?n:m;for(let r=0,m=n;r<=b;r+=1,m-=2){const b=0===r||r!==n&&c[r]<C,F=b?c[r]:C,P=b?F:F-1,S=d+P-m,E=countCommonItemsR(o,P-1,t,S-1,l),$=P-E;if(C=c[r],c[r]=$,u<=m&&m<=w){const r=(n+(m-f))/2;if(r<=a&&$-1<=g[r]){const r=S-E;if(s.nChangePreceding=n,n===$+r-o-t?(s.aEndPreceding=o,s.bEndPreceding=t):(s.aEndPreceding=$,s.bEndPreceding=r),s.nCommonPreceding=E,0!==E&&(s.aCommonPreceding=$,s.bCommonPreceding=r),s.nChangeFollowing=n-1,1===n)s.nCommonFollowing=0,s.aStartFollowing=e,s.bStartFollowing=i;else{const o=d+F-(b?m-1:m+1),r=countCommonItemsF(F,e,o,i,l);s.nCommonFollowing=r,0!==r&&(s.aCommonFollowing=F,s.bCommonFollowing=o);const t=F+r,g=o+r;n-1==e+i-t-g?(s.aStartFollowing=e,s.bStartFollowing=i):(s.aStartFollowing=t,s.bStartFollowing=g)}return!0}}}return!1},findSubsequences=(n,o,r,t,i,l,g,a,c,m)=>{if(i-t<r-o){if((l=!l)&&1===g.length){const{foundSubsequence:n,isCommon:o}=g[0];g[1]={foundSubsequence:(o,e,r)=>{n(o,r,e)},isCommon:(n,e)=>o(e,n)}}const n=o,e=r;o=t,r=i,t=n,i=e}const{foundSubsequence:s,isCommon:d}=g[l?1:0];((n,o,r,t,i,l,g,a,c)=>{const m=t-o,s=i-r,d=r-o,f=i-t,u=f-d;let w=d,C=d;if(g[0]=o-1,a[0]=r,u%2==0){const e=(n||u)/2,b=(d+f)/2;for(let n=1;n<=b;n+=1)if(w=extendPathsF(n,r,i,m,l,g,w),n<e)C=extendPathsR(n,o,t,s,l,a,C);else if(extendOverlappablePathsR(n,o,r,t,i,l,g,w,a,C,c))return}else{const e=((n||u)+1)/2,b=(d+f+1)/2;let F=1;for(w=extendPathsF(F,r,i,m,l,g,w),F+=1;F<=b;F+=1)if(C=extendPathsR(F-1,o,t,s,l,a,C),F<e)w=extendPathsF(F,r,i,m,l,g,w);else if(extendOverlappablePathsF(F,o,r,t,i,l,g,w,a,C,c))return}throw new Error(`${e}: no overlap aStart=${o} aEnd=${r} bStart=${t} bEnd=${i}`)})(n,o,r,t,i,d,a,c,m);const{nChangePreceding:f,aEndPreceding:u,bEndPreceding:w,nCommonPreceding:C,aCommonPreceding:b,bCommonPreceding:F,nCommonFollowing:P,aCommonFollowing:S,bCommonFollowing:E,nChangeFollowing:$,aStartFollowing:h,bStartFollowing:p}=m;o<u&&t<w&&findSubsequences(f,o,u,t,w,l,g,a,c,m),0!==C&&s(C,b,F),0!==P&&s(P,S,E),h<r&&p<i&&findSubsequences($,h,r,p,i,l,g,a,c,m)},validateLength=(n,o)=>{if("number"!=typeof o)throw new TypeError(`${e}: ${n} typeof ${typeof o} is not a number`);if(!Number.isSafeInteger(o))throw new RangeError(`${e}: ${n} value ${o} is not a safe integer`);if(o<0)throw new RangeError(`${e}: ${n} value ${o} is a negative integer`)},validateCallback=(n,o)=>{const r=typeof o;if("function"!==r)throw new TypeError(`${e}: ${n} typeof ${r} is not a function`)};return n}export{requireBuild as __require};
+//# sourceMappingURL=index.esm.js.map

package/dist/browser/node_modules/.pnpm/diff-sequences@29.6.3/node_modules/diff-sequences/build/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":["../../../../../../../../../../node_modules/.pnpm/diff-sequences@29.6.3/node_modules/diff-sequences/build/index.js"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nexports.default = diffSequence;\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n// This diff-sequences package implements the linear space variation in\n// An O(ND) Difference Algorithm and Its Variations by Eugene W. Myers\n\n// Relationship in notation between Myers paper and this package:\n// A is a\n// N is aLength, aEnd - aStart, and so on\n// x is aIndex, aFirst, aLast, and so on\n// B is b\n// M is bLength, bEnd - bStart, and so on\n// y is bIndex, bFirst, bLast, and so on\n// Δ = N - M is negative of baDeltaLength = bLength - aLength\n// D is d\n// k is kF\n// k + Δ is kF = kR - baDeltaLength\n// V is aIndexesF or aIndexesR (see comment below about Indexes type)\n// index intervals [1, N] and [1, M] are [0, aLength) and [0, bLength)\n// starting point in forward direction (0, 0) is (-1, -1)\n// starting point in reverse direction (N + 1, M + 1) is (aLength, bLength)\n\n// The “edit graph” for sequences a and b corresponds to items:\n// in a on the horizontal axis\n// in b on the vertical axis\n//\n// Given a-coordinate of a point in a diagonal, you can compute b-coordinate.\n//\n// Forward diagonals kF:\n// zero diagonal intersects top left corner\n// positive diagonals intersect top edge\n// negative diagonals insersect left edge\n//\n// Reverse diagonals kR:\n// zero diagonal intersects bottom right corner\n// positive diagonals intersect right edge\n// negative diagonals intersect bottom edge\n\n// The graph contains a directed acyclic graph of edges:\n// horizontal: delete an item from a\n// vertical: insert an item from b\n// diagonal: common item in a and b\n//\n// The algorithm solves dual problems in the graph analogy:\n// Find longest common subsequence: path with maximum number of diagonal edges\n// Find shortest edit script: path with minimum number of non-diagonal edges\n\n// Input callback function compares items at indexes in the sequences.\n\n// Output callback function receives the number of adjacent items\n// and starting indexes of each common subsequence.\n// Either original functions or wrapped to swap indexes if graph is transposed.\n// Indexes in sequence a of last point of forward or reverse paths in graph.\n// Myers algorithm indexes by diagonal k which for negative is bad deopt in V8.\n// This package indexes by iF and iR which are greater than or equal to zero.\n// and also updates the index arrays in place to cut memory in half.\n// kF = 2 * iF - d\n// kR = d - 2 * iR\n// Division of index intervals in sequences a and b at the middle change.\n// Invariant: intervals do not have common items at the start or end.\nconst pkg = 'diff-sequences'; // for error messages\nconst NOT_YET_SET = 0; // small int instead of undefined to avoid deopt in V8\n\n// Return the number of common items that follow in forward direction.\n// The length of what Myers paper calls a “snake” in a forward path.\nconst countCommonItemsF = (aIndex, aEnd, bIndex, bEnd, isCommon) => {\n  let nCommon = 0;\n  while (aIndex < aEnd && bIndex < bEnd && isCommon(aIndex, bIndex)) {\n    aIndex += 1;\n    bIndex += 1;\n    nCommon += 1;\n  }\n  return nCommon;\n};\n\n// Return the number of common items that precede in reverse direction.\n// The length of what Myers paper calls a “snake” in a reverse path.\nconst countCommonItemsR = (aStart, aIndex, bStart, bIndex, isCommon) => {\n  let nCommon = 0;\n  while (aStart <= aIndex && bStart <= bIndex && isCommon(aIndex, bIndex)) {\n    aIndex -= 1;\n    bIndex -= 1;\n    nCommon += 1;\n  }\n  return nCommon;\n};\n\n// A simple function to extend forward paths from (d - 1) to d changes\n// when forward and reverse paths cannot yet overlap.\nconst extendPathsF = (\n  d,\n  aEnd,\n  bEnd,\n  bF,\n  isCommon,\n  aIndexesF,\n  iMaxF // return the value because optimization might decrease it\n) => {\n  // Unroll the first iteration.\n  let iF = 0;\n  let kF = -d; // kF = 2 * iF - d\n  let aFirst = aIndexesF[iF]; // in first iteration always insert\n  let aIndexPrev1 = aFirst; // prev value of [iF - 1] in next iteration\n  aIndexesF[iF] += countCommonItemsF(\n    aFirst + 1,\n    aEnd,\n    bF + aFirst - kF + 1,\n    bEnd,\n    isCommon\n  );\n\n  // Optimization: skip diagonals in which paths cannot ever overlap.\n  const nF = d < iMaxF ? d : iMaxF;\n\n  // The diagonals kF are odd when d is odd and even when d is even.\n  for (iF += 1, kF += 2; iF <= nF; iF += 1, kF += 2) {\n    // To get first point of path segment, move one change in forward direction\n    // from last point of previous path segment in an adjacent diagonal.\n    // In last possible iteration when iF === d and kF === d always delete.\n    if (iF !== d && aIndexPrev1 < aIndexesF[iF]) {\n      aFirst = aIndexesF[iF]; // vertical to insert from b\n    } else {\n      aFirst = aIndexPrev1 + 1; // horizontal to delete from a\n\n      if (aEnd <= aFirst) {\n        // Optimization: delete moved past right of graph.\n        return iF - 1;\n      }\n    }\n\n    // To get last point of path segment, move along diagonal of common items.\n    aIndexPrev1 = aIndexesF[iF];\n    aIndexesF[iF] =\n      aFirst +\n      countCommonItemsF(aFirst + 1, aEnd, bF + aFirst - kF + 1, bEnd, isCommon);\n  }\n  return iMaxF;\n};\n\n// A simple function to extend reverse paths from (d - 1) to d changes\n// when reverse and forward paths cannot yet overlap.\nconst extendPathsR = (\n  d,\n  aStart,\n  bStart,\n  bR,\n  isCommon,\n  aIndexesR,\n  iMaxR // return the value because optimization might decrease it\n) => {\n  // Unroll the first iteration.\n  let iR = 0;\n  let kR = d; // kR = d - 2 * iR\n  let aFirst = aIndexesR[iR]; // in first iteration always insert\n  let aIndexPrev1 = aFirst; // prev value of [iR - 1] in next iteration\n  aIndexesR[iR] -= countCommonItemsR(\n    aStart,\n    aFirst - 1,\n    bStart,\n    bR + aFirst - kR - 1,\n    isCommon\n  );\n\n  // Optimization: skip diagonals in which paths cannot ever overlap.\n  const nR = d < iMaxR ? d : iMaxR;\n\n  // The diagonals kR are odd when d is odd and even when d is even.\n  for (iR += 1, kR -= 2; iR <= nR; iR += 1, kR -= 2) {\n    // To get first point of path segment, move one change in reverse direction\n    // from last point of previous path segment in an adjacent diagonal.\n    // In last possible iteration when iR === d and kR === -d always delete.\n    if (iR !== d && aIndexesR[iR] < aIndexPrev1) {\n      aFirst = aIndexesR[iR]; // vertical to insert from b\n    } else {\n      aFirst = aIndexPrev1 - 1; // horizontal to delete from a\n\n      if (aFirst < aStart) {\n        // Optimization: delete moved past left of graph.\n        return iR - 1;\n      }\n    }\n\n    // To get last point of path segment, move along diagonal of common items.\n    aIndexPrev1 = aIndexesR[iR];\n    aIndexesR[iR] =\n      aFirst -\n      countCommonItemsR(\n        aStart,\n        aFirst - 1,\n        bStart,\n        bR + aFirst - kR - 1,\n        isCommon\n      );\n  }\n  return iMaxR;\n};\n\n// A complete function to extend forward paths from (d - 1) to d changes.\n// Return true if a path overlaps reverse path of (d - 1) changes in its diagonal.\nconst extendOverlappablePathsF = (\n  d,\n  aStart,\n  aEnd,\n  bStart,\n  bEnd,\n  isCommon,\n  aIndexesF,\n  iMaxF,\n  aIndexesR,\n  iMaxR,\n  division // update prop values if return true\n) => {\n  const bF = bStart - aStart; // bIndex = bF + aIndex - kF\n  const aLength = aEnd - aStart;\n  const bLength = bEnd - bStart;\n  const baDeltaLength = bLength - aLength; // kF = kR - baDeltaLength\n\n  // Range of diagonals in which forward and reverse paths might overlap.\n  const kMinOverlapF = -baDeltaLength - (d - 1); // -(d - 1) <= kR\n  const kMaxOverlapF = -baDeltaLength + (d - 1); // kR <= (d - 1)\n\n  let aIndexPrev1 = NOT_YET_SET; // prev value of [iF - 1] in next iteration\n\n  // Optimization: skip diagonals in which paths cannot ever overlap.\n  const nF = d < iMaxF ? d : iMaxF;\n\n  // The diagonals kF = 2 * iF - d are odd when d is odd and even when d is even.\n  for (let iF = 0, kF = -d; iF <= nF; iF += 1, kF += 2) {\n    // To get first point of path segment, move one change in forward direction\n    // from last point of previous path segment in an adjacent diagonal.\n    // In first iteration when iF === 0 and kF === -d always insert.\n    // In last possible iteration when iF === d and kF === d always delete.\n    const insert = iF === 0 || (iF !== d && aIndexPrev1 < aIndexesF[iF]);\n    const aLastPrev = insert ? aIndexesF[iF] : aIndexPrev1;\n    const aFirst = insert\n      ? aLastPrev // vertical to insert from b\n      : aLastPrev + 1; // horizontal to delete from a\n\n    // To get last point of path segment, move along diagonal of common items.\n    const bFirst = bF + aFirst - kF;\n    const nCommonF = countCommonItemsF(\n      aFirst + 1,\n      aEnd,\n      bFirst + 1,\n      bEnd,\n      isCommon\n    );\n    const aLast = aFirst + nCommonF;\n    aIndexPrev1 = aIndexesF[iF];\n    aIndexesF[iF] = aLast;\n    if (kMinOverlapF <= kF && kF <= kMaxOverlapF) {\n      // Solve for iR of reverse path with (d - 1) changes in diagonal kF:\n      // kR = kF + baDeltaLength\n      // kR = (d - 1) - 2 * iR\n      const iR = (d - 1 - (kF + baDeltaLength)) / 2;\n\n      // If this forward path overlaps the reverse path in this diagonal,\n      // then this is the middle change of the index intervals.\n      if (iR <= iMaxR && aIndexesR[iR] - 1 <= aLast) {\n        // Unlike the Myers algorithm which finds only the middle “snake”\n        // this package can find two common subsequences per division.\n        // Last point of previous path segment is on an adjacent diagonal.\n        const bLastPrev = bF + aLastPrev - (insert ? kF + 1 : kF - 1);\n\n        // Because of invariant that intervals preceding the middle change\n        // cannot have common items at the end,\n        // move in reverse direction along a diagonal of common items.\n        const nCommonR = countCommonItemsR(\n          aStart,\n          aLastPrev,\n          bStart,\n          bLastPrev,\n          isCommon\n        );\n        const aIndexPrevFirst = aLastPrev - nCommonR;\n        const bIndexPrevFirst = bLastPrev - nCommonR;\n        const aEndPreceding = aIndexPrevFirst + 1;\n        const bEndPreceding = bIndexPrevFirst + 1;\n        division.nChangePreceding = d - 1;\n        if (d - 1 === aEndPreceding + bEndPreceding - aStart - bStart) {\n          // Optimization: number of preceding changes in forward direction\n          // is equal to number of items in preceding interval,\n          // therefore it cannot contain any common items.\n          division.aEndPreceding = aStart;\n          division.bEndPreceding = bStart;\n        } else {\n          division.aEndPreceding = aEndPreceding;\n          division.bEndPreceding = bEndPreceding;\n        }\n        division.nCommonPreceding = nCommonR;\n        if (nCommonR !== 0) {\n          division.aCommonPreceding = aEndPreceding;\n          division.bCommonPreceding = bEndPreceding;\n        }\n        division.nCommonFollowing = nCommonF;\n        if (nCommonF !== 0) {\n          division.aCommonFollowing = aFirst + 1;\n          division.bCommonFollowing = bFirst + 1;\n        }\n        const aStartFollowing = aLast + 1;\n        const bStartFollowing = bFirst + nCommonF + 1;\n        division.nChangeFollowing = d - 1;\n        if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {\n          // Optimization: number of changes in reverse direction\n          // is equal to number of items in following interval,\n          // therefore it cannot contain any common items.\n          division.aStartFollowing = aEnd;\n          division.bStartFollowing = bEnd;\n        } else {\n          division.aStartFollowing = aStartFollowing;\n          division.bStartFollowing = bStartFollowing;\n        }\n        return true;\n      }\n    }\n  }\n  return false;\n};\n\n// A complete function to extend reverse paths from (d - 1) to d changes.\n// Return true if a path overlaps forward path of d changes in its diagonal.\nconst extendOverlappablePathsR = (\n  d,\n  aStart,\n  aEnd,\n  bStart,\n  bEnd,\n  isCommon,\n  aIndexesF,\n  iMaxF,\n  aIndexesR,\n  iMaxR,\n  division // update prop values if return true\n) => {\n  const bR = bEnd - aEnd; // bIndex = bR + aIndex - kR\n  const aLength = aEnd - aStart;\n  const bLength = bEnd - bStart;\n  const baDeltaLength = bLength - aLength; // kR = kF + baDeltaLength\n\n  // Range of diagonals in which forward and reverse paths might overlap.\n  const kMinOverlapR = baDeltaLength - d; // -d <= kF\n  const kMaxOverlapR = baDeltaLength + d; // kF <= d\n\n  let aIndexPrev1 = NOT_YET_SET; // prev value of [iR - 1] in next iteration\n\n  // Optimization: skip diagonals in which paths cannot ever overlap.\n  const nR = d < iMaxR ? d : iMaxR;\n\n  // The diagonals kR = d - 2 * iR are odd when d is odd and even when d is even.\n  for (let iR = 0, kR = d; iR <= nR; iR += 1, kR -= 2) {\n    // To get first point of path segment, move one change in reverse direction\n    // from last point of previous path segment in an adjacent diagonal.\n    // In first iteration when iR === 0 and kR === d always insert.\n    // In last possible iteration when iR === d and kR === -d always delete.\n    const insert = iR === 0 || (iR !== d && aIndexesR[iR] < aIndexPrev1);\n    const aLastPrev = insert ? aIndexesR[iR] : aIndexPrev1;\n    const aFirst = insert\n      ? aLastPrev // vertical to insert from b\n      : aLastPrev - 1; // horizontal to delete from a\n\n    // To get last point of path segment, move along diagonal of common items.\n    const bFirst = bR + aFirst - kR;\n    const nCommonR = countCommonItemsR(\n      aStart,\n      aFirst - 1,\n      bStart,\n      bFirst - 1,\n      isCommon\n    );\n    const aLast = aFirst - nCommonR;\n    aIndexPrev1 = aIndexesR[iR];\n    aIndexesR[iR] = aLast;\n    if (kMinOverlapR <= kR && kR <= kMaxOverlapR) {\n      // Solve for iF of forward path with d changes in diagonal kR:\n      // kF = kR - baDeltaLength\n      // kF = 2 * iF - d\n      const iF = (d + (kR - baDeltaLength)) / 2;\n\n      // If this reverse path overlaps the forward path in this diagonal,\n      // then this is a middle change of the index intervals.\n      if (iF <= iMaxF && aLast - 1 <= aIndexesF[iF]) {\n        const bLast = bFirst - nCommonR;\n        division.nChangePreceding = d;\n        if (d === aLast + bLast - aStart - bStart) {\n          // Optimization: number of changes in reverse direction\n          // is equal to number of items in preceding interval,\n          // therefore it cannot contain any common items.\n          division.aEndPreceding = aStart;\n          division.bEndPreceding = bStart;\n        } else {\n          division.aEndPreceding = aLast;\n          division.bEndPreceding = bLast;\n        }\n        division.nCommonPreceding = nCommonR;\n        if (nCommonR !== 0) {\n          // The last point of reverse path segment is start of common subsequence.\n          division.aCommonPreceding = aLast;\n          division.bCommonPreceding = bLast;\n        }\n        division.nChangeFollowing = d - 1;\n        if (d === 1) {\n          // There is no previous path segment.\n          division.nCommonFollowing = 0;\n          division.aStartFollowing = aEnd;\n          division.bStartFollowing = bEnd;\n        } else {\n          // Unlike the Myers algorithm which finds only the middle “snake”\n          // this package can find two common subsequences per division.\n          // Last point of previous path segment is on an adjacent diagonal.\n          const bLastPrev = bR + aLastPrev - (insert ? kR - 1 : kR + 1);\n\n          // Because of invariant that intervals following the middle change\n          // cannot have common items at the start,\n          // move in forward direction along a diagonal of common items.\n          const nCommonF = countCommonItemsF(\n            aLastPrev,\n            aEnd,\n            bLastPrev,\n            bEnd,\n            isCommon\n          );\n          division.nCommonFollowing = nCommonF;\n          if (nCommonF !== 0) {\n            // The last point of reverse path segment is start of common subsequence.\n            division.aCommonFollowing = aLastPrev;\n            division.bCommonFollowing = bLastPrev;\n          }\n          const aStartFollowing = aLastPrev + nCommonF; // aFirstPrev\n          const bStartFollowing = bLastPrev + nCommonF; // bFirstPrev\n\n          if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {\n            // Optimization: number of changes in forward direction\n            // is equal to number of items in following interval,\n            // therefore it cannot contain any common items.\n            division.aStartFollowing = aEnd;\n            division.bStartFollowing = bEnd;\n          } else {\n            division.aStartFollowing = aStartFollowing;\n            division.bStartFollowing = bStartFollowing;\n          }\n        }\n        return true;\n      }\n    }\n  }\n  return false;\n};\n\n// Given index intervals and input function to compare items at indexes,\n// divide at the middle change.\n//\n// DO NOT CALL if start === end, because interval cannot contain common items\n// and because this function will throw the “no overlap” error.\nconst divide = (\n  nChange,\n  aStart,\n  aEnd,\n  bStart,\n  bEnd,\n  isCommon,\n  aIndexesF,\n  aIndexesR,\n  division // output\n) => {\n  const bF = bStart - aStart; // bIndex = bF + aIndex - kF\n  const bR = bEnd - aEnd; // bIndex = bR + aIndex - kR\n  const aLength = aEnd - aStart;\n  const bLength = bEnd - bStart;\n\n  // Because graph has square or portrait orientation,\n  // length difference is minimum number of items to insert from b.\n  // Corresponding forward and reverse diagonals in graph\n  // depend on length difference of the sequences:\n  // kF = kR - baDeltaLength\n  // kR = kF + baDeltaLength\n  const baDeltaLength = bLength - aLength;\n\n  // Optimization: max diagonal in graph intersects corner of shorter side.\n  let iMaxF = aLength;\n  let iMaxR = aLength;\n\n  // Initialize no changes yet in forward or reverse direction:\n  aIndexesF[0] = aStart - 1; // at open start of interval, outside closed start\n  aIndexesR[0] = aEnd; // at open end of interval\n\n  if (baDeltaLength % 2 === 0) {\n    // The number of changes in paths is 2 * d if length difference is even.\n    const dMin = (nChange || baDeltaLength) / 2;\n    const dMax = (aLength + bLength) / 2;\n    for (let d = 1; d <= dMax; d += 1) {\n      iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);\n      if (d < dMin) {\n        iMaxR = extendPathsR(d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR);\n      } else if (\n        // If a reverse path overlaps a forward path in the same diagonal,\n        // return a division of the index intervals at the middle change.\n        extendOverlappablePathsR(\n          d,\n          aStart,\n          aEnd,\n          bStart,\n          bEnd,\n          isCommon,\n          aIndexesF,\n          iMaxF,\n          aIndexesR,\n          iMaxR,\n          division\n        )\n      ) {\n        return;\n      }\n    }\n  } else {\n    // The number of changes in paths is 2 * d - 1 if length difference is odd.\n    const dMin = ((nChange || baDeltaLength) + 1) / 2;\n    const dMax = (aLength + bLength + 1) / 2;\n\n    // Unroll first half iteration so loop extends the relevant pairs of paths.\n    // Because of invariant that intervals have no common items at start or end,\n    // and limitation not to call divide with empty intervals,\n    // therefore it cannot be called if a forward path with one change\n    // would overlap a reverse path with no changes, even if dMin === 1.\n    let d = 1;\n    iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);\n    for (d += 1; d <= dMax; d += 1) {\n      iMaxR = extendPathsR(\n        d - 1,\n        aStart,\n        bStart,\n        bR,\n        isCommon,\n        aIndexesR,\n        iMaxR\n      );\n      if (d < dMin) {\n        iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);\n      } else if (\n        // If a forward path overlaps a reverse path in the same diagonal,\n        // return a division of the index intervals at the middle change.\n        extendOverlappablePathsF(\n          d,\n          aStart,\n          aEnd,\n          bStart,\n          bEnd,\n          isCommon,\n          aIndexesF,\n          iMaxF,\n          aIndexesR,\n          iMaxR,\n          division\n        )\n      ) {\n        return;\n      }\n    }\n  }\n\n  /* istanbul ignore next */\n  throw new Error(\n    `${pkg}: no overlap aStart=${aStart} aEnd=${aEnd} bStart=${bStart} bEnd=${bEnd}`\n  );\n};\n\n// Given index intervals and input function to compare items at indexes,\n// return by output function the number of adjacent items and starting indexes\n// of each common subsequence. Divide and conquer with only linear space.\n//\n// The index intervals are half open [start, end) like array slice method.\n// DO NOT CALL if start === end, because interval cannot contain common items\n// and because divide function will throw the “no overlap” error.\nconst findSubsequences = (\n  nChange,\n  aStart,\n  aEnd,\n  bStart,\n  bEnd,\n  transposed,\n  callbacks,\n  aIndexesF,\n  aIndexesR,\n  division // temporary memory, not input nor output\n) => {\n  if (bEnd - bStart < aEnd - aStart) {\n    // Transpose graph so it has portrait instead of landscape orientation.\n    // Always compare shorter to longer sequence for consistency and optimization.\n    transposed = !transposed;\n    if (transposed && callbacks.length === 1) {\n      // Lazily wrap callback functions to swap args if graph is transposed.\n      const {foundSubsequence, isCommon} = callbacks[0];\n      callbacks[1] = {\n        foundSubsequence: (nCommon, bCommon, aCommon) => {\n          foundSubsequence(nCommon, aCommon, bCommon);\n        },\n        isCommon: (bIndex, aIndex) => isCommon(aIndex, bIndex)\n      };\n    }\n    const tStart = aStart;\n    const tEnd = aEnd;\n    aStart = bStart;\n    aEnd = bEnd;\n    bStart = tStart;\n    bEnd = tEnd;\n  }\n  const {foundSubsequence, isCommon} = callbacks[transposed ? 1 : 0];\n\n  // Divide the index intervals at the middle change.\n  divide(\n    nChange,\n    aStart,\n    aEnd,\n    bStart,\n    bEnd,\n    isCommon,\n    aIndexesF,\n    aIndexesR,\n    division\n  );\n  const {\n    nChangePreceding,\n    aEndPreceding,\n    bEndPreceding,\n    nCommonPreceding,\n    aCommonPreceding,\n    bCommonPreceding,\n    nCommonFollowing,\n    aCommonFollowing,\n    bCommonFollowing,\n    nChangeFollowing,\n    aStartFollowing,\n    bStartFollowing\n  } = division;\n\n  // Unless either index interval is empty, they might contain common items.\n  if (aStart < aEndPreceding && bStart < bEndPreceding) {\n    // Recursely find and return common subsequences preceding the division.\n    findSubsequences(\n      nChangePreceding,\n      aStart,\n      aEndPreceding,\n      bStart,\n      bEndPreceding,\n      transposed,\n      callbacks,\n      aIndexesF,\n      aIndexesR,\n      division\n    );\n  }\n\n  // Return common subsequences that are adjacent to the middle change.\n  if (nCommonPreceding !== 0) {\n    foundSubsequence(nCommonPreceding, aCommonPreceding, bCommonPreceding);\n  }\n  if (nCommonFollowing !== 0) {\n    foundSubsequence(nCommonFollowing, aCommonFollowing, bCommonFollowing);\n  }\n\n  // Unless either index interval is empty, they might contain common items.\n  if (aStartFollowing < aEnd && bStartFollowing < bEnd) {\n    // Recursely find and return common subsequences following the division.\n    findSubsequences(\n      nChangeFollowing,\n      aStartFollowing,\n      aEnd,\n      bStartFollowing,\n      bEnd,\n      transposed,\n      callbacks,\n      aIndexesF,\n      aIndexesR,\n      division\n    );\n  }\n};\nconst validateLength = (name, arg) => {\n  if (typeof arg !== 'number') {\n    throw new TypeError(`${pkg}: ${name} typeof ${typeof arg} is not a number`);\n  }\n  if (!Number.isSafeInteger(arg)) {\n    throw new RangeError(`${pkg}: ${name} value ${arg} is not a safe integer`);\n  }\n  if (arg < 0) {\n    throw new RangeError(`${pkg}: ${name} value ${arg} is a negative integer`);\n  }\n};\nconst validateCallback = (name, arg) => {\n  const type = typeof arg;\n  if (type !== 'function') {\n    throw new TypeError(`${pkg}: ${name} typeof ${type} is not a function`);\n  }\n};\n\n// Compare items in two sequences to find a longest common subsequence.\n// Given lengths of sequences and input function to compare items at indexes,\n// return by output function the number of adjacent items and starting indexes\n// of each common subsequence.\nfunction diffSequence(aLength, bLength, isCommon, foundSubsequence) {\n  validateLength('aLength', aLength);\n  validateLength('bLength', bLength);\n  validateCallback('isCommon', isCommon);\n  validateCallback('foundSubsequence', foundSubsequence);\n\n  // Count common items from the start in the forward direction.\n  const nCommonF = countCommonItemsF(0, aLength, 0, bLength, isCommon);\n  if (nCommonF !== 0) {\n    foundSubsequence(nCommonF, 0, 0);\n  }\n\n  // Unless both sequences consist of common items only,\n  // find common items in the half-trimmed index intervals.\n  if (aLength !== nCommonF || bLength !== nCommonF) {\n    // Invariant: intervals do not have common items at the start.\n    // The start of an index interval is closed like array slice method.\n    const aStart = nCommonF;\n    const bStart = nCommonF;\n\n    // Count common items from the end in the reverse direction.\n    const nCommonR = countCommonItemsR(\n      aStart,\n      aLength - 1,\n      bStart,\n      bLength - 1,\n      isCommon\n    );\n\n    // Invariant: intervals do not have common items at the end.\n    // The end of an index interval is open like array slice method.\n    const aEnd = aLength - nCommonR;\n    const bEnd = bLength - nCommonR;\n\n    // Unless one sequence consists of common items only,\n    // therefore the other trimmed index interval consists of changes only,\n    // find common items in the trimmed index intervals.\n    const nCommonFR = nCommonF + nCommonR;\n    if (aLength !== nCommonFR && bLength !== nCommonFR) {\n      const nChange = 0; // number of change items is not yet known\n      const transposed = false; // call the original unwrapped functions\n      const callbacks = [\n        {\n          foundSubsequence,\n          isCommon\n        }\n      ];\n\n      // Indexes in sequence a of last points in furthest reaching paths\n      // from outside the start at top left in the forward direction:\n      const aIndexesF = [NOT_YET_SET];\n      // from the end at bottom right in the reverse direction:\n      const aIndexesR = [NOT_YET_SET];\n\n      // Initialize one object as output of all calls to divide function.\n      const division = {\n        aCommonFollowing: NOT_YET_SET,\n        aCommonPreceding: NOT_YET_SET,\n        aEndPreceding: NOT_YET_SET,\n        aStartFollowing: NOT_YET_SET,\n        bCommonFollowing: NOT_YET_SET,\n        bCommonPreceding: NOT_YET_SET,\n        bEndPreceding: NOT_YET_SET,\n        bStartFollowing: NOT_YET_SET,\n        nChangeFollowing: NOT_YET_SET,\n        nChangePreceding: NOT_YET_SET,\n        nCommonFollowing: NOT_YET_SET,\n        nCommonPreceding: NOT_YET_SET\n      };\n\n      // Find and return common subsequences in the trimmed index intervals.\n      findSubsequences(\n        nChange,\n        aStart,\n        aEnd,\n        bStart,\n        bEnd,\n        transposed,\n        callbacks,\n        aIndexesF,\n        aIndexesR,\n        division\n      );\n    }\n    if (nCommonR !== 0) {\n      foundSubsequence(nCommonR, aEnd, bEnd);\n    }\n  }\n}\n"],"names":["Object","defineProperty","build","value","default","diffSequence","aLength","bLength","isCommon","foundSubsequence","validateLength","validateCallback","nCommonF","countCommonItemsF","aStart","bStart","nCommonR","countCommonItemsR","aEnd","bEnd","nCommonFR","findSubsequences","NOT_YET_SET","aCommonFollowing","aCommonPreceding","aEndPreceding","aStartFollowing","bCommonFollowing","bCommonPreceding","bEndPreceding","bStartFollowing","nChangeFollowing","nChangePreceding","nCommonFollowing","nCommonPreceding","pkg","aIndex","bIndex","nCommon","extendPathsF","d","bF","aIndexesF","iMaxF","iF","kF","aFirst","aIndexPrev1","nF","extendPathsR","bR","aIndexesR","iMaxR","iR","kR","nR","extendOverlappablePathsF","division","baDeltaLength","kMinOverlapF","kMaxOverlapF","insert","aLastPrev","bFirst","aLast","bLastPrev","extendOverlappablePathsR","kMinOverlapR","kMaxOverlapR","bLast","nChange","transposed","callbacks","length","bCommon","aCommon","tStart","tEnd","dMin","dMax","Error","divide","name","arg","TypeError","Number","isSafeInteger","RangeError","type"],"mappings":"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","x_google_ignoreList":[0]}