{"version":3,"file":"index-DTq0E2HE.js","sources":["../../node_modules/ohash/dist/index.mjs"],"sourcesContent":["const defaults = Object.freeze({\n  ignoreUnknown: false,\n  respectType: false,\n  respectFunctionNames: false,\n  respectFunctionProperties: false,\n  unorderedObjects: true,\n  unorderedArrays: false,\n  unorderedSets: false,\n  excludeKeys: void 0,\n  excludeValues: void 0,\n  replacer: void 0\n});\nfunction objectHash(object, options) {\n  if (options) {\n    options = { ...defaults, ...options };\n  } else {\n    options = defaults;\n  }\n  const hasher = createHasher(options);\n  hasher.dispatch(object);\n  return hasher.toString();\n}\nconst defaultPrototypesKeys = Object.freeze([\n  \"prototype\",\n  \"__proto__\",\n  \"constructor\"\n]);\nfunction createHasher(options) {\n  let buff = \"\";\n  let context = /* @__PURE__ */ new Map();\n  const write = (str) => {\n    buff += str;\n  };\n  return {\n    toString() {\n      return buff;\n    },\n    getContext() {\n      return context;\n    },\n    dispatch(value) {\n      if (options.replacer) {\n        value = options.replacer(value);\n      }\n      const type = value === null ? \"null\" : typeof value;\n      return this[type](value);\n    },\n    object(object) {\n      if (object && typeof object.toJSON === \"function\") {\n        return this.object(object.toJSON());\n      }\n      const objString = Object.prototype.toString.call(object);\n      let objType = \"\";\n      const objectLength = objString.length;\n      if (objectLength < 10) {\n        objType = \"unknown:[\" + objString + \"]\";\n      } else {\n        objType = objString.slice(8, objectLength - 1);\n      }\n      objType = objType.toLowerCase();\n      let objectNumber = null;\n      if ((objectNumber = context.get(object)) === void 0) {\n        context.set(object, context.size);\n      } else {\n        return this.dispatch(\"[CIRCULAR:\" + objectNumber + \"]\");\n      }\n      if (typeof Buffer !== \"undefined\" && Buffer.isBuffer && Buffer.isBuffer(object)) {\n        write(\"buffer:\");\n        return write(object.toString(\"utf8\"));\n      }\n      if (objType !== \"object\" && objType !== \"function\" && objType !== \"asyncfunction\") {\n        if (this[objType]) {\n          this[objType](object);\n        } else if (!options.ignoreUnknown) {\n          this.unkown(object, objType);\n        }\n      } else {\n        let keys = Object.keys(object);\n        if (options.unorderedObjects) {\n          keys = keys.sort();\n        }\n        let extraKeys = [];\n        if (options.respectType !== false && !isNativeFunction(object)) {\n          extraKeys = defaultPrototypesKeys;\n        }\n        if (options.excludeKeys) {\n          keys = keys.filter((key) => {\n            return !options.excludeKeys(key);\n          });\n          extraKeys = extraKeys.filter((key) => {\n            return !options.excludeKeys(key);\n          });\n        }\n        write(\"object:\" + (keys.length + extraKeys.length) + \":\");\n        const dispatchForKey = (key) => {\n          this.dispatch(key);\n          write(\":\");\n          if (!options.excludeValues) {\n            this.dispatch(object[key]);\n          }\n          write(\",\");\n        };\n        for (const key of keys) {\n          dispatchForKey(key);\n        }\n        for (const key of extraKeys) {\n          dispatchForKey(key);\n        }\n      }\n    },\n    array(arr, unordered) {\n      unordered = unordered === void 0 ? options.unorderedArrays !== false : unordered;\n      write(\"array:\" + arr.length + \":\");\n      if (!unordered || arr.length <= 1) {\n        for (const entry of arr) {\n          this.dispatch(entry);\n        }\n        return;\n      }\n      const contextAdditions = /* @__PURE__ */ new Map();\n      const entries = arr.map((entry) => {\n        const hasher = createHasher(options);\n        hasher.dispatch(entry);\n        for (const [key, value] of hasher.getContext()) {\n          contextAdditions.set(key, value);\n        }\n        return hasher.toString();\n      });\n      context = contextAdditions;\n      entries.sort();\n      return this.array(entries, false);\n    },\n    date(date) {\n      return write(\"date:\" + date.toJSON());\n    },\n    symbol(sym) {\n      return write(\"symbol:\" + sym.toString());\n    },\n    unkown(value, type) {\n      write(type);\n      if (!value) {\n        return;\n      }\n      write(\":\");\n      if (value && typeof value.entries === \"function\") {\n        return this.array(\n          Array.from(value.entries()),\n          true\n          /* ordered */\n        );\n      }\n    },\n    error(err) {\n      return write(\"error:\" + err.toString());\n    },\n    boolean(bool) {\n      return write(\"bool:\" + bool);\n    },\n    string(string) {\n      write(\"string:\" + string.length + \":\");\n      write(string);\n    },\n    function(fn) {\n      write(\"fn:\");\n      if (isNativeFunction(fn)) {\n        this.dispatch(\"[native]\");\n      } else {\n        this.dispatch(fn.toString());\n      }\n      if (options.respectFunctionNames !== false) {\n        this.dispatch(\"function-name:\" + String(fn.name));\n      }\n      if (options.respectFunctionProperties) {\n        this.object(fn);\n      }\n    },\n    number(number) {\n      return write(\"number:\" + number);\n    },\n    xml(xml) {\n      return write(\"xml:\" + xml.toString());\n    },\n    null() {\n      return write(\"Null\");\n    },\n    undefined() {\n      return write(\"Undefined\");\n    },\n    regexp(regex) {\n      return write(\"regex:\" + regex.toString());\n    },\n    uint8array(arr) {\n      write(\"uint8array:\");\n      return this.dispatch(Array.prototype.slice.call(arr));\n    },\n    uint8clampedarray(arr) {\n      write(\"uint8clampedarray:\");\n      return this.dispatch(Array.prototype.slice.call(arr));\n    },\n    int8array(arr) {\n      write(\"int8array:\");\n      return this.dispatch(Array.prototype.slice.call(arr));\n    },\n    uint16array(arr) {\n      write(\"uint16array:\");\n      return this.dispatch(Array.prototype.slice.call(arr));\n    },\n    int16array(arr) {\n      write(\"int16array:\");\n      return this.dispatch(Array.prototype.slice.call(arr));\n    },\n    uint32array(arr) {\n      write(\"uint32array:\");\n      return this.dispatch(Array.prototype.slice.call(arr));\n    },\n    int32array(arr) {\n      write(\"int32array:\");\n      return this.dispatch(Array.prototype.slice.call(arr));\n    },\n    float32array(arr) {\n      write(\"float32array:\");\n      return this.dispatch(Array.prototype.slice.call(arr));\n    },\n    float64array(arr) {\n      write(\"float64array:\");\n      return this.dispatch(Array.prototype.slice.call(arr));\n    },\n    arraybuffer(arr) {\n      write(\"arraybuffer:\");\n      return this.dispatch(new Uint8Array(arr));\n    },\n    url(url) {\n      return write(\"url:\" + url.toString());\n    },\n    map(map) {\n      write(\"map:\");\n      const arr = [...map];\n      return this.array(arr, options.unorderedSets !== false);\n    },\n    set(set) {\n      write(\"set:\");\n      const arr = [...set];\n      return this.array(arr, options.unorderedSets !== false);\n    },\n    file(file) {\n      write(\"file:\");\n      return this.dispatch([file.name, file.size, file.type, file.lastModfied]);\n    },\n    blob() {\n      if (options.ignoreUnknown) {\n        return write(\"[blob]\");\n      }\n      throw new Error(\n        'Hashing Blob objects is currently not supported\\nUse \"options.replacer\" or \"options.ignoreUnknown\"\\n'\n      );\n    },\n    domwindow() {\n      return write(\"domwindow\");\n    },\n    bigint(number) {\n      return write(\"bigint:\" + number.toString());\n    },\n    /* Node.js standard native objects */\n    process() {\n      return write(\"process\");\n    },\n    timer() {\n      return write(\"timer\");\n    },\n    pipe() {\n      return write(\"pipe\");\n    },\n    tcp() {\n      return write(\"tcp\");\n    },\n    udp() {\n      return write(\"udp\");\n    },\n    tty() {\n      return write(\"tty\");\n    },\n    statwatcher() {\n      return write(\"statwatcher\");\n    },\n    securecontext() {\n      return write(\"securecontext\");\n    },\n    connection() {\n      return write(\"connection\");\n    },\n    zlib() {\n      return write(\"zlib\");\n    },\n    context() {\n      return write(\"context\");\n    },\n    nodescript() {\n      return write(\"nodescript\");\n    },\n    httpparser() {\n      return write(\"httpparser\");\n    },\n    dataview() {\n      return write(\"dataview\");\n    },\n    signal() {\n      return write(\"signal\");\n    },\n    fsevent() {\n      return write(\"fsevent\");\n    },\n    tlswrap() {\n      return write(\"tlswrap\");\n    }\n  };\n}\nconst nativeFunc = \"[native code] }\";\nconst nativeFuncLength = nativeFunc.length;\nfunction isNativeFunction(f) {\n  if (typeof f !== \"function\") {\n    return false;\n  }\n  return Function.prototype.toString.call(f).slice(-nativeFuncLength) === nativeFunc;\n}\n\nvar __defProp$1 = Object.defineProperty;\nvar __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __publicField$1 = (obj, key, value) => {\n  __defNormalProp$1(obj, typeof key !== \"symbol\" ? key + \"\" : key, value);\n  return value;\n};\nclass WordArray {\n  constructor(words, sigBytes) {\n    __publicField$1(this, \"words\");\n    __publicField$1(this, \"sigBytes\");\n    words = this.words = words || [];\n    this.sigBytes = sigBytes === void 0 ? words.length * 4 : sigBytes;\n  }\n  toString(encoder) {\n    return (encoder || Hex).stringify(this);\n  }\n  concat(wordArray) {\n    this.clamp();\n    if (this.sigBytes % 4) {\n      for (let i = 0; i < wordArray.sigBytes; i++) {\n        const thatByte = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;\n        this.words[this.sigBytes + i >>> 2] |= thatByte << 24 - (this.sigBytes + i) % 4 * 8;\n      }\n    } else {\n      for (let j = 0; j < wordArray.sigBytes; j += 4) {\n        this.words[this.sigBytes + j >>> 2] = wordArray.words[j >>> 2];\n      }\n    }\n    this.sigBytes += wordArray.sigBytes;\n    return this;\n  }\n  clamp() {\n    this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8;\n    this.words.length = Math.ceil(this.sigBytes / 4);\n  }\n  clone() {\n    return new WordArray([...this.words]);\n  }\n}\nconst Hex = {\n  stringify(wordArray) {\n    const hexChars = [];\n    for (let i = 0; i < wordArray.sigBytes; i++) {\n      const bite = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;\n      hexChars.push((bite >>> 4).toString(16), (bite & 15).toString(16));\n    }\n    return hexChars.join(\"\");\n  }\n};\nconst Base64 = {\n  stringify(wordArray) {\n    const keyStr = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\";\n    const base64Chars = [];\n    for (let i = 0; i < wordArray.sigBytes; i += 3) {\n      const byte1 = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;\n      const byte2 = wordArray.words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;\n      const byte3 = wordArray.words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;\n      const triplet = byte1 << 16 | byte2 << 8 | byte3;\n      for (let j = 0; j < 4 && i * 8 + j * 6 < wordArray.sigBytes * 8; j++) {\n        base64Chars.push(keyStr.charAt(triplet >>> 6 * (3 - j) & 63));\n      }\n    }\n    return base64Chars.join(\"\");\n  }\n};\nconst Latin1 = {\n  parse(latin1Str) {\n    const latin1StrLength = latin1Str.length;\n    const words = [];\n    for (let i = 0; i < latin1StrLength; i++) {\n      words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;\n    }\n    return new WordArray(words, latin1StrLength);\n  }\n};\nconst Utf8 = {\n  parse(utf8Str) {\n    return Latin1.parse(unescape(encodeURIComponent(utf8Str)));\n  }\n};\nclass BufferedBlockAlgorithm {\n  constructor() {\n    __publicField$1(this, \"_data\", new WordArray());\n    __publicField$1(this, \"_nDataBytes\", 0);\n    __publicField$1(this, \"_minBufferSize\", 0);\n    __publicField$1(this, \"blockSize\", 512 / 32);\n  }\n  reset() {\n    this._data = new WordArray();\n    this._nDataBytes = 0;\n  }\n  _append(data) {\n    if (typeof data === \"string\") {\n      data = Utf8.parse(data);\n    }\n    this._data.concat(data);\n    this._nDataBytes += data.sigBytes;\n  }\n  _doProcessBlock(_dataWords, _offset) {\n  }\n  _process(doFlush) {\n    let processedWords;\n    let nBlocksReady = this._data.sigBytes / (this.blockSize * 4);\n    if (doFlush) {\n      nBlocksReady = Math.ceil(nBlocksReady);\n    } else {\n      nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);\n    }\n    const nWordsReady = nBlocksReady * this.blockSize;\n    const nBytesReady = Math.min(nWordsReady * 4, this._data.sigBytes);\n    if (nWordsReady) {\n      for (let offset = 0; offset < nWordsReady; offset += this.blockSize) {\n        this._doProcessBlock(this._data.words, offset);\n      }\n      processedWords = this._data.words.splice(0, nWordsReady);\n      this._data.sigBytes -= nBytesReady;\n    }\n    return new WordArray(processedWords, nBytesReady);\n  }\n}\nclass Hasher extends BufferedBlockAlgorithm {\n  update(messageUpdate) {\n    this._append(messageUpdate);\n    this._process();\n    return this;\n  }\n  finalize(messageUpdate) {\n    if (messageUpdate) {\n      this._append(messageUpdate);\n    }\n  }\n}\n\nvar __defProp = Object.defineProperty;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __publicField = (obj, key, value) => {\n  __defNormalProp(obj, typeof key !== \"symbol\" ? key + \"\" : key, value);\n  return value;\n};\nconst H = [\n  1779033703,\n  -1150833019,\n  1013904242,\n  -1521486534,\n  1359893119,\n  -1694144372,\n  528734635,\n  1541459225\n];\nconst K = [\n  1116352408,\n  1899447441,\n  -1245643825,\n  -373957723,\n  961987163,\n  1508970993,\n  -1841331548,\n  -1424204075,\n  -670586216,\n  310598401,\n  607225278,\n  1426881987,\n  1925078388,\n  -2132889090,\n  -1680079193,\n  -1046744716,\n  -459576895,\n  -272742522,\n  264347078,\n  604807628,\n  770255983,\n  1249150122,\n  1555081692,\n  1996064986,\n  -1740746414,\n  -1473132947,\n  -1341970488,\n  -1084653625,\n  -958395405,\n  -710438585,\n  113926993,\n  338241895,\n  666307205,\n  773529912,\n  1294757372,\n  1396182291,\n  1695183700,\n  1986661051,\n  -2117940946,\n  -1838011259,\n  -1564481375,\n  -1474664885,\n  -1035236496,\n  -949202525,\n  -778901479,\n  -694614492,\n  -200395387,\n  275423344,\n  430227734,\n  506948616,\n  659060556,\n  883997877,\n  958139571,\n  1322822218,\n  1537002063,\n  1747873779,\n  1955562222,\n  2024104815,\n  -2067236844,\n  -1933114872,\n  -1866530822,\n  -1538233109,\n  -1090935817,\n  -965641998\n];\nconst W = [];\nclass SHA256 extends Hasher {\n  constructor() {\n    super(...arguments);\n    __publicField(this, \"_hash\", new WordArray([...H]));\n  }\n  /**\n   * Resets the internal state of the hash object to initial values.\n   */\n  reset() {\n    super.reset();\n    this._hash = new WordArray([...H]);\n  }\n  _doProcessBlock(M, offset) {\n    const H2 = this._hash.words;\n    let a = H2[0];\n    let b = H2[1];\n    let c = H2[2];\n    let d = H2[3];\n    let e = H2[4];\n    let f = H2[5];\n    let g = H2[6];\n    let h = H2[7];\n    for (let i = 0; i < 64; i++) {\n      if (i < 16) {\n        W[i] = M[offset + i] | 0;\n      } else {\n        const gamma0x = W[i - 15];\n        const gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;\n        const gamma1x = W[i - 2];\n        const gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;\n        W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];\n      }\n      const ch = e & f ^ ~e & g;\n      const maj = a & b ^ a & c ^ b & c;\n      const sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);\n      const sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);\n      const t1 = h + sigma1 + ch + K[i] + W[i];\n      const t2 = sigma0 + maj;\n      h = g;\n      g = f;\n      f = e;\n      e = d + t1 | 0;\n      d = c;\n      c = b;\n      b = a;\n      a = t1 + t2 | 0;\n    }\n    H2[0] = H2[0] + a | 0;\n    H2[1] = H2[1] + b | 0;\n    H2[2] = H2[2] + c | 0;\n    H2[3] = H2[3] + d | 0;\n    H2[4] = H2[4] + e | 0;\n    H2[5] = H2[5] + f | 0;\n    H2[6] = H2[6] + g | 0;\n    H2[7] = H2[7] + h | 0;\n  }\n  /**\n   * Finishes the hash calculation and returns the hash as a WordArray.\n   *\n   * @param {string} messageUpdate - Additional message content to include in the hash.\n   * @returns {WordArray} The finalised hash as a WordArray.\n   */\n  finalize(messageUpdate) {\n    super.finalize(messageUpdate);\n    const nBitsTotal = this._nDataBytes * 8;\n    const nBitsLeft = this._data.sigBytes * 8;\n    this._data.words[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;\n    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(\n      nBitsTotal / 4294967296\n    );\n    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;\n    this._data.sigBytes = this._data.words.length * 4;\n    this._process();\n    return this._hash;\n  }\n}\nfunction sha256(message) {\n  return new SHA256().finalize(message).toString();\n}\nfunction sha256base64(message) {\n  return new SHA256().finalize(message).toString(Base64);\n}\n\nfunction hash(object, options = {}) {\n  const hashed = typeof object === \"string\" ? object : objectHash(object, options);\n  return sha256base64(hashed).slice(0, 10);\n}\n\nfunction murmurHash(key, seed = 0) {\n  if (typeof key === \"string\") {\n    key = createBuffer(key);\n  }\n  let i = 0;\n  let h1 = seed;\n  let k1;\n  let h1b;\n  const remainder = key.length & 3;\n  const bytes = key.length - remainder;\n  const c1 = 3432918353;\n  const c2 = 461845907;\n  while (i < bytes) {\n    k1 = key[i] & 255 | (key[++i] & 255) << 8 | (key[++i] & 255) << 16 | (key[++i] & 255) << 24;\n    ++i;\n    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;\n    k1 = k1 << 15 | k1 >>> 17;\n    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;\n    h1 ^= k1;\n    h1 = h1 << 13 | h1 >>> 19;\n    h1b = (h1 & 65535) * 5 + (((h1 >>> 16) * 5 & 65535) << 16) & 4294967295;\n    h1 = (h1b & 65535) + 27492 + (((h1b >>> 16) + 58964 & 65535) << 16);\n  }\n  k1 = 0;\n  switch (remainder) {\n    case 3: {\n      k1 ^= (key[i + 2] & 255) << 16;\n    }\n    case 2: {\n      k1 ^= (key[i + 1] & 255) << 8;\n    }\n    case 1: {\n      k1 ^= key[i] & 255;\n      k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;\n      k1 = k1 << 15 | k1 >>> 17;\n      k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;\n      h1 ^= k1;\n    }\n  }\n  h1 ^= key.length;\n  h1 ^= h1 >>> 16;\n  h1 = (h1 & 65535) * 2246822507 + (((h1 >>> 16) * 2246822507 & 65535) << 16) & 4294967295;\n  h1 ^= h1 >>> 13;\n  h1 = (h1 & 65535) * 3266489909 + (((h1 >>> 16) * 3266489909 & 65535) << 16) & 4294967295;\n  h1 ^= h1 >>> 16;\n  return h1 >>> 0;\n}\nfunction createBuffer(val) {\n  return new TextEncoder().encode(val);\n}\n\nfunction isEqual(object1, object2, hashOptions = {}) {\n  if (object1 === object2) {\n    return true;\n  }\n  if (objectHash(object1, hashOptions) === objectHash(object2, hashOptions)) {\n    return true;\n  }\n  return false;\n}\n\nfunction diff(obj1, obj2, opts = {}) {\n  const h1 = _toHashedObject(obj1, opts);\n  const h2 = _toHashedObject(obj2, opts);\n  return _diff(h1, h2, opts);\n}\nfunction _diff(h1, h2, opts = {}) {\n  const diffs = [];\n  const allProps = /* @__PURE__ */ new Set([\n    ...Object.keys(h1.props || {}),\n    ...Object.keys(h2.props || {})\n  ]);\n  if (h1.props && h2.props) {\n    for (const prop of allProps) {\n      const p1 = h1.props[prop];\n      const p2 = h2.props[prop];\n      if (p1 && p2) {\n        diffs.push(..._diff(h1.props?.[prop], h2.props?.[prop], opts));\n      } else if (p1 || p2) {\n        diffs.push(\n          new DiffEntry((p2 || p1).key, p1 ? \"removed\" : \"added\", p2, p1)\n        );\n      }\n    }\n  }\n  if (allProps.size === 0 && h1.hash !== h2.hash) {\n    diffs.push(new DiffEntry((h2 || h1).key, \"changed\", h2, h1));\n  }\n  return diffs;\n}\nfunction _toHashedObject(obj, opts, key = \"\") {\n  if (obj && typeof obj !== \"object\") {\n    return new DiffHashedObject(key, obj, objectHash(obj, opts));\n  }\n  const props = {};\n  const hashes = [];\n  for (const _key in obj) {\n    props[_key] = _toHashedObject(\n      obj[_key],\n      opts,\n      key ? `${key}.${_key}` : _key\n    );\n    hashes.push(props[_key].hash);\n  }\n  return new DiffHashedObject(key, obj, `{${hashes.join(\":\")}}`, props);\n}\nclass DiffEntry {\n  constructor(key, type, newValue, oldValue) {\n    this.key = key;\n    this.type = type;\n    this.newValue = newValue;\n    this.oldValue = oldValue;\n  }\n  toString() {\n    return this.toJSON();\n  }\n  toJSON() {\n    switch (this.type) {\n      case \"added\": {\n        return `Added   \\`${this.key}\\``;\n      }\n      case \"removed\": {\n        return `Removed \\`${this.key}\\``;\n      }\n      case \"changed\": {\n        return `Changed \\`${this.key}\\` from \\`${this.oldValue?.toString() || \"-\"}\\` to \\`${this.newValue.toString()}\\``;\n      }\n    }\n  }\n}\nclass DiffHashedObject {\n  constructor(key, value, hash, props) {\n    this.key = key;\n    this.value = value;\n    this.hash = hash;\n    this.props = props;\n  }\n  toString() {\n    if (this.props) {\n      return `{${Object.keys(this.props).join(\",\")}}`;\n    } else {\n      return JSON.stringify(this.value);\n    }\n  }\n  toJSON() {\n    const k = this.key || \".\";\n    if (this.props) {\n      return `${k}({${Object.keys(this.props).join(\",\")}})`;\n    }\n    return `${k}(${this.value})`;\n  }\n}\n\nexport { diff, hash, isEqual, murmurHash, objectHash, sha256, sha256base64 };\n"],"names":["defaults","Object","freeze","ignoreUnknown","respectType","respectFunctionNames","respectFunctionProperties","unorderedObjects","unorderedArrays","unorderedSets","excludeKeys","excludeValues","replacer","objectHash","object","options","hasher","createHasher","dispatch","toString","defaultPrototypesKeys","buff","context","Map","write","str","getContext","value","this","toJSON","objString","prototype","call","objType","objectLength","length","slice","toLowerCase","objectNumber","get","set","size","Buffer","isBuffer","unkown","keys","sort","extraKeys","isNativeFunction","filter","key","dispatchForKey","array","arr","unordered","entry","contextAdditions","entries","map","date","symbol","sym","type","Array","from","error","err","boolean","bool","string","fn","String","name","number","xml","null","undefined","regexp","regex","uint8array","uint8clampedarray","int8array","uint16array","int16array","uint32array","int32array","float32array","float64array","arraybuffer","Uint8Array","url","file","lastModfied","blob","Error","domwindow","bigint","process","timer","pipe","tcp","udp","tty","statwatcher","securecontext","connection","zlib","nodescript","httpparser","dataview","signal","fsevent","tlswrap","nativeFunc","nativeFuncLength","f","Function","isEqual","object1","object2","hashOptions"],"mappings":"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","x_google_ignoreList":[0]}