/*! SES sources included by LavaMoat. Do not optimize or minify. */
;
// ses@1.15.0
(functors => options => {
  'use strict';

  const {
    Map,
    Object,
    ReferenceError,
    Reflect,
    TypeError,
  } = globalThis;
  const {
    create,
    defineProperties,
    defineProperty,
    freeze,
    fromEntries,
    getOwnPropertyDescriptors,
    getOwnPropertyNames,
    keys,
  } = Object;
  const { get, set } = Reflect;

  const {
  } = options || {};



  const cell = (name, value = undefined) => {
    const observers = [];
    return freeze({
      get: freeze(() => {
        return value;
      }),
      set: freeze((newValue) => {
        value = newValue;
        for (const observe of observers) {
          observe(value);
        }
      }),
      observe: freeze((observe) => {
        observers.push(observe);
        observe(value);
      }),
      enumerable: true,
    });
  };

  const cells = [
    {
      globalThis: cell("globalThis"),
      Array: cell("Array"),
      ArrayBuffer: cell("ArrayBuffer"),
      Date: cell("Date"),
      FinalizationRegistry: cell("FinalizationRegistry"),
      Float32Array: cell("Float32Array"),
      JSON: cell("JSON"),
      Map: cell("Map"),
      Math: cell("Math"),
      Number: cell("Number"),
      Object: cell("Object"),
      Promise: cell("Promise"),
      Proxy: cell("Proxy"),
      Reflect: cell("Reflect"),
      FERAL_REG_EXP: cell("FERAL_REG_EXP"),
      Set: cell("Set"),
      String: cell("String"),
      Symbol: cell("Symbol"),
      Uint8Array: cell("Uint8Array"),
      WeakMap: cell("WeakMap"),
      WeakSet: cell("WeakSet"),
      FERAL_ERROR: cell("FERAL_ERROR"),
      RangeError: cell("RangeError"),
      ReferenceError: cell("ReferenceError"),
      SyntaxError: cell("SyntaxError"),
      TypeError: cell("TypeError"),
      AggregateError: cell("AggregateError"),
      assign: cell("assign"),
      create: cell("create"),
      defineProperties: cell("defineProperties"),
      entries: cell("entries"),
      freeze: cell("freeze"),
      getOwnPropertyDescriptor: cell("getOwnPropertyDescriptor"),
      getOwnPropertyDescriptors: cell("getOwnPropertyDescriptors"),
      getOwnPropertyNames: cell("getOwnPropertyNames"),
      getPrototypeOf: cell("getPrototypeOf"),
      is: cell("is"),
      isFrozen: cell("isFrozen"),
      isSealed: cell("isSealed"),
      isExtensible: cell("isExtensible"),
      keys: cell("keys"),
      objectPrototype: cell("objectPrototype"),
      seal: cell("seal"),
      preventExtensions: cell("preventExtensions"),
      setPrototypeOf: cell("setPrototypeOf"),
      values: cell("values"),
      fromEntries: cell("fromEntries"),
      speciesSymbol: cell("speciesSymbol"),
      toStringTagSymbol: cell("toStringTagSymbol"),
      iteratorSymbol: cell("iteratorSymbol"),
      matchAllSymbol: cell("matchAllSymbol"),
      replaceSymbol: cell("replaceSymbol"),
      unscopablesSymbol: cell("unscopablesSymbol"),
      symbolKeyFor: cell("symbolKeyFor"),
      symbolFor: cell("symbolFor"),
      isInteger: cell("isInteger"),
      stringifyJson: cell("stringifyJson"),
      defineProperty: cell("defineProperty"),
      apply: cell("apply"),
      construct: cell("construct"),
      reflectGet: cell("reflectGet"),
      reflectGetOwnPropertyDescriptor: cell("reflectGetOwnPropertyDescriptor"),
      reflectHas: cell("reflectHas"),
      reflectIsExtensible: cell("reflectIsExtensible"),
      ownKeys: cell("ownKeys"),
      reflectPreventExtensions: cell("reflectPreventExtensions"),
      reflectSet: cell("reflectSet"),
      isArray: cell("isArray"),
      arrayPrototype: cell("arrayPrototype"),
      arrayBufferPrototype: cell("arrayBufferPrototype"),
      mapPrototype: cell("mapPrototype"),
      proxyRevocable: cell("proxyRevocable"),
      regexpPrototype: cell("regexpPrototype"),
      setPrototype: cell("setPrototype"),
      stringPrototype: cell("stringPrototype"),
      weakmapPrototype: cell("weakmapPrototype"),
      weaksetPrototype: cell("weaksetPrototype"),
      functionPrototype: cell("functionPrototype"),
      promisePrototype: cell("promisePrototype"),
      generatorPrototype: cell("generatorPrototype"),
      iteratorPrototype: cell("iteratorPrototype"),
      typedArrayPrototype: cell("typedArrayPrototype"),
      uncurryThis: cell("uncurryThis"),
      hasOwn: cell("hasOwn"),
      arrayFilter: cell("arrayFilter"),
      arrayForEach: cell("arrayForEach"),
      arrayIncludes: cell("arrayIncludes"),
      arrayJoin: cell("arrayJoin"),
      arrayMap: cell("arrayMap"),
      arrayFlatMap: cell("arrayFlatMap"),
      arrayPop: cell("arrayPop"),
      arrayPush: cell("arrayPush"),
      arraySlice: cell("arraySlice"),
      arraySome: cell("arraySome"),
      arraySort: cell("arraySort"),
      iterateArray: cell("iterateArray"),
      arrayBufferSlice: cell("arrayBufferSlice"),
      arrayBufferGetByteLength: cell("arrayBufferGetByteLength"),
      typedArraySet: cell("typedArraySet"),
      mapSet: cell("mapSet"),
      mapGet: cell("mapGet"),
      mapHas: cell("mapHas"),
      mapDelete: cell("mapDelete"),
      mapEntries: cell("mapEntries"),
      iterateMap: cell("iterateMap"),
      setAdd: cell("setAdd"),
      setDelete: cell("setDelete"),
      setForEach: cell("setForEach"),
      setHas: cell("setHas"),
      iterateSet: cell("iterateSet"),
      regexpExec: cell("regexpExec"),
      regexpReplace: cell("regexpReplace"),
      matchAllRegExp: cell("matchAllRegExp"),
      sealRegexp: cell("sealRegexp"),
      stringEndsWith: cell("stringEndsWith"),
      stringIncludes: cell("stringIncludes"),
      stringIndexOf: cell("stringIndexOf"),
      stringMatch: cell("stringMatch"),
      stringSearch: cell("stringSearch"),
      stringSlice: cell("stringSlice"),
      stringSplit: cell("stringSplit"),
      stringStartsWith: cell("stringStartsWith"),
      iterateString: cell("iterateString"),
      weakmapDelete: cell("weakmapDelete"),
      weakmapGet: cell("weakmapGet"),
      weakmapHas: cell("weakmapHas"),
      weakmapSet: cell("weakmapSet"),
      weaksetAdd: cell("weaksetAdd"),
      weaksetHas: cell("weaksetHas"),
      functionToString: cell("functionToString"),
      functionBind: cell("functionBind"),
      generatorNext: cell("generatorNext"),
      generatorThrow: cell("generatorThrow"),
      promiseAll: cell("promiseAll"),
      promiseCatch: cell("promiseCatch"),
      promiseThen: cell("promiseThen"),
      finalizationRegistryRegister: cell("finalizationRegistryRegister"),
      finalizationRegistryUnregister: cell("finalizationRegistryUnregister"),
      isPrimitive: cell("isPrimitive"),
      isError: cell("isError"),
      identity: cell("identity"),
      FERAL_EVAL: cell("FERAL_EVAL"),
      FERAL_FUNCTION: cell("FERAL_FUNCTION"),
      noEvalEvaluate: cell("noEvalEvaluate"),
      FERAL_STACK_GETTER: cell("FERAL_STACK_GETTER"),
      FERAL_STACK_SETTER: cell("FERAL_STACK_SETTER"),
      AsyncGeneratorFunctionInstance: cell("AsyncGeneratorFunctionInstance"),
    },
    {
    },
    {
      makeEnvironmentCaptor: cell("makeEnvironmentCaptor"),
      getEnvironmentOption: cell("getEnvironmentOption"),
      getEnvironmentOptionsList: cell("getEnvironmentOptionsList"),
      environmentOptionsListHas: cell("environmentOptionsListHas"),
    },
    {
    },
    {
      isBufferImmutable: cell("isBufferImmutable"),
      sliceBufferToImmutable: cell("sliceBufferToImmutable"),
      optTransferBufferToImmutable: cell("optTransferBufferToImmutable"),
    },
    {
    },
    {
    },
    {
      an: cell("an"),
      bestEffortStringify: cell("bestEffortStringify"),
      enJoin: cell("enJoin"),
    },
    {
    },
    {
    },
    {
      makeCacheMapKit: cell("makeCacheMapKit"),
    },
    {
      makeCacheMapKit: cell("makeCacheMapKit"),
    },
    {
      makeNoteLogArgsArrayKit: cell("makeNoteLogArgsArrayKit"),
    },
    {
      q: cell("q"),
      b: cell("b"),
      X: cell("X"),
      unredactedDetails: cell("unredactedDetails"),
      makeError: cell("makeError"),
      annotateError: cell("annotateError"),
      loggedErrorHandler: cell("loggedErrorHandler"),
      assert: cell("assert"),
      assertEqual: cell("assertEqual"),
      sanitizeError: cell("sanitizeError"),
      makeAssert: cell("makeAssert"),
    },
    {
      isTypedArray: cell("isTypedArray"),
      makeHardener: cell("makeHardener"),
    },
    {
      cauterizeProperty: cell("cauterizeProperty"),
    },
    {
      NativeErrors: cell("NativeErrors"),
      constantProperties: cell("constantProperties"),
      universalPropertyNames: cell("universalPropertyNames"),
      initialGlobalPropertyNames: cell("initialGlobalPropertyNames"),
      sharedGlobalPropertyNames: cell("sharedGlobalPropertyNames"),
      uniqueGlobalPropertyNames: cell("uniqueGlobalPropertyNames"),
      FunctionInstance: cell("FunctionInstance"),
      AsyncFunctionInstance: cell("AsyncFunctionInstance"),
      isAccessorPermit: cell("isAccessorPermit"),
      permitted: cell("permitted"),
    },
    {
      makeIntrinsicsCollector: cell("makeIntrinsicsCollector"),
      getGlobalIntrinsics: cell("getGlobalIntrinsics"),
    },
    {
      default: cell("default"),
    },
    {
      default: cell("default"),
    },
    {
      default: cell("default"),
    },
    {
      default: cell("default"),
    },
    {
      default: cell("default"),
    },
    {
      minEnablements: cell("minEnablements"),
      moderateEnablements: cell("moderateEnablements"),
      severeEnablements: cell("severeEnablements"),
    },
    {
      default: cell("default"),
    },
    {
      default: cell("default"),
    },
    {
      makeEvalFunction: cell("makeEvalFunction"),
    },
    {
      makeFunctionConstructor: cell("makeFunctionConstructor"),
    },
    {
      setGlobalObjectSymbolUnscopables: cell("setGlobalObjectSymbolUnscopables"),
      setGlobalObjectConstantProperties: cell("setGlobalObjectConstantProperties"),
      setGlobalObjectMutableProperties: cell("setGlobalObjectMutableProperties"),
      setGlobalObjectEvaluators: cell("setGlobalObjectEvaluators"),
    },
    {
      alwaysThrowHandler: cell("alwaysThrowHandler"),
      strictScopeTerminatorHandler: cell("strictScopeTerminatorHandler"),
      strictScopeTerminator: cell("strictScopeTerminator"),
    },
    {
      createSloppyGlobalsScopeTerminator: cell("createSloppyGlobalsScopeTerminator"),
    },
    {
      makeEvalScopeKit: cell("makeEvalScopeKit"),
    },
    {
      getSourceURL: cell("getSourceURL"),
    },
    {
      rejectHtmlComments: cell("rejectHtmlComments"),
      evadeHtmlCommentTest: cell("evadeHtmlCommentTest"),
      rejectImportExpressions: cell("rejectImportExpressions"),
      evadeImportExpressionTest: cell("evadeImportExpressionTest"),
      rejectSomeDirectEvalExpressions: cell("rejectSomeDirectEvalExpressions"),
      mandatoryTransforms: cell("mandatoryTransforms"),
      applyTransforms: cell("applyTransforms"),
      transforms: cell("transforms"),
    },
    {
      isValidIdentifierName: cell("isValidIdentifierName"),
      getScopeConstants: cell("getScopeConstants"),
    },
    {
      makeEvaluate: cell("makeEvaluate"),
    },
    {
      makeSafeEvaluator: cell("makeSafeEvaluator"),
    },
    {
      tameFunctionToString: cell("tameFunctionToString"),
    },
    {
      tameDomains: cell("tameDomains"),
    },
    {
      tameModuleSource: cell("tameModuleSource"),
    },
    {
      consoleLevelMethods: cell("consoleLevelMethods"),
      consoleOtherMethods: cell("consoleOtherMethods"),
      makeLoggingConsoleKit: cell("makeLoggingConsoleKit"),
      pumpLogToConsole: cell("pumpLogToConsole"),
      makeCausalConsole: cell("makeCausalConsole"),
      defineCausalConsoleFromLogger: cell("defineCausalConsoleFromLogger"),
      filterConsole: cell("filterConsole"),
    },
    {
      makeRejectionHandlers: cell("makeRejectionHandlers"),
    },
    {
      tameConsole: cell("tameConsole"),
    },
    {
      filterFileName: cell("filterFileName"),
      shortenCallSiteString: cell("shortenCallSiteString"),
      tameV8ErrorConstructor: cell("tameV8ErrorConstructor"),
    },
    {
      default: cell("default"),
    },
    {
      makeAlias: cell("makeAlias"),
      load: cell("load"),
      loadNow: cell("loadNow"),
    },
    {
      deferExports: cell("deferExports"),
      getDeferredExports: cell("getDeferredExports"),
    },
    {
      provideCompartmentEvaluator: cell("provideCompartmentEvaluator"),
      compartmentEvaluate: cell("compartmentEvaluate"),
    },
    {
      makeVirtualModuleInstance: cell("makeVirtualModuleInstance"),
      makeModuleInstance: cell("makeModuleInstance"),
    },
    {
      link: cell("link"),
      instantiate: cell("instantiate"),
    },
    {
      InertCompartment: cell("InertCompartment"),
      CompartmentPrototype: cell("CompartmentPrototype"),
      compartmentOptions: cell("compartmentOptions"),
      makeCompartmentConstructor: cell("makeCompartmentConstructor"),
    },
    {
      getAnonymousIntrinsics: cell("getAnonymousIntrinsics"),
    },
    {
      tameHarden: cell("tameHarden"),
    },
    {
      tameSymbolConstructor: cell("tameSymbolConstructor"),
    },
    {
      tameFauxDataProperty: cell("tameFauxDataProperty"),
      tameFauxDataProperties: cell("tameFauxDataProperties"),
    },
    {
      tameRegeneratorRuntime: cell("tameRegeneratorRuntime"),
    },
    {
      shimArrayBufferTransfer: cell("shimArrayBufferTransfer"),
    },
    {
      chooseReporter: cell("chooseReporter"),
      reportInGroup: cell("reportInGroup"),
    },
    {
      repairIntrinsics: cell("repairIntrinsics"),
    },
    {
    },
    {
    },
    {
    },
    {
    },
    {
    },
  ];

  defineProperties(cells[3], getOwnPropertyDescriptors(cells[2]));

  defineProperties(cells[11], {"makeCacheMapKit": { value: cells[10]["makeCacheMapKit"] } });

  const namespaces = cells.map(cells => freeze(create(null, {
    ...cells,
    // Make this appear like an ESM module namespace object.
    [Symbol.toStringTag]: {
      value: 'Module',
      writable: false,
      enumerable: false,
      configurable: false,
    },
  })));

  for (let index = 0; index < namespaces.length; index += 1) {
    cells[index]['*'] = cell('*', namespaces[index]);
  }

function observeImports(map, importName, importIndex) {
  for (const [name, observers] of map.get(importName)) {
    const cell = cells[importIndex][name];
    if (cell === undefined) {
      throw new ReferenceError(`Cannot import name ${name} (has ${Object.getOwnPropertyNames(cells[importIndex]).join(', ')})`);
    }
    for (const observer of observers) {
      cell.observe(observer);
    }
  }
}

  functors[0]({
    imports(entries) {
      const map = new Map(entries);
    },
    liveVar: {
    },
    onceVar: {
      universalThis: cells[0].globalThis.set,
      Array: cells[0].Array.set,
      ArrayBuffer: cells[0].ArrayBuffer.set,
      Date: cells[0].Date.set,
      FinalizationRegistry: cells[0].FinalizationRegistry.set,
      Float32Array: cells[0].Float32Array.set,
      JSON: cells[0].JSON.set,
      Map: cells[0].Map.set,
      Math: cells[0].Math.set,
      Number: cells[0].Number.set,
      Object: cells[0].Object.set,
      Promise: cells[0].Promise.set,
      Proxy: cells[0].Proxy.set,
      Reflect: cells[0].Reflect.set,
      FERAL_REG_EXP: cells[0].FERAL_REG_EXP.set,
      Set: cells[0].Set.set,
      String: cells[0].String.set,
      Symbol: cells[0].Symbol.set,
      Uint8Array: cells[0].Uint8Array.set,
      WeakMap: cells[0].WeakMap.set,
      WeakSet: cells[0].WeakSet.set,
      FERAL_ERROR: cells[0].FERAL_ERROR.set,
      RangeError: cells[0].RangeError.set,
      ReferenceError: cells[0].ReferenceError.set,
      SyntaxError: cells[0].SyntaxError.set,
      TypeError: cells[0].TypeError.set,
      AggregateError: cells[0].AggregateError.set,
      assign: cells[0].assign.set,
      create: cells[0].create.set,
      defineProperties: cells[0].defineProperties.set,
      entries: cells[0].entries.set,
      freeze: cells[0].freeze.set,
      getOwnPropertyDescriptor: cells[0].getOwnPropertyDescriptor.set,
      getOwnPropertyDescriptors: cells[0].getOwnPropertyDescriptors.set,
      getOwnPropertyNames: cells[0].getOwnPropertyNames.set,
      getPrototypeOf: cells[0].getPrototypeOf.set,
      is: cells[0].is.set,
      isFrozen: cells[0].isFrozen.set,
      isSealed: cells[0].isSealed.set,
      isExtensible: cells[0].isExtensible.set,
      keys: cells[0].keys.set,
      objectPrototype: cells[0].objectPrototype.set,
      seal: cells[0].seal.set,
      preventExtensions: cells[0].preventExtensions.set,
      setPrototypeOf: cells[0].setPrototypeOf.set,
      values: cells[0].values.set,
      fromEntries: cells[0].fromEntries.set,
      speciesSymbol: cells[0].speciesSymbol.set,
      toStringTagSymbol: cells[0].toStringTagSymbol.set,
      iteratorSymbol: cells[0].iteratorSymbol.set,
      matchAllSymbol: cells[0].matchAllSymbol.set,
      replaceSymbol: cells[0].replaceSymbol.set,
      unscopablesSymbol: cells[0].unscopablesSymbol.set,
      symbolKeyFor: cells[0].symbolKeyFor.set,
      symbolFor: cells[0].symbolFor.set,
      isInteger: cells[0].isInteger.set,
      stringifyJson: cells[0].stringifyJson.set,
      defineProperty: cells[0].defineProperty.set,
      apply: cells[0].apply.set,
      construct: cells[0].construct.set,
      reflectGet: cells[0].reflectGet.set,
      reflectGetOwnPropertyDescriptor: cells[0].reflectGetOwnPropertyDescriptor.set,
      reflectHas: cells[0].reflectHas.set,
      reflectIsExtensible: cells[0].reflectIsExtensible.set,
      ownKeys: cells[0].ownKeys.set,
      reflectPreventExtensions: cells[0].reflectPreventExtensions.set,
      reflectSet: cells[0].reflectSet.set,
      isArray: cells[0].isArray.set,
      arrayPrototype: cells[0].arrayPrototype.set,
      arrayBufferPrototype: cells[0].arrayBufferPrototype.set,
      mapPrototype: cells[0].mapPrototype.set,
      proxyRevocable: cells[0].proxyRevocable.set,
      regexpPrototype: cells[0].regexpPrototype.set,
      setPrototype: cells[0].setPrototype.set,
      stringPrototype: cells[0].stringPrototype.set,
      weakmapPrototype: cells[0].weakmapPrototype.set,
      weaksetPrototype: cells[0].weaksetPrototype.set,
      functionPrototype: cells[0].functionPrototype.set,
      promisePrototype: cells[0].promisePrototype.set,
      generatorPrototype: cells[0].generatorPrototype.set,
      iteratorPrototype: cells[0].iteratorPrototype.set,
      typedArrayPrototype: cells[0].typedArrayPrototype.set,
      uncurryThis: cells[0].uncurryThis.set,
      hasOwn: cells[0].hasOwn.set,
      arrayFilter: cells[0].arrayFilter.set,
      arrayForEach: cells[0].arrayForEach.set,
      arrayIncludes: cells[0].arrayIncludes.set,
      arrayJoin: cells[0].arrayJoin.set,
      arrayMap: cells[0].arrayMap.set,
      arrayFlatMap: cells[0].arrayFlatMap.set,
      arrayPop: cells[0].arrayPop.set,
      arrayPush: cells[0].arrayPush.set,
      arraySlice: cells[0].arraySlice.set,
      arraySome: cells[0].arraySome.set,
      arraySort: cells[0].arraySort.set,
      iterateArray: cells[0].iterateArray.set,
      arrayBufferSlice: cells[0].arrayBufferSlice.set,
      arrayBufferGetByteLength: cells[0].arrayBufferGetByteLength.set,
      typedArraySet: cells[0].typedArraySet.set,
      mapSet: cells[0].mapSet.set,
      mapGet: cells[0].mapGet.set,
      mapHas: cells[0].mapHas.set,
      mapDelete: cells[0].mapDelete.set,
      mapEntries: cells[0].mapEntries.set,
      iterateMap: cells[0].iterateMap.set,
      setAdd: cells[0].setAdd.set,
      setDelete: cells[0].setDelete.set,
      setForEach: cells[0].setForEach.set,
      setHas: cells[0].setHas.set,
      iterateSet: cells[0].iterateSet.set,
      regexpExec: cells[0].regexpExec.set,
      regexpReplace: cells[0].regexpReplace.set,
      matchAllRegExp: cells[0].matchAllRegExp.set,
      sealRegexp: cells[0].sealRegexp.set,
      stringEndsWith: cells[0].stringEndsWith.set,
      stringIncludes: cells[0].stringIncludes.set,
      stringIndexOf: cells[0].stringIndexOf.set,
      stringMatch: cells[0].stringMatch.set,
      stringSearch: cells[0].stringSearch.set,
      stringSlice: cells[0].stringSlice.set,
      stringSplit: cells[0].stringSplit.set,
      stringStartsWith: cells[0].stringStartsWith.set,
      iterateString: cells[0].iterateString.set,
      weakmapDelete: cells[0].weakmapDelete.set,
      weakmapGet: cells[0].weakmapGet.set,
      weakmapHas: cells[0].weakmapHas.set,
      weakmapSet: cells[0].weakmapSet.set,
      weaksetAdd: cells[0].weaksetAdd.set,
      weaksetHas: cells[0].weaksetHas.set,
      functionToString: cells[0].functionToString.set,
      functionBind: cells[0].functionBind.set,
      generatorNext: cells[0].generatorNext.set,
      generatorThrow: cells[0].generatorThrow.set,
      promiseAll: cells[0].promiseAll.set,
      promiseCatch: cells[0].promiseCatch.set,
      promiseThen: cells[0].promiseThen.set,
      finalizationRegistryRegister: cells[0].finalizationRegistryRegister.set,
      finalizationRegistryUnregister: cells[0].finalizationRegistryUnregister.set,
      isPrimitive: cells[0].isPrimitive.set,
      isError: cells[0].isError.set,
      identity: cells[0].identity.set,
      FERAL_EVAL: cells[0].FERAL_EVAL.set,
      FERAL_FUNCTION: cells[0].FERAL_FUNCTION.set,
      noEvalEvaluate: cells[0].noEvalEvaluate.set,
      FERAL_STACK_GETTER: cells[0].FERAL_STACK_GETTER.set,
      FERAL_STACK_SETTER: cells[0].FERAL_STACK_SETTER.set,
      AsyncGeneratorFunctionInstance: cells[0].AsyncGeneratorFunctionInstance.set,
    },
    importMeta: {},
  });
  functors[1]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
    },
    importMeta: {},
  });
  functors[2]({
    imports(entries) {
      const map = new Map(entries);
    },
    liveVar: {
    },
    onceVar: {
      makeEnvironmentCaptor: cells[2].makeEnvironmentCaptor.set,
      getEnvironmentOption: cells[2].getEnvironmentOption.set,
      getEnvironmentOptionsList: cells[2].getEnvironmentOptionsList.set,
      environmentOptionsListHas: cells[2].environmentOptionsListHas.set,
    },
    importMeta: {},
  });
  functors[3]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./src/env-options.js", 2);
    },
    liveVar: {
    },
    onceVar: {
    },
    importMeta: {},
  });
  functors[4]({
    imports(entries) {
      const map = new Map(entries);
    },
    liveVar: {
    },
    onceVar: {
      isBufferImmutable: cells[4].isBufferImmutable.set,
      sliceBufferToImmutable: cells[4].sliceBufferToImmutable.set,
      optTransferBufferToImmutable: cells[4].optTransferBufferToImmutable.set,
    },
    importMeta: {},
  });
  functors[5]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./immutable-arraybuffer-pony.js", 4);
    },
    liveVar: {
    },
    onceVar: {
    },
    importMeta: {},
  });
  functors[6]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./src/immutable-arraybuffer-shim.js", 5);
    },
    liveVar: {
    },
    onceVar: {
    },
    importMeta: {},
  });
  functors[7]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "../commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      an: cells[7].an.set,
      bestEffortStringify: cells[7].bestEffortStringify.set,
      enJoin: cells[7].enJoin.set,
    },
    importMeta: {},
  });
  functors[8]({
    imports(entries) {
      const map = new Map(entries);
    },
    liveVar: {
    },
    onceVar: {
    },
    importMeta: {},
  });
  functors[9]({
    imports(entries) {
      const map = new Map(entries);
    },
    liveVar: {
    },
    onceVar: {
    },
    importMeta: {},
  });
  functors[10]({
    imports(entries) {
      const map = new Map(entries);
    },
    liveVar: {
    },
    onceVar: {
      makeCacheMapKit: cells[10].makeCacheMapKit.set,
    },
    importMeta: {},
  });
  functors[11]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./src/cachemap.js", 10);
    },
    liveVar: {
    },
    onceVar: {
    },
    importMeta: {},
  });
  functors[12]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "@endo/cache-map", 11);
    },
    liveVar: {
    },
    onceVar: {
      makeNoteLogArgsArrayKit: cells[12].makeNoteLogArgsArrayKit.set,
    },
    importMeta: {},
  });
  functors[13]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "../commons.js", 0);
      observeImports(map, "./stringify-utils.js", 7);
      observeImports(map, "./types.js", 8);
      observeImports(map, "./internal-types.js", 9);
      observeImports(map, "./note-log-args.js", 12);
    },
    liveVar: {
    },
    onceVar: {
      quote: cells[13].q.set,
      bare: cells[13].b.set,
      redactedDetails: cells[13].X.set,
      unredactedDetails: cells[13].unredactedDetails.set,
      makeError: cells[13].makeError.set,
      note: cells[13].annotateError.set,
      loggedErrorHandler: cells[13].loggedErrorHandler.set,
      assert: cells[13].assert.set,
      assertEqual: cells[13].assertEqual.set,
      sanitizeError: cells[13].sanitizeError.set,
      makeAssert: cells[13].makeAssert.set,
    },
    importMeta: {},
  });
  functors[14]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./error/assert.js", 13);
    },
    liveVar: {
    },
    onceVar: {
      isTypedArray: cells[14].isTypedArray.set,
      makeHardener: cells[14].makeHardener.set,
    },
    importMeta: {},
  });
  functors[15]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      cauterizeProperty: cells[15].cauterizeProperty.set,
    },
    importMeta: {},
  });
  functors[16]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      NativeErrors: cells[16].NativeErrors.set,
      constantProperties: cells[16].constantProperties.set,
      universalPropertyNames: cells[16].universalPropertyNames.set,
      initialGlobalPropertyNames: cells[16].initialGlobalPropertyNames.set,
      sharedGlobalPropertyNames: cells[16].sharedGlobalPropertyNames.set,
      uniqueGlobalPropertyNames: cells[16].uniqueGlobalPropertyNames.set,
      FunctionInstance: cells[16].FunctionInstance.set,
      AsyncFunctionInstance: cells[16].AsyncFunctionInstance.set,
      isAccessorPermit: cells[16].isAccessorPermit.set,
      permitted: cells[16].permitted.set,
    },
    importMeta: {},
  });
  functors[17]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./cauterize-property.js", 15);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./permits.js", 16);
    },
    liveVar: {
    },
    onceVar: {
      makeIntrinsicsCollector: cells[17].makeIntrinsicsCollector.set,
      getGlobalIntrinsics: cells[17].getGlobalIntrinsics.set,
    },
    importMeta: {},
  });
  functors[18]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./permits.js", 16);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./cauterize-property.js", 15);
    },
    liveVar: {
    },
    onceVar: {
      default: cells[18].default.set,
    },
    importMeta: {},
  });
  functors[19]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      default: cells[19].default.set,
    },
    importMeta: {},
  });
  functors[20]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      default: cells[20].default.set,
    },
    importMeta: {},
  });
  functors[21]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      default: cells[21].default.set,
    },
    importMeta: {},
  });
  functors[22]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      default: cells[22].default.set,
    },
    importMeta: {},
  });
  functors[23]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      minEnablements: cells[23].minEnablements.set,
      moderateEnablements: cells[23].moderateEnablements.set,
      severeEnablements: cells[23].severeEnablements.set,
    },
    importMeta: {},
  });
  functors[24]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./enablements.js", 23);
    },
    liveVar: {
    },
    onceVar: {
      default: cells[24].default.set,
    },
    importMeta: {},
  });
  functors[25]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./error/assert.js", 13);
    },
    liveVar: {
    },
    onceVar: {
      default: cells[25].default.set,
    },
    importMeta: {},
  });
  functors[26]({
    imports(entries) {
      const map = new Map(entries);
    },
    liveVar: {
    },
    onceVar: {
      makeEvalFunction: cells[26].makeEvalFunction.set,
    },
    importMeta: {},
  });
  functors[27]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./error/assert.js", 13);
    },
    liveVar: {
    },
    onceVar: {
      makeFunctionConstructor: cells[27].makeFunctionConstructor.set,
    },
    importMeta: {},
  });
  functors[28]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./make-eval-function.js", 26);
      observeImports(map, "./make-function-constructor.js", 27);
      observeImports(map, "./permits.js", 16);
    },
    liveVar: {
    },
    onceVar: {
      setGlobalObjectSymbolUnscopables: cells[28].setGlobalObjectSymbolUnscopables.set,
      setGlobalObjectConstantProperties: cells[28].setGlobalObjectConstantProperties.set,
      setGlobalObjectMutableProperties: cells[28].setGlobalObjectMutableProperties.set,
      setGlobalObjectEvaluators: cells[28].setGlobalObjectEvaluators.set,
    },
    importMeta: {},
  });
  functors[29]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./error/assert.js", 13);
    },
    liveVar: {
    },
    onceVar: {
      alwaysThrowHandler: cells[29].alwaysThrowHandler.set,
      strictScopeTerminatorHandler: cells[29].strictScopeTerminatorHandler.set,
      strictScopeTerminator: cells[29].strictScopeTerminator.set,
    },
    importMeta: {},
  });
  functors[30]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./strict-scope-terminator.js", 29);
    },
    liveVar: {
    },
    onceVar: {
      createSloppyGlobalsScopeTerminator: cells[30].createSloppyGlobalsScopeTerminator.set,
    },
    importMeta: {},
  });
  functors[31]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./error/assert.js", 13);
    },
    liveVar: {
    },
    onceVar: {
      makeEvalScopeKit: cells[31].makeEvalScopeKit.set,
    },
    importMeta: {},
  });
  functors[32]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      getSourceURL: cells[32].getSourceURL.set,
    },
    importMeta: {},
  });
  functors[33]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./get-source-url.js", 32);
    },
    liveVar: {
    },
    onceVar: {
      rejectHtmlComments: cells[33].rejectHtmlComments.set,
      evadeHtmlCommentTest: cells[33].evadeHtmlCommentTest.set,
      rejectImportExpressions: cells[33].rejectImportExpressions.set,
      evadeImportExpressionTest: cells[33].evadeImportExpressionTest.set,
      rejectSomeDirectEvalExpressions: cells[33].rejectSomeDirectEvalExpressions.set,
      mandatoryTransforms: cells[33].mandatoryTransforms.set,
      applyTransforms: cells[33].applyTransforms.set,
      transforms: cells[33].transforms.set,
    },
    importMeta: {},
  });
  functors[34]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      isValidIdentifierName: cells[34].isValidIdentifierName.set,
      getScopeConstants: cells[34].getScopeConstants.set,
    },
    importMeta: {},
  });
  functors[35]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./scope-constants.js", 34);
    },
    liveVar: {
    },
    onceVar: {
      makeEvaluate: cells[35].makeEvaluate.set,
    },
    importMeta: {},
  });
  functors[36]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./strict-scope-terminator.js", 29);
      observeImports(map, "./sloppy-globals-scope-terminator.js", 30);
      observeImports(map, "./eval-scope.js", 31);
      observeImports(map, "./transforms.js", 33);
      observeImports(map, "./make-evaluate.js", 35);
      observeImports(map, "./error/assert.js", 13);
    },
    liveVar: {
    },
    onceVar: {
      makeSafeEvaluator: cells[36].makeSafeEvaluator.set,
    },
    importMeta: {},
  });
  functors[37]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      tameFunctionToString: cells[37].tameFunctionToString.set,
    },
    importMeta: {},
  });
  functors[38]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      tameDomains: cells[38].tameDomains.set,
    },
    importMeta: {},
  });
  functors[39]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      tameModuleSource: cells[39].tameModuleSource.set,
    },
    importMeta: {},
  });
  functors[40]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "../commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      consoleLevelMethods: cells[40].consoleLevelMethods.set,
      consoleOtherMethods: cells[40].consoleOtherMethods.set,
      makeLoggingConsoleKit: cells[40].makeLoggingConsoleKit.set,
      pumpLogToConsole: cells[40].pumpLogToConsole.set,
      makeCausalConsole: cells[40].makeCausalConsole.set,
      defineCausalConsoleFromLogger: cells[40].defineCausalConsoleFromLogger.set,
      filterConsole: cells[40].filterConsole.set,
    },
    importMeta: {},
  });
  functors[41]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "../commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      makeRejectionHandlers: cells[41].makeRejectionHandlers.set,
    },
    importMeta: {},
  });
  functors[42]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "../commons.js", 0);
      observeImports(map, "./assert.js", 13);
      observeImports(map, "./console.js", 40);
      observeImports(map, "./unhandled-rejection.js", 41);
    },
    liveVar: {
    },
    onceVar: {
      tameConsole: cells[42].tameConsole.set,
    },
    importMeta: {},
  });
  functors[43]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "../commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      filterFileName: cells[43].filterFileName.set,
      shortenCallSiteString: cells[43].shortenCallSiteString.set,
      tameV8ErrorConstructor: cells[43].tameV8ErrorConstructor.set,
    },
    importMeta: {},
  });
  functors[44]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "../commons.js", 0);
      observeImports(map, "../permits.js", 16);
      observeImports(map, "./tame-v8-error-constructor.js", 43);
    },
    liveVar: {
    },
    onceVar: {
      default: cells[44].default.set,
    },
    importMeta: {},
  });
  functors[45]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "@endo/env-options", 3);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./error/assert.js", 13);
    },
    liveVar: {
    },
    onceVar: {
      makeAlias: cells[45].makeAlias.set,
      load: cells[45].load.set,
      loadNow: cells[45].loadNow.set,
    },
    importMeta: {},
  });
  functors[46]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./module-load.js", 45);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./error/assert.js", 13);
    },
    liveVar: {
    },
    onceVar: {
      deferExports: cells[46].deferExports.set,
      getDeferredExports: cells[46].getDeferredExports.set,
    },
    importMeta: {},
  });
  functors[47]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./transforms.js", 33);
      observeImports(map, "./make-safe-evaluator.js", 36);
    },
    liveVar: {
    },
    onceVar: {
      provideCompartmentEvaluator: cells[47].provideCompartmentEvaluator.set,
      compartmentEvaluate: cells[47].compartmentEvaluate.set,
    },
    importMeta: {},
  });
  functors[48]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./error/assert.js", 13);
      observeImports(map, "./module-proxy.js", 46);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./compartment-evaluate.js", 47);
    },
    liveVar: {
    },
    onceVar: {
      makeVirtualModuleInstance: cells[48].makeVirtualModuleInstance.set,
      makeModuleInstance: cells[48].makeModuleInstance.set,
    },
    importMeta: {},
  });
  functors[49]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./error/assert.js", 13);
      observeImports(map, "./module-instance.js", 48);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      link: cells[49].link.set,
      instantiate: cells[49].instantiate.set,
    },
    importMeta: {},
  });
  functors[50]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./global-object.js", 28);
      observeImports(map, "./error/assert.js", 13);
      observeImports(map, "./permits.js", 16);
      observeImports(map, "./module-load.js", 45);
      observeImports(map, "./module-link.js", 49);
      observeImports(map, "./module-proxy.js", 46);
      observeImports(map, "./compartment-evaluate.js", 47);
      observeImports(map, "./make-safe-evaluator.js", 36);
    },
    liveVar: {
    },
    onceVar: {
      InertCompartment: cells[50].InertCompartment.set,
      CompartmentPrototype: cells[50].CompartmentPrototype.set,
      compartmentOptions: cells[50].compartmentOptions.set,
      makeCompartmentConstructor: cells[50].makeCompartmentConstructor.set,
    },
    importMeta: {},
  });
  functors[51]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./compartment.js", 50);
    },
    liveVar: {
    },
    onceVar: {
      getAnonymousIntrinsics: cells[51].getAnonymousIntrinsics.set,
    },
    importMeta: {},
  });
  functors[52]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      tameHarden: cells[52].tameHarden.set,
    },
    importMeta: {},
  });
  functors[53]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      tameSymbolConstructor: cells[53].tameSymbolConstructor.set,
    },
    importMeta: {},
  });
  functors[54]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      tameFauxDataProperty: cells[54].tameFauxDataProperty.set,
      tameFauxDataProperties: cells[54].tameFauxDataProperties.set,
    },
    importMeta: {},
  });
  functors[55]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      tameRegeneratorRuntime: cells[55].tameRegeneratorRuntime.set,
    },
    importMeta: {},
  });
  functors[56]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
    },
    liveVar: {
    },
    onceVar: {
      shimArrayBufferTransfer: cells[56].shimArrayBufferTransfer.set,
    },
    importMeta: {},
  });
  functors[57]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./error/assert.js", 13);
    },
    liveVar: {
    },
    onceVar: {
      chooseReporter: cells[57].chooseReporter.set,
      reportInGroup: cells[57].reportInGroup.set,
    },
    importMeta: {},
  });
  functors[58]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "@endo/env-options", 3);
      observeImports(map, "@endo/immutable-arraybuffer/shim.js", 6);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./make-hardener.js", 14);
      observeImports(map, "./intrinsics.js", 17);
      observeImports(map, "./permits-intrinsics.js", 18);
      observeImports(map, "./tame-function-constructors.js", 19);
      observeImports(map, "./tame-date-constructor.js", 20);
      observeImports(map, "./tame-math-object.js", 21);
      observeImports(map, "./tame-regexp-constructor.js", 22);
      observeImports(map, "./enable-property-overrides.js", 24);
      observeImports(map, "./tame-locale-methods.js", 25);
      observeImports(map, "./global-object.js", 28);
      observeImports(map, "./make-safe-evaluator.js", 36);
      observeImports(map, "./permits.js", 16);
      observeImports(map, "./tame-function-tostring.js", 37);
      observeImports(map, "./tame-domains.js", 38);
      observeImports(map, "./tame-module-source.js", 39);
      observeImports(map, "./error/tame-console.js", 42);
      observeImports(map, "./error/tame-error-constructor.js", 44);
      observeImports(map, "./error/assert.js", 13);
      observeImports(map, "./get-anonymous-intrinsics.js", 51);
      observeImports(map, "./compartment.js", 50);
      observeImports(map, "./tame-harden.js", 52);
      observeImports(map, "./tame-symbol-constructor.js", 53);
      observeImports(map, "./tame-faux-data-properties.js", 54);
      observeImports(map, "./tame-regenerator-runtime.js", 55);
      observeImports(map, "./shim-arraybuffer-transfer.js", 56);
      observeImports(map, "./reporting.js", 57);
    },
    liveVar: {
    },
    onceVar: {
      repairIntrinsics: cells[58].repairIntrinsics.set,
    },
    importMeta: {},
  });
  functors[59]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./assert-sloppy-mode.js", 1);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./lockdown.js", 58);
    },
    liveVar: {
    },
    onceVar: {
    },
    importMeta: {},
  });
  functors[60]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./compartment.js", 50);
      observeImports(map, "./tame-function-tostring.js", 37);
      observeImports(map, "./intrinsics.js", 17);
      observeImports(map, "./reporting.js", 57);
    },
    liveVar: {
    },
    onceVar: {
    },
    importMeta: {},
  });
  functors[61]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./error/assert.js", 13);
    },
    liveVar: {
    },
    onceVar: {
    },
    importMeta: {},
  });
  functors[62]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./commons.js", 0);
      observeImports(map, "./error/console.js", 40);
      observeImports(map, "./error/assert.js", 13);
    },
    liveVar: {
    },
    onceVar: {
    },
    importMeta: {},
  });
  functors[63]({
    imports(entries) {
      const map = new Map(entries);
      observeImports(map, "./src/lockdown-shim.js", 59);
      observeImports(map, "./src/compartment-shim.js", 60);
      observeImports(map, "./src/assert-shim.js", 61);
      observeImports(map, "./src/console-shim.js", 62);
    },
    liveVar: {
    },
    onceVar: {
    },
    importMeta: {},
  });

  return cells[cells.length - 1]['*'].get();
})([
// === 0. ses ./src/commons.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';$h͏_imports([]);/**
 * Captures native intrinsics during initialization, so vetted shims
 * (running between initialization of SES and calling lockdown) are free to
 * modify the environment without compromising the integrity of SES. For
 * example, a vetted shim can modify Object.assign because we capture and
 * export Object and assign here, then never again consult Object to get its
 * assign property.
 *
 * This pattern of use is enforced by eslint rules no-restricted-globals and
 * no-polymorphic-call.
 * We maintain the list of restricted globals in ../package.json.
 *
 * @module
 */

/* global globalThis */
/* eslint-disable no-restricted-globals */

// We cannot use globalThis as the local name since it would capture the
// lexical name.
const universalThis = globalThis;$h͏_once.universalThis(universalThis);


       const {
  Array,
  ArrayBuffer,
  Date,
  FinalizationRegistry,
  Float32Array,
  JSON,
  Map,
  Math,
  Number,
  Object,
  Promise,
  Proxy,
  Reflect,
  RegExp: FERAL_REG_EXP,
  Set,
  String,
  Symbol,
  Uint8Array,
  WeakMap,
  WeakSet,
} = globalThis;$h͏_once.Array(Array);$h͏_once.ArrayBuffer(ArrayBuffer);$h͏_once.Date(Date);$h͏_once.FinalizationRegistry(FinalizationRegistry);$h͏_once.Float32Array(Float32Array);$h͏_once.JSON(JSON);$h͏_once.Map(Map);$h͏_once.Math(Math);$h͏_once.Number(Number);$h͏_once.Object(Object);$h͏_once.Promise(Promise);$h͏_once.Proxy(Proxy);$h͏_once.Reflect(Reflect);$h͏_once.FERAL_REG_EXP(FERAL_REG_EXP);$h͏_once.Set(Set);$h͏_once.String(String);$h͏_once.Symbol(Symbol);$h͏_once.Uint8Array(Uint8Array);$h͏_once.WeakMap(WeakMap);$h͏_once.WeakSet(WeakSet);

       const {
  // The feral Error constructor is safe for internal use, but must not be
  // revealed to post-lockdown code in any compartment including the start
  // compartment since in V8 at least it bears stack inspection capabilities.
  Error: FERAL_ERROR,
  RangeError,
  ReferenceError,
  SyntaxError,
  TypeError,
  AggregateError,
} = globalThis;$h͏_once.FERAL_ERROR(FERAL_ERROR);$h͏_once.RangeError(RangeError);$h͏_once.ReferenceError(ReferenceError);$h͏_once.SyntaxError(SyntaxError);$h͏_once.TypeError(TypeError);$h͏_once.AggregateError(AggregateError);

       const {
  assign,
  create,
  defineProperties,
  entries,
  freeze,
  getOwnPropertyDescriptor,
  getOwnPropertyDescriptors,
  getOwnPropertyNames,
  getPrototypeOf,
  is,
  isFrozen,
  isSealed,
  isExtensible,
  keys,
  prototype: objectPrototype,
  seal,
  preventExtensions,
  setPrototypeOf,
  values,
  fromEntries,
} = Object;$h͏_once.assign(assign);$h͏_once.create(create);$h͏_once.defineProperties(defineProperties);$h͏_once.entries(entries);$h͏_once.freeze(freeze);$h͏_once.getOwnPropertyDescriptor(getOwnPropertyDescriptor);$h͏_once.getOwnPropertyDescriptors(getOwnPropertyDescriptors);$h͏_once.getOwnPropertyNames(getOwnPropertyNames);$h͏_once.getPrototypeOf(getPrototypeOf);$h͏_once.is(is);$h͏_once.isFrozen(isFrozen);$h͏_once.isSealed(isSealed);$h͏_once.isExtensible(isExtensible);$h͏_once.keys(keys);$h͏_once.objectPrototype(objectPrototype);$h͏_once.seal(seal);$h͏_once.preventExtensions(preventExtensions);$h͏_once.setPrototypeOf(setPrototypeOf);$h͏_once.values(values);$h͏_once.fromEntries(fromEntries);

       const {
  species: speciesSymbol,
  toStringTag: toStringTagSymbol,
  iterator: iteratorSymbol,
  matchAll: matchAllSymbol,
  replace: replaceSymbol,
  unscopables: unscopablesSymbol,
  keyFor: symbolKeyFor,
  for: symbolFor,
} = Symbol;$h͏_once.speciesSymbol(speciesSymbol);$h͏_once.toStringTagSymbol(toStringTagSymbol);$h͏_once.iteratorSymbol(iteratorSymbol);$h͏_once.matchAllSymbol(matchAllSymbol);$h͏_once.replaceSymbol(replaceSymbol);$h͏_once.unscopablesSymbol(unscopablesSymbol);$h͏_once.symbolKeyFor(symbolKeyFor);$h͏_once.symbolFor(symbolFor);

       const { isInteger } = Number;$h͏_once.isInteger(isInteger);

       const { stringify: stringifyJson } = JSON;

// Needed only for the Safari bug workaround below
$h͏_once.stringifyJson(stringifyJson);const{defineProperty:originalDefineProperty}=Object;

       const defineProperty = (object, prop, descriptor) => {
  // We used to do the following, until we had to reopen Safari bug
  // https://bugs.webkit.org/show_bug.cgi?id=222538#c17
  // Once this is fixed, we may restore it.
  // // Object.defineProperty is allowed to fail silently so we use
  // // Object.defineProperties instead.
  // return defineProperties(object, { [prop]: descriptor });

  // Instead, to workaround the Safari bug
  const result = originalDefineProperty(object, prop, descriptor);
  if (result !== object) {
    // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_DEFINE_PROPERTY_FAILED_SILENTLY.md
    throw TypeError(
      `Please report that the original defineProperty silently failed to set ${stringifyJson(
        String(prop),
      )}. (SES_DEFINE_PROPERTY_FAILED_SILENTLY)`,
    );
  }
  return result;
};$h͏_once.defineProperty(defineProperty);

       const {
  apply,
  construct,
  get: reflectGet,
  getOwnPropertyDescriptor: reflectGetOwnPropertyDescriptor,
  has: reflectHas,
  isExtensible: reflectIsExtensible,
  ownKeys,
  preventExtensions: reflectPreventExtensions,
  set: reflectSet,
} = Reflect;$h͏_once.apply(apply);$h͏_once.construct(construct);$h͏_once.reflectGet(reflectGet);$h͏_once.reflectGetOwnPropertyDescriptor(reflectGetOwnPropertyDescriptor);$h͏_once.reflectHas(reflectHas);$h͏_once.reflectIsExtensible(reflectIsExtensible);$h͏_once.ownKeys(ownKeys);$h͏_once.reflectPreventExtensions(reflectPreventExtensions);$h͏_once.reflectSet(reflectSet);

       const { isArray, prototype: arrayPrototype } = Array;$h͏_once.isArray(isArray);$h͏_once.arrayPrototype(arrayPrototype);
       const { prototype: arrayBufferPrototype } = ArrayBuffer;$h͏_once.arrayBufferPrototype(arrayBufferPrototype);
       const { prototype: mapPrototype } = Map;$h͏_once.mapPrototype(mapPrototype);
       const { revocable: proxyRevocable } = Proxy;$h͏_once.proxyRevocable(proxyRevocable);
       const { prototype: regexpPrototype } = RegExp;$h͏_once.regexpPrototype(regexpPrototype);
       const { prototype: setPrototype } = Set;$h͏_once.setPrototype(setPrototype);
       const { prototype: stringPrototype } = String;$h͏_once.stringPrototype(stringPrototype);
       const { prototype: weakmapPrototype } = WeakMap;$h͏_once.weakmapPrototype(weakmapPrototype);
       const { prototype: weaksetPrototype } = WeakSet;$h͏_once.weaksetPrototype(weaksetPrototype);
       const { prototype: functionPrototype } = Function;$h͏_once.functionPrototype(functionPrototype);
       const { prototype: promisePrototype } = Promise;$h͏_once.promisePrototype(promisePrototype);
       const { prototype: generatorPrototype } = getPrototypeOf(
  // eslint-disable-next-line no-empty-function, func-names
  function* () {},
);$h͏_once.generatorPrototype(generatorPrototype);
       const iteratorPrototype = getPrototypeOf(
  // eslint-disable-next-line @endo/no-polymorphic-call
  getPrototypeOf(arrayPrototype.values()),
);$h͏_once.iteratorPrototype(iteratorPrototype);

       const typedArrayPrototype = getPrototypeOf(Uint8Array.prototype);$h͏_once.typedArrayPrototype(typedArrayPrototype);

const { bind } = functionPrototype;

/**
 * uncurryThis()
 * Equivalent of: fn => (thisArg, ...args) => apply(fn, thisArg, args)
 *
 * See those reference for a complete explanation:
 * http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
 * which only lives at
 * http://web.archive.org/web/20160805225710/http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
 *
 * @type {<F extends (this: any, ...args: any[]) => any>(fn: F) => ((thisArg: ThisParameterType<F>, ...args: Parameters<F>) => ReturnType<F>)}
 */
       const uncurryThis = bind.bind(bind.call); // eslint-disable-line @endo/no-polymorphic-call

// See https://github.com/endojs/endo/issues/2930
$h͏_once.uncurryThis(uncurryThis);if(!('hasOwn'in Object)){
  const ObjectPrototypeHasOwnProperty = objectPrototype.hasOwnProperty;
  const hasOwnShim = (obj, key) => {
    if (obj === undefined || obj === null) {
      // We need to add this extra test because of differences in
      // the order in which `hasOwn` vs `hasOwnProperty` validates
      // arguments.
      throw TypeError('Cannot convert undefined or null to object');
    }
    return apply(ObjectPrototypeHasOwnProperty, obj, [key]);
  };
  defineProperty(Object, 'hasOwn', {
    value: hasOwnShim,
    writable: true,
    enumerable: false,
    configurable: true,
  });
}

       const { hasOwn } = Object;
//
$h͏_once.hasOwn(hasOwn);const arrayFilter=uncurryThis(arrayPrototype.filter);$h͏_once.arrayFilter(arrayFilter);
       const arrayForEach = uncurryThis(arrayPrototype.forEach);$h͏_once.arrayForEach(arrayForEach);
       const arrayIncludes = uncurryThis(arrayPrototype.includes);$h͏_once.arrayIncludes(arrayIncludes);
       const arrayJoin = uncurryThis(arrayPrototype.join);
/** @type {<T, U>(thisArg: readonly T[], callbackfn: (value: T, index: number, array: T[]) => U, cbThisArg?: any) => U[]} */$h͏_once.arrayJoin(arrayJoin);
       const arrayMap = /** @type {any} */ (uncurryThis(arrayPrototype.map));$h͏_once.arrayMap(arrayMap);
       const arrayFlatMap = /** @type {any} */ (
  uncurryThis(arrayPrototype.flatMap)
);$h͏_once.arrayFlatMap(arrayFlatMap);
       const arrayPop = uncurryThis(arrayPrototype.pop);
/** @type {<T>(thisArg: T[], ...items: T[]) => number} */$h͏_once.arrayPop(arrayPop);
       const arrayPush = uncurryThis(arrayPrototype.push);$h͏_once.arrayPush(arrayPush);
       const arraySlice = uncurryThis(arrayPrototype.slice);$h͏_once.arraySlice(arraySlice);
       const arraySome = uncurryThis(arrayPrototype.some);$h͏_once.arraySome(arraySome);
       const arraySort = uncurryThis(arrayPrototype.sort);$h͏_once.arraySort(arraySort);
       const iterateArray = uncurryThis(arrayPrototype[iteratorSymbol]);
//
$h͏_once.iterateArray(iterateArray);const arrayBufferSlice=uncurryThis(arrayBufferPrototype.slice);
/** @type {(b: ArrayBuffer) => number} */$h͏_once.arrayBufferSlice(arrayBufferSlice);
       const arrayBufferGetByteLength = uncurryThis(
  // @ts-expect-error we know it is there on all conforming platforms
  getOwnPropertyDescriptor(arrayBufferPrototype, 'byteLength').get,
);
//
$h͏_once.arrayBufferGetByteLength(arrayBufferGetByteLength);const typedArraySet=uncurryThis(typedArrayPrototype.set);
//
$h͏_once.typedArraySet(typedArraySet);const mapSet=uncurryThis(mapPrototype.set);$h͏_once.mapSet(mapSet);
       const mapGet = uncurryThis(mapPrototype.get);$h͏_once.mapGet(mapGet);
       const mapHas = uncurryThis(mapPrototype.has);$h͏_once.mapHas(mapHas);
       const mapDelete = uncurryThis(mapPrototype.delete);$h͏_once.mapDelete(mapDelete);
       const mapEntries = uncurryThis(mapPrototype.entries);$h͏_once.mapEntries(mapEntries);
       const iterateMap = uncurryThis(mapPrototype[iteratorSymbol]);
//
$h͏_once.iterateMap(iterateMap);const setAdd=uncurryThis(setPrototype.add);$h͏_once.setAdd(setAdd);
       const setDelete = uncurryThis(setPrototype.delete);$h͏_once.setDelete(setDelete);
       const setForEach = uncurryThis(setPrototype.forEach);$h͏_once.setForEach(setForEach);
       const setHas = uncurryThis(setPrototype.has);$h͏_once.setHas(setHas);
       const iterateSet = uncurryThis(setPrototype[iteratorSymbol]);
//
/**
 * `regexpExec` is provided in exclusion of `regexpTest`, which would be
 * vulnerable to RegExp.prototype poisoning.
 */$h͏_once.iterateSet(iterateSet);
       const regexpExec = uncurryThis(regexpPrototype.exec);
/**
 * @type { &
 *   ((thisArg: RegExp, string: string, replaceValue: string) => string) &
 *   ((thisArg: RegExp, string: string, replacer: (substring: string, ...args: any[]) => string) => string)
 * }
 */$h͏_once.regexpExec(regexpExec);
       const regexpReplace = /** @type {any} */ (
  uncurryThis(regexpPrototype[replaceSymbol])
);$h͏_once.regexpReplace(regexpReplace);
       const matchAllRegExp = uncurryThis(regexpPrototype[matchAllSymbol]);$h͏_once.matchAllRegExp(matchAllRegExp);
const { _regexpConstructor, ...regexpDescriptors } =
  getOwnPropertyDescriptors(regexpPrototype);
arrayForEach(ownKeys(regexpDescriptors), key => {
  const desc = regexpDescriptors[/** @type {any} */ (key)];
  desc.configurable = false;
  if (desc.writable) desc.writable = false;
});
/**
 * Protect a RegExp instance against RegExp.prototype poisoning ("exec",
 * "flags", Symbol.replace, etc.).
 * @type {<T extends RegExp>(regexp: T) => T}
 */
       const sealRegexp = regexp =>
  seal(defineProperties(regexp, regexpDescriptors));
//
$h͏_once.sealRegexp(sealRegexp);const stringEndsWith=uncurryThis(stringPrototype.endsWith);$h͏_once.stringEndsWith(stringEndsWith);
       const stringIncludes = uncurryThis(stringPrototype.includes);$h͏_once.stringIncludes(stringIncludes);
       const stringIndexOf = uncurryThis(stringPrototype.indexOf);$h͏_once.stringIndexOf(stringIndexOf);
       const stringMatch = uncurryThis(stringPrototype.match);
// `stringReplace` is intentionally omitted because it would be vulnerable to
// RegExp.prototype poisoning; use `regexpReplace(re, str, replacer)` instead
// (and `sealRegexp` on its regular expressions).
$h͏_once.stringMatch(stringMatch);const stringSearch=uncurryThis(stringPrototype.search);$h͏_once.stringSearch(stringSearch);
       const stringSlice = uncurryThis(stringPrototype.slice);
/**
 * `stringSplit` should only be used with a string separator; regular
 * expressions are vulnerable to RegExp.prototype poisoning.
 * @type {(thisArg: string, separator: string, limit?: number) => string[]}
 */$h͏_once.stringSlice(stringSlice);
       const stringSplit = /** @type {any} */ (
  uncurryThis(stringPrototype.split)
);$h͏_once.stringSplit(stringSplit);
       const stringStartsWith = uncurryThis(stringPrototype.startsWith);$h͏_once.stringStartsWith(stringStartsWith);
       const iterateString = uncurryThis(stringPrototype[iteratorSymbol]);
//
$h͏_once.iterateString(iterateString);const weakmapDelete=uncurryThis(weakmapPrototype.delete);
/** @type {<K extends {}, V>(thisArg: WeakMap<K, V>, ...args: Parameters<WeakMap<K,V>['get']>) => ReturnType<WeakMap<K,V>['get']>} */$h͏_once.weakmapDelete(weakmapDelete);
       const weakmapGet = uncurryThis(weakmapPrototype.get);$h͏_once.weakmapGet(weakmapGet);
       const weakmapHas = uncurryThis(weakmapPrototype.has);$h͏_once.weakmapHas(weakmapHas);
       const weakmapSet = uncurryThis(weakmapPrototype.set);
//
$h͏_once.weakmapSet(weakmapSet);const weaksetAdd=uncurryThis(weaksetPrototype.add);$h͏_once.weaksetAdd(weaksetAdd);
       const weaksetHas = uncurryThis(weaksetPrototype.has);
//
$h͏_once.weaksetHas(weaksetHas);const functionToString=uncurryThis(functionPrototype.toString);$h͏_once.functionToString(functionToString);
       const functionBind = uncurryThis(bind);
//
$h͏_once.functionBind(functionBind);const generatorNext=uncurryThis(generatorPrototype.next);$h͏_once.generatorNext(generatorNext);
       const generatorThrow = uncurryThis(generatorPrototype.throw);
//
$h͏_once.generatorThrow(generatorThrow);const{all}=Promise;
       const promiseAll = promises => apply(all, Promise, [promises]);$h͏_once.promiseAll(promiseAll);
       const promiseCatch = uncurryThis(promisePrototype.catch);
/** @type {<T, TResult1 = T, TResult2 = never>(thisArg: T, onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null) => Promise<TResult1 | TResult2>} */$h͏_once.promiseCatch(promiseCatch);
       const promiseThen = /** @type {any} */ (
  uncurryThis(promisePrototype.then)
);
//
$h͏_once.promiseThen(promiseThen);const finalizationRegistryRegister=
  FinalizationRegistry && uncurryThis(FinalizationRegistry.prototype.register);$h͏_once.finalizationRegistryRegister(finalizationRegistryRegister);
       const finalizationRegistryUnregister =
  FinalizationRegistry &&
  uncurryThis(FinalizationRegistry.prototype.unregister);

/**
 * TODO Consolidate with `isPrimitive` that's currently in `@endo/pass-style`.
 * Layering constraints make this tricky, which is why we haven't yet figured
 * out how to do this.
 *
 * @type {(val: unknown) => val is (undefined
 * | null
 * | boolean
 * | number
 * | bigint
 * | string
 * | symbol)}
 */$h͏_once.finalizationRegistryUnregister(finalizationRegistryUnregister);
       const isPrimitive = val =>
  !val || (typeof val !== 'object' && typeof val !== 'function');

/**
 * isError tests whether an object inherits from the intrinsic
 * `Error.prototype`.
 * We capture the original error constructor as FERAL_ERROR to provide a clear
 * signal for reviewers that we are handling an object with excess authority,
 * like stack trace inspection, that we are carefully hiding from client code.
 * Checking instanceof happens to be safe, but to avoid uttering FERAL_ERROR
 * for such a trivial case outside commons.js, we provide a utility function.
 *
 * @param {any} value
 */$h͏_once.isPrimitive(isPrimitive);
       const isError = value => value instanceof FERAL_ERROR;

/**
 * @template T
 * @param {T} x
 */$h͏_once.isError(isError);
       const identity = x => x;

// The original unsafe untamed eval function, which must not escape.
// Sample at module initialization time, which is before lockdown can
// repair it.  Use it only to build powerless abstractions.
// eslint-disable-next-line no-eval
$h͏_once.identity(identity);const FERAL_EVAL=eval;

// The original unsafe untamed Function constructor, which must not escape.
// Sample at module initialization time, which is before lockdown can
// repair it.  Use it only to build powerless abstractions.
$h͏_once.FERAL_EVAL(FERAL_EVAL);const FERAL_FUNCTION=Function;$h͏_once.FERAL_FUNCTION(FERAL_FUNCTION);

       const noEvalEvaluate = () => {
  // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_NO_EVAL.md
  throw TypeError('Cannot eval with evalTaming set to "no-eval" (SES_NO_EVAL)');
};

// ////////////////// FERAL_STACK_GETTER FERAL_STACK_SETTER ////////////////////

// The error repair mechanism is very similar to code in
// pass-style/src/error.js and these implementations should be kept in sync.

/**
 * We gratuitiously construct a TypeError instance using syntax in order to
 * obviate the possibility that code that ran before SES (for which we are
 * irreducable vulnerable) may have replaced the global TypeError constructor.
 * We treat the nature of this error instance as the source of truth for the
 * nature of runtime constructed errors on the platform, particularly whether
 * such errors will have an own "stack" property with getters and setters.
 * At time of writing (2025) we know of no comparable mechanism for obtaining a
 * host-generated base Error instance, but we corroborate the nature of the
 * global Error constructor's instances and refuse to initialize SES in an
 * environment where the syntactic TypeError and global Error produce
 * inconsistent "stack" properties.
 * @returns {TypeError}
 */$h͏_once.noEvalEvaluate(noEvalEvaluate);
const makeTypeError = () => {
  try {
    // @ts-expect-error deliberate TypeError
    null.null;
    throw TypeError('obligatory'); // To convince the type flow inferrence.
  } catch (error) {
    return error;
  }
};

const errorStackDesc = getOwnPropertyDescriptor(Error('obligatory'), 'stack');
const typeErrorStackDesc = getOwnPropertyDescriptor(makeTypeError(), 'stack');

let feralStackGetter;
let feralStackSetter;
if (typeErrorStackDesc && typeErrorStackDesc.get) {
  // We should only encounter this case on v8 because of its problematic
  // error own stack accessor behavior.
  // Note that FF/SpiderMonkey, Moddable/XS, and the error stack proposal
  // all inherit a stack accessor property from Error.prototype, which is
  // great. That case needs no heroics to secure.
  if (
    // In the v8 case as we understand it, all errors have an own stack
    // accessor property, but within the same realm, all these accessor
    // properties have the same getter and have the same setter.
    // This is therefore the case that we repair.
    errorStackDesc &&
    typeof typeErrorStackDesc.get === 'function' &&
    typeErrorStackDesc.get === errorStackDesc.get &&
    typeof typeErrorStackDesc.set === 'function' &&
    typeErrorStackDesc.set === errorStackDesc.set
  ) {
    // Otherwise, we have own stack accessor properties that are outside
    // our expectations, that therefore need to be understood better
    // before we know how to repair them.
    feralStackGetter = freeze(typeErrorStackDesc.get);
    feralStackSetter = freeze(typeErrorStackDesc.set);
  } else {
    // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNEXPECTED_ERROR_OWN_STACK_ACCESSOR.md
    throw TypeError(
      'Unexpected Error own stack accessor functions (SES_UNEXPECTED_ERROR_OWN_STACK_ACCESSOR)',
    );
  }
}

/**
 * If on a v8 with the problematic error own stack accessor behavior,
 * `FERAL_STACK_GETTER` will be the shared getter of all those accessors
 * and `FERAL_STACK_SETTER` will be the shared setter. On any platform
 * without this problem, `FERAL_STACK_GETTER` and `FERAL_STACK_SETTER` are
 * both `undefined`.
 *
 * @type {(() => any) | undefined}
 */
       const FERAL_STACK_GETTER = feralStackGetter;

/**
 * If on a v8 with the problematic error own stack accessor behavior,
 * `FERAL_STACK_GETTER` will be the shared getter of all those accessors
 * and `FERAL_STACK_SETTER` will be the shared setter. On any platform
 * without this problem, `FERAL_STACK_GETTER` and `FERAL_STACK_SETTER` are
 * both `undefined`.
 *
 * @type {((newValue: any) => void) | undefined}
 */$h͏_once.FERAL_STACK_GETTER(FERAL_STACK_GETTER);
       const FERAL_STACK_SETTER = feralStackSetter;$h͏_once.FERAL_STACK_SETTER(FERAL_STACK_SETTER);

const getAsyncGeneratorFunctionInstance = () => {
  // Test for async generator function syntax support.
  try {
    // Wrapping one in an new Function lets the `hermesc` binary file
    // parse the Metro js bundle without SyntaxError, to generate the
    // optimised Hermes bytecode bundle, when `gradlew` is called to
    // assemble the release build APK for React Native prod Android apps.
    // Delaying the error until runtime lets us customise lockdown behaviour.
    return new FERAL_FUNCTION(
      'return (async function* AsyncGeneratorFunctionInstance() {})',
    )();
  } catch (error) {
    // Note: `Error.prototype.jsEngine` is only set by React Native runtime, not Hermes:
    // https://github.com/facebook/react-native/blob/main/packages/react-native/ReactCommon/hermes/executor/HermesExecutorFactory.cpp#L224-L230
    if (error.name === 'SyntaxError') {
      // Swallows Hermes error `async generators are unsupported` at runtime.
      // Note: `console` is not a JS built-in, so Hermes engine throws:
      // Uncaught ReferenceError: Property 'console' doesn't exist
      // See: https://github.com/facebook/hermes/issues/675
      // However React Native provides a `console` implementation when setting up error handling:
      // https://github.com/facebook/react-native/blob/main/packages/react-native/Libraries/Core/InitializeCore.js
      return undefined;
    } else if (error.name === 'EvalError') {
      // eslint-disable-next-line no-empty-function
      return async function* AsyncGeneratorFunctionInstance() {};
    } else {
      throw error;
    }
  }
};

/**
 * If the platform supports async generator functions, this will be an
 * async generator function instance. Otherwise, it will be `undefined`.
 *
 * @type {AsyncGeneratorFunction | undefined}
 */
       const AsyncGeneratorFunctionInstance =
  getAsyncGeneratorFunctionInstance();$h͏_once.AsyncGeneratorFunctionInstance(AsyncGeneratorFunctionInstance);
})()
,
// === 1. ses ./src/assert-sloppy-mode.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let TypeError;$h͏_imports([["./commons.js", [["TypeError",[$h͏_a => (TypeError = $h͏_a)]]]]]);

/** getThis returns globalThis in sloppy mode or undefined in strict mode. */
function getThis() {
  return this;
}

if (getThis()) {
  // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_NO_SLOPPY.md
  throw TypeError(`SES failed to initialize, sloppy mode (SES_NO_SLOPPY)`);
}
})()
,
// === 2. env-options ./src/env-options.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';$h͏_imports([]);/* global globalThis */
// @ts-check

// `@endo/env-options` needs to be imported quite early, and so should
// avoid importing from ses or anything that depends on ses.

// /////////////////////////////////////////////////////////////////////////////
// Prelude of cheap good - enough imitations of things we'd use or
// do differently if we could depend on ses

// eslint-disable-next-line no-restricted-globals
const localThis = globalThis;

const { Object, Reflect, Array, String, JSON, Error } = localThis;
const { freeze } = Object;
const { apply } = Reflect;

// Should be equivalent to the one in ses' commons.js even though it
// uses the other technique.
const uncurryThis =
  fn =>
  (receiver, ...args) =>
    apply(fn, receiver, args);
const arrayPush = uncurryThis(Array.prototype.push);
const arrayIncludes = uncurryThis(Array.prototype.includes);
const stringSplit = uncurryThis(String.prototype.split);

const q = JSON.stringify;

const Fail = (literals, ...args) => {
  let msg = literals[0];
  for (let i = 0; i < args.length; i += 1) {
    msg = `${msg}${args[i]}${literals[i + 1]}`;
  }
  throw Error(msg);
};

// end prelude
// /////////////////////////////////////////////////////////////////////////////

/**
 * `makeEnvironmentCaptor` provides a mechanism for getting environment
 * variables, if they are needed, and a way to catalog the names of all
 * the environment variables that were captured.
 *
 * @param {object} aGlobal
 * @param {boolean} [dropNames] Defaults to false. If true, don't track
 * names used.
 */
       const makeEnvironmentCaptor = (aGlobal, dropNames = false) => {
  /** @type {string[]} */
  const capturedEnvironmentOptionNames = [];

  /**
   * Gets an environment option by name and returns the option value or the
   * given default.
   *
   * @param {string} optionName
   * @param {string} defaultSetting
   * @param {string[]} [optOtherValues]
   * If provided, the option value must be included or match `defaultSetting`.
   * @returns {string}
   */
  const getEnvironmentOption = (
    optionName,
    defaultSetting,
    optOtherValues = undefined,
  ) => {
    typeof optionName === 'string' ||
      Fail`Environment option name ${q(optionName)} must be a string.`;
    typeof defaultSetting === 'string' ||
      Fail`Environment option default setting ${q(
        defaultSetting,
      )} must be a string.`;

    /** @type {string} */
    let setting = defaultSetting;
    const globalProcess = aGlobal.process || undefined;
    const globalEnv =
      (typeof globalProcess === 'object' && globalProcess.env) || undefined;
    if (typeof globalEnv === 'object') {
      if (optionName in globalEnv) {
        if (!dropNames) {
          arrayPush(capturedEnvironmentOptionNames, optionName);
        }
        const optionValue = globalEnv[optionName];
        // eslint-disable-next-line @endo/no-polymorphic-call
        typeof optionValue === 'string' ||
          Fail`Environment option named ${q(
            optionName,
          )}, if present, must have a corresponding string value, got ${q(
            optionValue,
          )}`;
        setting = optionValue;
      }
    }
    optOtherValues === undefined ||
      setting === defaultSetting ||
      arrayIncludes(optOtherValues, setting) ||
      Fail`Unrecognized ${q(optionName)} value ${q(
        setting,
      )}. Expected one of ${q([defaultSetting, ...optOtherValues])}`;
    return setting;
  };
  freeze(getEnvironmentOption);

  /**
   * @template {string} [T=string]
   * @param {string} optionName
   * @returns {T[]}
   */
  const getEnvironmentOptionsList = optionName => {
    const option = getEnvironmentOption(optionName, '');
    return freeze(option === '' ? [] : stringSplit(option, ','));
  };
  freeze(getEnvironmentOptionsList);

  /**
   * @template {string} [T=string]
   * @param {string} optionName
   * @param {T} element
   * @returns {boolean}
   */
  const environmentOptionsListHas = (optionName, element) =>
    arrayIncludes(getEnvironmentOptionsList(optionName), element);

  const getCapturedEnvironmentOptionNames = () => {
    return freeze([...capturedEnvironmentOptionNames]);
  };
  freeze(getCapturedEnvironmentOptionNames);

  return freeze({
    getEnvironmentOption,
    getEnvironmentOptionsList,
    environmentOptionsListHas,
    getCapturedEnvironmentOptionNames,
  });
};$h͏_once.makeEnvironmentCaptor(makeEnvironmentCaptor);
freeze(makeEnvironmentCaptor);

/**
 * For the simple case, where the global in question is `globalThis` and no
 * reporting of option names is desired.
 */
       const {
  getEnvironmentOption,
  getEnvironmentOptionsList,
  environmentOptionsListHas,
} = makeEnvironmentCaptor(localThis, true);$h͏_once.getEnvironmentOption(getEnvironmentOption);$h͏_once.getEnvironmentOptionsList(getEnvironmentOptionsList);$h͏_once.environmentOptionsListHas(environmentOptionsListHas);
})()
,
// === 3. env-options ./index.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';$h͏_imports([["./src/env-options.js", []]]);
})()
,
// === 4. immutable-arraybuffer ./src/immutable-arraybuffer-pony.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';$h͏_imports([]);/* global globalThis */

const {
  ArrayBuffer,
  Object,
  Reflect,
  Symbol,
  TypeError,
  Uint8Array,
  WeakMap,
  // Capture structuredClone before it can be scuttled.
  structuredClone: optStructuredClone
  // eslint-disable-next-line no-restricted-globals
} = globalThis;

const { freeze, defineProperty, getPrototypeOf, getOwnPropertyDescriptor } =
  Object;
const { apply, ownKeys } = Reflect;
const { toStringTag } = Symbol;

const { prototype: arrayBufferPrototype } = ArrayBuffer;
const { slice, transfer: optTransfer } = arrayBufferPrototype;
// @ts-expect-error TS doesn't know it'll be there
const { get: arrayBufferByteLength } = getOwnPropertyDescriptor(
  arrayBufferPrototype,
  'byteLength',
);

const typedArrayPrototype = getPrototypeOf(Uint8Array.prototype);
const { set: uint8ArraySet } = typedArrayPrototype;
// @ts-expect-error TS doesn't know it'll be there
const { get: uint8ArrayBuffer } = getOwnPropertyDescriptor(
  typedArrayPrototype,
  'buffer',
);

/**
 * Copy a range of values from a genuine ArrayBuffer exotic object into a new
 * ArrayBuffer.
 *
 * @param {ArrayBuffer} realBuffer
 * @param {number} [start]
 * @param {number} [end]
 * @returns {ArrayBuffer}
 */
const arrayBufferSlice = (realBuffer, start = undefined, end = undefined) =>
  apply(slice, realBuffer, [start, end]);

/**
 * Move the contents of a genuine ArrayBuffer exotic object into a new fresh
 * ArrayBuffer and detach the original source.
 * We can only do this on platforms that support `structuredClone` or
 * `ArrayBuffer.prototype.transfer`.
 * On other platforms, we can still emulate
 * `ArrayBuffer.prototoype.sliceToImmutable`, but not
 * `ArrayBuffer.prototype.transferToImmutable`.
 * Currently, these known-deficient platforms are
 * - Hermes
 * - Node.js <= 16
 * - Apparently some versions of JavaScriptCore that are still of concern.
 *
 * @param {ArrayBuffer} arrayBuffer
 * @returns {ArrayBuffer}
 */
let optArrayBufferTransfer;

if (optTransfer) {
  optArrayBufferTransfer = arrayBuffer => apply(optTransfer, arrayBuffer, []);
} else if (optStructuredClone) {
  optArrayBufferTransfer = arrayBuffer => {
    // Hopefully, a zero-length slice is cheap, but still enforces that
    // `arrayBuffer` is a genuine `ArrayBuffer` exotic object.
    arrayBufferSlice(arrayBuffer, 0, 0);
    return optStructuredClone(arrayBuffer, {
      transfer: [arrayBuffer],
    });
  };
} else {
  // Assignment is redundant, but remains for clarity.
  optArrayBufferTransfer = undefined;
}

/**
 * If we could use classes with private fields everywhere, this would have
 * been a `this.#buffer` private field on an `ImmutableArrayBufferInternal`
 * class. But we cannot do so on Hermes. So, instead, we
 * emulate the `this.#buffer` private field, including its use as a brand check.
 * Maps from all and only emulated Immutable ArrayBuffers to real ArrayBuffers.
 *
 * @type {Pick<WeakMap<ArrayBuffer, ArrayBuffer>, 'get' | 'has' | 'set'>}
 */
const buffers = new WeakMap();
// Avoid post-hoc prototype lookups.
for (const methodName of ['get', 'has', 'set']) {
  defineProperty(buffers, methodName, { value: buffers[methodName] });
}
const getBuffer = immuAB => {
  // Safe because this WeakMap owns its get method.
  // eslint-disable-next-line @endo/no-polymorphic-call
  const result = buffers.get(immuAB);
  if (result) {
    return result;
  }
  throw TypeError('Not an emulated Immutable ArrayBuffer');
};

// Omits `constructor` so `Array.prototype.constructor` is inherited.
const ImmutableArrayBufferInternalPrototype = {
  __proto__: arrayBufferPrototype,
  get byteLength() {
    return apply(arrayBufferByteLength, getBuffer(this), []);
  },
  get detached() {
    getBuffer(this); // shim brand check
    return false;
  },
  get maxByteLength() {
    // Not underlying maxByteLength, which is irrelevant
    return apply(arrayBufferByteLength, getBuffer(this), []);
  },
  get resizable() {
    getBuffer(this); // shim brand check
    return false;
  },
  get immutable() {
    getBuffer(this); // shim brand check
    return true;
  },
  slice(start = undefined, end = undefined) {
    return arrayBufferSlice(getBuffer(this), start, end);
  },
  sliceToImmutable(start = undefined, end = undefined) {
    // eslint-disable-next-line no-use-before-define
    return sliceBufferToImmutable(getBuffer(this), start, end);
  },
  resize(_newByteLength = undefined) {
    getBuffer(this); // shim brand check
    throw TypeError('Cannot resize an immutable ArrayBuffer');
  },
  transfer(_newLength = undefined) {
    getBuffer(this); // shim brand check
    throw TypeError('Cannot detach an immutable ArrayBuffer');
  },
  transferToFixedLength(_newLength = undefined) {
    getBuffer(this); // shim brand check
    throw TypeError('Cannot detach an immutable ArrayBuffer');
  },
  transferToImmutable(_newLength = undefined) {
    getBuffer(this); // shim brand check
    throw TypeError('Cannot detach an immutable ArrayBuffer');
  },
  /**
   * See https://github.com/endojs/endo/tree/master/packages/immutable-arraybuffer#purposeful-violation
   */
  [toStringTag]: 'ImmutableArrayBuffer',
};

// Better fidelity emulation of a class prototype
for (const key of ownKeys(ImmutableArrayBufferInternalPrototype)) {
  defineProperty(ImmutableArrayBufferInternalPrototype, key, {
    enumerable: false,
  });
}

/**
 * Emulates what would have been the encapsulated `ImmutableArrayBufferInternal`
 * class constructor. This function takes the `realBuffer` which its
 * result encapsulates. Security demands that this result has exclusive access
 * to the `realBuffer` it is given, which its callers must ensure.
 *
 * @param {ArrayBuffer} realBuffer
 * @returns {ArrayBuffer}
 */
const makeImmutableArrayBufferInternal = realBuffer => {
  const result = /** @type {ArrayBuffer} */ (
    /** @type {unknown} */ ({
      __proto__: ImmutableArrayBufferInternalPrototype,
    })
  );
  // Safe because this WeakMap owns its set method.
  // eslint-disable-next-line @endo/no-polymorphic-call
  buffers.set(result, realBuffer);
  return result;
};
// Since `makeImmutableArrayBufferInternal` MUST not escape,
// this `freeze` is just belt-and-suspenders.
freeze(makeImmutableArrayBufferInternal);

/**
 * @param {ArrayBuffer} buffer
 * @returns {boolean}
 */
// eslint-disable-next-line @endo/no-polymorphic-call
       const isBufferImmutable = buffer => buffers.has(buffer);

/**
 * Creates an immutable slice of the given buffer.
 * @param {ArrayBuffer} buffer The original buffer.
 * @param {number} [start] The start index.
 * @param {number} [end] The end index.
 * @returns {ArrayBuffer} The sliced immutable ArrayBuffer.
 */$h͏_once.isBufferImmutable(isBufferImmutable);
       const sliceBufferToImmutable = (
  buffer,
  start = undefined,
  end = undefined,
) => {
  // Safe because this WeakMap owns its get method.
  // eslint-disable-next-line @endo/no-polymorphic-call
  let realBuffer = buffers.get(buffer);
  if (realBuffer === undefined) {
    realBuffer = buffer;
  }
  return makeImmutableArrayBufferInternal(
    arrayBufferSlice(realBuffer, start, end),
  );
};$h͏_once.sliceBufferToImmutable(sliceBufferToImmutable);

let transferBufferToImmutable;
if (optArrayBufferTransfer) {
  /**
   * Transfer the contents to a new Immutable ArrayBuffer
   *
   * @param {ArrayBuffer} buffer The original buffer.
   * @param {number} [newLength] The start index.
   * @returns {ArrayBuffer}
   */
  transferBufferToImmutable = (buffer, newLength = undefined) => {
    if (newLength === undefined) {
      buffer = optArrayBufferTransfer(buffer);
    } else if (optTransfer) {
      buffer = apply(optTransfer, buffer, [newLength]);
    } else {
      buffer = optArrayBufferTransfer(buffer);
      const oldLength = buffer.byteLength;
      // eslint-disable-next-line @endo/restrict-comparison-operands
      if (newLength <= oldLength) {
        buffer = arrayBufferSlice(buffer, 0, newLength);
      } else {
        const oldTA = new Uint8Array(buffer);
        const newTA = new Uint8Array(newLength);
        apply(uint8ArraySet, newTA, [oldTA]);
        buffer = apply(uint8ArrayBuffer, newTA, []);
      }
    }
    const result = makeImmutableArrayBufferInternal(buffer);
    return /** @type {ArrayBuffer} */ (/** @type {unknown} */ (result));
  };
} else {
  transferBufferToImmutable = undefined;
}

       const optTransferBufferToImmutable = transferBufferToImmutable;$h͏_once.optTransferBufferToImmutable(optTransferBufferToImmutable);
})()
,
// === 5. immutable-arraybuffer ./src/immutable-arraybuffer-shim.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let isBufferImmutable,sliceBufferToImmutable,optXferBuf2Immu;$h͏_imports([["./immutable-arraybuffer-pony.js", [["isBufferImmutable",[$h͏_a => (isBufferImmutable = $h͏_a)]],["sliceBufferToImmutable",[$h͏_a => (sliceBufferToImmutable = $h͏_a)]],["optTransferBufferToImmutable",[$h͏_a => (optXferBuf2Immu = $h͏_a)]]]]]);







const {
  ArrayBuffer,
  JSON,
  Object,
  Reflect
  // eslint-disable-next-line no-restricted-globals
} = globalThis;

// Even though the imported one is not exported by the pony as a live binding,
// TS doesn't know that,
// so it cannot do its normal flow-based inference. By making and using a local
// copy, no problem.
const optTransferBufferToImmutable = optXferBuf2Immu;

const { getOwnPropertyDescriptors, defineProperties, defineProperty } = Object;
const { ownKeys } = Reflect;
const { prototype: arrayBufferPrototype } = ArrayBuffer;
const { stringify } = JSON;

const arrayBufferMethods = {
  /**
   * Creates an immutable slice of the given buffer.
   *
   * @this {ArrayBuffer} buffer The original buffer.
   * @param {number} [start] The start index.
   * @param {number} [end] The end index.
   * @returns {ArrayBuffer} The sliced immutable ArrayBuffer.
   */
  sliceToImmutable(start = undefined, end = undefined) {
    return sliceBufferToImmutable(this, start, end);
  },

  /**
   * @this {ArrayBuffer}
   */
  get immutable() {
    return isBufferImmutable(this);
  },

  ...(optTransferBufferToImmutable
    ? {
        /**
         * Transfer the contents to a new immutable ArrayBuffer
         *
         * @this {ArrayBuffer} buffer The original buffer.
         * @param {number} [newLength] The start index.
         * @returns {ArrayBuffer} The new immutable ArrayBuffer.
         */
        transferToImmutable(newLength = undefined) {
          return optTransferBufferToImmutable(this, newLength);
        },
      }
    : {}),
};

// Better fidelity emulation of a class prototype
for (const key of ownKeys(arrayBufferMethods)) {
  defineProperty(arrayBufferMethods, key, {
    enumerable: false,
  });
}

// Modern shim practice frowns on conditional installation, at least for
// proposals prior to stage 3. This is so changes to the proposal since
// an old shim was distributed don't need to worry about the proposal
// breaking old code depending on the old shim. Thus, if we detect that
// we're about to overwrite a prior installation, we simply issue this
// warning and continue.
//
// TODO, if the primordials are frozen after the prior implementation, such as
// by `lockdown`, then this precludes overwriting as expected. However, for
// this case, the following warning text will be confusing.
//
// Allowing polymorphic calls because these occur during initialization.
// eslint-disable-next-line @endo/no-polymorphic-call
const overwrites = ownKeys(arrayBufferMethods).filter(
  key => key in arrayBufferPrototype,
);
if (overwrites.length > 0) {
  // eslint-disable-next-line @endo/no-polymorphic-call
  console.warn(
    `About to overwrite ArrayBuffer.prototype properties ${stringify(overwrites)}`,
  );
}

defineProperties(
  arrayBufferPrototype,
  getOwnPropertyDescriptors(arrayBufferMethods),
);
})()
,
// === 6. immutable-arraybuffer ./shim.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';$h͏_imports([["./src/immutable-arraybuffer-shim.js", []]]);
})()
,
// === 7. ses ./src/error/stringify-utils.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let Set,String,isArray,arrayJoin,arraySlice,arraySort,arrayMap,keys,fromEntries,freeze,is,isError,setAdd,setHas,stringIncludes,stringStartsWith,stringifyJson,toStringTagSymbol;$h͏_imports([["../commons.js", [["Set",[$h͏_a => (Set = $h͏_a)]],["String",[$h͏_a => (String = $h͏_a)]],["isArray",[$h͏_a => (isArray = $h͏_a)]],["arrayJoin",[$h͏_a => (arrayJoin = $h͏_a)]],["arraySlice",[$h͏_a => (arraySlice = $h͏_a)]],["arraySort",[$h͏_a => (arraySort = $h͏_a)]],["arrayMap",[$h͏_a => (arrayMap = $h͏_a)]],["keys",[$h͏_a => (keys = $h͏_a)]],["fromEntries",[$h͏_a => (fromEntries = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["is",[$h͏_a => (is = $h͏_a)]],["isError",[$h͏_a => (isError = $h͏_a)]],["setAdd",[$h͏_a => (setAdd = $h͏_a)]],["setHas",[$h͏_a => (setHas = $h͏_a)]],["stringIncludes",[$h͏_a => (stringIncludes = $h͏_a)]],["stringStartsWith",[$h͏_a => (stringStartsWith = $h͏_a)]],["stringifyJson",[$h͏_a => (stringifyJson = $h͏_a)]],["toStringTagSymbol",[$h͏_a => (toStringTagSymbol = $h͏_a)]]]]]);






















/** @import {Stringable} from '../../types.js' */

/**
 * Joins English terms with commas and an optional conjunction.
 *
 * @param {(string | Stringable)[]} terms
 * @param {"and" | "or"} conjunction
 */
       const enJoin = (terms, conjunction) => {
  if (terms.length === 0) {
    return '(none)';
  } else if (terms.length === 1) {
    return terms[0];
  } else if (terms.length === 2) {
    const [first, second] = terms;
    return `${first} ${conjunction} ${second}`;
  } else {
    return `${arrayJoin(arraySlice(terms, 0, -1), ', ')}, ${conjunction} ${
      terms[terms.length - 1]
    }`;
  }
};

/**
 * Prepend the correct indefinite article onto a noun, typically a typeof
 * result, e.g., "an object" vs. "a number"
 *
 * @param {string} str The noun to prepend
 * @returns {string} The noun prepended with a/an
 */$h͏_once.enJoin(enJoin);
const an = str => {
  str = `${str}`;
  if (str.length >= 1 && stringIncludes('aeiouAEIOU', str[0])) {
    return `an ${str}`;
  }
  return `a ${str}`;
};$h͏_once.an(an);
freeze(an);


/**
 * Like `JSON.stringify` but does not blow up if given a cycle or a bigint.
 * This is not
 * intended to be a serialization to support any useful unserialization,
 * or any programmatic use of the resulting string. The string is intended
 * *only* for showing a human under benign conditions, in order to be
 * informative enough for some
 * logging purposes. As such, this `bestEffortStringify` has an
 * imprecise specification and may change over time.
 *
 * The current `bestEffortStringify` possibly emits too many "seen"
 * markings: Not only for cycles, but also for repeated subtrees by
 * object identity.
 *
 * As a best effort only for diagnostic interpretation by humans,
 * `bestEffortStringify` also turns various cases that normal
 * `JSON.stringify` skips or errors on, like `undefined` or bigints,
 * into strings that convey their meaning. To distinguish this from
 * strings in the input, these synthesized strings always begin and
 * end with square brackets. To distinguish those strings from an
 * input string with square brackets, and input string that starts
 * with an open square bracket `[` is itself placed in square brackets.
 *
 * @param {any} payload
 * @param {(string|number)=} spaces
 * @returns {string}
 */
const bestEffortStringify = (payload, spaces = undefined) => {
  const seenSet = new Set();
  const replacer = (_, val) => {
    switch (typeof val) {
      case 'object': {
        if (val === null) {
          return null;
        }
        if (setHas(seenSet, val)) {
          return '[Seen]';
        }
        setAdd(seenSet, val);
        if (isError(val)) {
          return `[${val.name}: ${val.message}]`;
        }
        if (toStringTagSymbol in val) {
          // For the built-ins that have or inherit a `Symbol.toStringTag`-named
          // property, most of them inherit the default `toString` method,
          // which will print in a similar manner: `"[object Foo]"` vs
          // `"[Foo]"`. The exceptions are
          //    * `Symbol.prototype`, `BigInt.prototype`, `String.prototype`
          //      which don't matter to us since we handle primitives
          //      separately and we don't care about primitive wrapper objects.
          //    * TODO
          //      `Date.prototype`, `TypedArray.prototype`.
          //      Hmmm, we probably should make special cases for these. We're
          //      not using these yet, so it's not urgent. But others will run
          //      into these.
          //
          // Once #2018 is closed, the only objects in our code that have or
          // inherit a `Symbol.toStringTag`-named property are remotables
          // or their remote presences.
          // This printing will do a good job for these without
          // violating abstraction layering. This behavior makes sense
          // purely in terms of JavaScript concepts. That's some of the
          // motivation for choosing that representation of remotables
          // and their remote presences in the first place.
          return `[${val[toStringTagSymbol]}]`;
        }
        if (isArray(val)) {
          return val;
        }
        const names = keys(val);
        if (names.length < 2) {
          return val;
        }
        let sorted = true;
        for (let i = 1; i < names.length; i += 1) {
          if (names[i - 1] >= names[i]) {
            sorted = false;
            break;
          }
        }
        if (sorted) {
          return val;
        }
        arraySort(names);
        const entries = arrayMap(names, name => [name, val[name]]);
        return fromEntries(entries);
      }
      case 'function': {
        return `[Function ${val.name || '<anon>'}]`;
      }
      case 'string': {
        if (stringStartsWith(val, '[')) {
          return `[${val}]`;
        }
        return val;
      }
      case 'undefined':
      case 'symbol': {
        return `[${String(val)}]`;
      }
      case 'bigint': {
        return `[${val}n]`;
      }
      case 'number': {
        if (is(val, NaN)) {
          return '[NaN]';
        } else if (val === Infinity) {
          return '[Infinity]';
        } else if (val === -Infinity) {
          return '[-Infinity]';
        }
        return val;
      }
      default: {
        return val;
      }
    }
  };
  try {
    return stringifyJson(payload, replacer, spaces);
  } catch (_err) {
    // Don't do anything more fancy here if there is any
    // chance that might throw, unless you surround that
    // with another try-catch-recovery. For example,
    // the caught thing might be a proxy or other exotic
    // object rather than an error. The proxy might throw
    // whenever it is possible for it to.
    return '[Something that failed to stringify]';
  }
};$h͏_once.bestEffortStringify(bestEffortStringify);
freeze(bestEffortStringify);
})()
,
// === 8. ses ./src/error/types.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';$h͏_imports([]);// @ts-check

/** @import {GenericErrorConstructor, AssertMakeErrorOptions, DetailsToken, Stringable} from '../../types.js' */

/**
 * @typedef {object} VirtualConsole
 * @property {Console['debug']} debug
 * @property {Console['log']} log
 * @property {Console['info']} info
 * @property {Console['warn']} warn
 * @property {Console['error']} error
 *
 * @property {Console['trace']} trace
 * @property {Console['dirxml']} dirxml
 * @property {Console['group']} group
 * @property {Console['groupCollapsed']} groupCollapsed
 *
 * @property {Console['assert']} assert
 * @property {Console['timeLog']} timeLog
 *
 * @property {Console['clear']} clear
 * @property {Console['count']} count
 * @property {Console['countReset']} countReset
 * @property {Console['dir']} dir
 * @property {Console['groupEnd']} groupEnd
 *
 * @property {Console['table']} table
 * @property {Console['time']} time
 * @property {Console['timeEnd']} timeEnd
 * @property {Console['timeStamp']} timeStamp
 */

/* This is deliberately *not* JSDoc, it is a regular comment.
 *
 * TODO: We'd like to add the following properties to the above
 * VirtualConsole, but they currently cause conflicts where
 * some Typescript implementations don't have these properties
 * on the Console type.
 *
 * @property {Console['profile']} profile
 * @property {Console['profileEnd']} profileEnd
 */

/**
 * @typedef {'debug' | 'log' | 'info' | 'warn' | 'error'} LogSeverity
 */

/**
 * @typedef ConsoleFilter
 * @property {(severity: LogSeverity) => boolean} canLog
 */

/**
 * @callback FilterConsole
 * @param {VirtualConsole} baseConsole
 * @param {ConsoleFilter} filter
 * @param {string} [topic]
 * @returns {VirtualConsole}
 */
})()
,
// === 9. ses ./src/error/internal-types.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';$h͏_imports([]);// @ts-check

/**
 * @import {VirtualConsole} from './types.js'
 */

/**
 * @typedef {readonly any[]} LogArgs
 *
 * This is an array suitable to be used as arguments of a console
 * level message *after* the format string argument. It is the result of
 * a `details` template string and consists of alternating literal strings
 * and substitution values, starting with a literal string. At least that
 * first literal string is always present.
 */

/**
 * @callback NoteCallback
 *
 * @param {Error} error
 * @param {LogArgs} noteLogArgs
 * @returns {void}
 */

/**
 * @callback GetStackString
 * @param {Error} error
 * @returns {string=}
 */

/**
 * @typedef {object} LoggedErrorHandler
 *
 * Used to parameterize `makeCausalConsole` to give it access to potentially
 * hidden information to augment the logging of errors.
 *
 * @property {GetStackString} getStackString
 * @property {(error: Error) => string} tagError
 * @property {() => void} resetErrorTagNum for debugging purposes only
 * @property {(error: Error) => (LogArgs | undefined)} getMessageLogArgs
 * @property {(error: Error) => (LogArgs | undefined)} takeMessageLogArgs
 * @property {(error: Error, callback?: NoteCallback) => LogArgs[] } takeNoteLogArgsArray
 */

// /////////////////////////////////////////////////////////////////////////////

/**
 * @typedef {readonly [string, ...any[]]} LogRecord
 */

/**
 * @typedef {object} LoggingConsoleKit
 * @property {VirtualConsole} loggingConsole
 * @property {() => readonly LogRecord[]} takeLog
 */

/**
 * @typedef {object} MakeLoggingConsoleKitOptions
 * @property {boolean=} shouldResetForDebugging
 */

/**
 * @callback MakeLoggingConsoleKit
 *
 * A logging console just accumulates the contents of all permitted calls,
 * making them available to callers of `takeLog()`. Calling `takeLog()`
 * consumes these, so later calls to `takeLog()` will only provide a log of
 * calls that have happened since then.
 *
 * @param {LoggedErrorHandler} loggedErrorHandler
 * @param {MakeLoggingConsoleKitOptions=} options
 * @returns {LoggingConsoleKit}
 */

/**
 * @typedef {{
 *   NOTE: 'ERROR_NOTE:',
 *   MESSAGE: 'ERROR_MESSAGE:',
 *   CAUSE: 'cause:',
 *   ERRORS: 'errors:',
 * }} ErrorInfo
 */

/**
 * @typedef {ErrorInfo[keyof ErrorInfo]} ErrorInfoKind
 */

/**
 * @callback MakeCausalConsole
 *
 * Makes a causal console wrapper of a `baseConsole`, where the causal console
 * calls methods of the `loggedErrorHandler` to customize how it handles logged
 * errors.
 *
 * @param {VirtualConsole | undefined} baseConsole
 * @param {LoggedErrorHandler} loggedErrorHandler
 * @returns {VirtualConsole | undefined}
 */
})()
,
// === 10. cache-map ./src/cachemap.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';$h͏_imports([]);// @ts-check
/* global globalThis */
/* eslint-disable @endo/no-polymorphic-call */

// eslint-disable-next-line no-restricted-globals
const { Error, TypeError, WeakMap } = globalThis;
// eslint-disable-next-line no-restricted-globals
const { parse, stringify } = JSON;
// eslint-disable-next-line no-restricted-globals
const { isSafeInteger } = Number;
// eslint-disable-next-line no-restricted-globals
const { freeze } = Object;
// eslint-disable-next-line no-restricted-globals
const { toStringTag: toStringTagSymbol } = Symbol;

// eslint-disable-next-line no-restricted-globals
const UNKNOWN_KEY = Symbol('UNKNOWN_KEY');

/**
 * @template T
 * @typedef {T extends object ? { -readonly [K in keyof T]: T[K] } : never} WritableDeep
 *   Intentionally limited to local needs; refer to
 *   https://github.com/sindresorhus/type-fest if insufficient.
 */

/**
 * @template T
 * @param {T} value
 * @param {<U,>(name: string, value: U) => U} [reviver]
 * @returns {WritableDeep<T>}
 */
const deepCopyJsonable = (value, reviver) => {
  const encoded = stringify(value);
  const decoded = parse(encoded, reviver);
  return decoded;
};

const freezingReviver = (_name, value) => freeze(value);

/** @type {<T,>(value: T) => T} */
const deepCopyAndFreezeJsonable = value =>
  deepCopyJsonable(value, freezingReviver);

/**
 * A cache of bounded size, implementing the WeakMap interface but holding keys
 * strongly if created with a non-weak `makeMap` option of
 * {@link makeCacheMapKit}.
 *
 * @template K
 * @template V
 * @typedef {Pick<Map<K, V>, Exclude<keyof WeakMap<WeakKey, *>, 'set'>> & {set: (key: K, value: V) => WeakMapAPI<K, V>}} WeakMapAPI
 */

/**
 * @template K
 * @template V
 * @typedef {WeakMapAPI<K, V> & ({clear?: undefined} | Pick<Map<K, V>, 'clear'>)} SingleEntryMap
 */

/**
 * A cell of a doubly-linked ring (circular list) for a cache map.
 * Instances are not frozen, and so should be closely encapsulated.
 *
 * @template K
 * @template V
 * @typedef {object} CacheMapCell
 * @property {number} id for debugging
 * @property {CacheMapCell<K, V>} next
 * @property {CacheMapCell<K, V>} prev
 * @property {SingleEntryMap<K, V>} data
 */

/**
 * @template K
 * @template V
 * @param {CacheMapCell<K, V>} prev
 * @param {number} id
 * @param {SingleEntryMap<K, V>} data
 * @returns {CacheMapCell<K, V>}
 */
const appendNewCell = (prev, id, data) => {
  const next = prev?.next;
  const cell = { id, next, prev, data };
  prev.next = cell;
  next.prev = cell;
  return cell;
};

/**
 * @template K
 * @template V
 * @param {CacheMapCell<K, V>} cell
 * @param {CacheMapCell<K, V>} prev
 * @param {CacheMapCell<K, V>} [next]
 */
const moveCellAfter = (cell, prev, next = prev.next) => {
  if (cell === prev || cell === next) return; // already in position

  // Splice out cell.
  const { prev: oldPrev, next: oldNext } = cell;
  oldPrev.next = oldNext;
  oldNext.prev = oldPrev;

  // Splice in cell after prev.
  cell.prev = prev;
  cell.next = next;
  prev.next = cell;
  next.prev = cell;
};

/**
 * Clear out a cell to prepare it for future use. Its map is preserved when
 * possible, but must instead be replaced if the associated key is not known.
 *
 * @template K
 * @template V
 * @param {CacheMapCell<K, V>} cell
 * @param {K | UNKNOWN_KEY} oldKey
 * @param {() => SingleEntryMap<K, V>} [makeMap] required when the key is unknown
 */
const resetCell = (cell, oldKey, makeMap) => {
  if (oldKey !== UNKNOWN_KEY) {
    cell.data.delete(oldKey);
    return;
  }
  if (cell.data.clear) {
    cell.data.clear();
    return;
  }
  // WeakMap instances must be replaced when the key is unknown.
  if (!makeMap) {
    throw Error('internal: makeMap is required with UNKNOWN_KEY');
  }
  cell.data = makeMap();
};

const zeroMetrics = freeze({
  totalQueryCount: 0,
  totalHitCount: 0
  // TODO?
  // * method-specific counts
  // * liveTouchStats/evictedTouchStats { count, sum, mean, min, max }
  //   * p50/p90/p95/p99 via Ben-Haim/Tom-Tov streaming histograms
});
/** @typedef {typeof zeroMetrics} CacheMapMetrics */

/**
 * @template {MapConstructor | WeakMapConstructor} [C=WeakMapConstructor]
 * @template {Parameters<InstanceType<C>['set']>[0]} [K=Parameters<InstanceType<C>['set']>[0]]
 * @template {unknown} [V=unknown]
 * @typedef {object} CacheMapKit
 * @property {WeakMapAPI<K, V>} cache
 * @property {() => CacheMapMetrics} getMetrics
 */

/**
 * Create a bounded-size cache having WeakMap-compatible
 * `has`/`get`/`set`/`delete` methods, capable of supporting SES (specifically
 * `assert` error notes).
 * Key validity, comparison, and referential strength are controlled by the
 * `makeMap` option, which defaults to `WeakMap` but can be set to any producer
 * of objects with those methods (e.g., using `Map` allows for arbitrary keys
 * which will be strongly held).
 * Cache eviction policy is not currently configurable, but strives for a hit
 * ratio at least as good as
 * [LRU](https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU) (e.g., it
 * might be
 * [CLOCK](https://en.wikipedia.org/wiki/Page_replacement_algorithm#Clock)
 * or [SIEVE](https://sievecache.com/)).
 *
 * @template {MapConstructor | WeakMapConstructor} [C=WeakMapConstructor]
 * @template {Parameters<InstanceType<C>['set']>[0]} [K=Parameters<InstanceType<C>['set']>[0]]
 * @template {unknown} [V=unknown]
 * @param {number} capacity
 * @param {object} [options]
 * @param {C | (() => SingleEntryMap<K, V>)} [options.makeMap]
 * @returns {CacheMapKit<C, K, V>}
 */
       const makeCacheMapKit = (capacity, options = {}) => {
  if (!isSafeInteger(capacity) || capacity < 0) {
    throw TypeError(
      'capacity must be a non-negative safe integer number <= 2**53 - 1',
    );
  }

  /**
   * @template V
   * @type {<V,>() => SingleEntryMap<K, V>}
   */
  const makeMap = (MaybeCtor => {
    try {
      // @ts-expect-error
      MaybeCtor();
      return /** @type {any} */ (MaybeCtor);
    } catch (err) {
      // @ts-expect-error
      const constructNewMap = () => new MaybeCtor();
      return constructNewMap;
    }
  })(options.makeMap ?? WeakMap);
  const tag =
    /** @type {any} */ (makeMap()).clear === undefined
      ? 'WeakCacheMap'
      : 'CacheMap';

  /** @type {WeakMapAPI<K, CacheMapCell<K, V>>} */
  const keyToCell = makeMap();
  // @ts-expect-error this sentinel head is special
  const head = /** @type {CacheMapCell<K, V>} */ ({
    id: 0,
    // next and prev are established below as self-referential.
    next: undefined,
    prev: undefined,
    data: {
      has: () => {
        throw Error('internal: sentinel head cell has no data');
      },
    },
  });
  head.next = head;
  head.prev = head;
  let cellCount = 0;

  const metrics = deepCopyJsonable(zeroMetrics);
  const getMetrics = () => deepCopyAndFreezeJsonable(metrics);

  /**
   * Touching moves a cell to first position so LRU eviction can target the last
   * cell (`head.prev`).
   *
   * @type {(key: K) => (CacheMapCell<K, V> | undefined)}
   */
  const touchKey = key => {
    metrics.totalQueryCount += 1;
    const cell = keyToCell.get(key);
    if (!cell?.data.has(key)) return undefined;

    metrics.totalHitCount += 1;
    moveCellAfter(cell, head);
    return cell;
  };

  /** @type {WeakMapAPI<K, V>['has']} */
  const has = key => {
    const cell = touchKey(key);
    return cell !== undefined;
  };
  freeze(has);

  /** @type {WeakMapAPI<K, V>['get']} */
  const get = key => {
    const cell = touchKey(key);
    return cell?.data.get(key);
  };
  freeze(get);

  /** @type {WeakMapAPI<K, V>['set']} */
  const set = (key, value) => {
    let cell = touchKey(key);
    if (cell) {
      cell.data.set(key, value);
      // eslint-disable-next-line no-use-before-define
      return implementation;
    }

    if (cellCount < capacity) {
      // Add and use a new cell at first position.
      cell = appendNewCell(head, cellCount + 1, makeMap());
      cellCount += 1; // intentionally follows cell creation
      cell.data.set(key, value);
    } else if (capacity > 0) {
      // Reuse the current tail, moving it to first position.
      cell = head.prev;
      resetCell(/** @type {any} */ (cell), UNKNOWN_KEY, makeMap);
      cell.data.set(key, value);
      moveCellAfter(cell, head);
    }

    // Don't establish this entry until prior steps succeed.
    if (cell) keyToCell.set(key, cell);

    // eslint-disable-next-line no-use-before-define
    return implementation;
  };
  freeze(set);

  // "delete" is a keyword.
  const { delete: deleteEntry } = {
    /** @type {WeakMapAPI<K, V>['delete']} */
    delete: key => {
      const cell = keyToCell.get(key);
      if (!cell?.data.has(key)) {
        keyToCell.delete(key);
        return false;
      }
      moveCellAfter(cell, head.prev);
      resetCell(cell, key);
      keyToCell.delete(key);
      return true;
    },
  };
  freeze(deleteEntry);

  const implementation = /** @type {WeakMapAPI<K, V>} */ ({
    has,
    get,
    set,
    delete: deleteEntry,
    // eslint-disable-next-line jsdoc/check-types
    [/** @type {typeof Symbol.toStringTag} */ (toStringTagSymbol)]: tag,
  });
  freeze(implementation);

  const kit = { cache: implementation, getMetrics };
  return freeze(kit);
};$h͏_once.makeCacheMapKit(makeCacheMapKit);
freeze(makeCacheMapKit);
})()
,
// === 11. cache-map ./index.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';$h͏_imports([["./src/cachemap.js", []]]);
})()
,
// === 12. ses ./src/error/note-log-args.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let makeCacheMapKit;$h͏_imports([["@endo/cache-map", [["makeCacheMapKit",[$h͏_a => (makeCacheMapKit = $h͏_a)]]]]]);





/**
 * @import {CacheMapKit} from '@endo/cache-map';
 * @import {LogArgs} from './internal-types.js';
 */

const { freeze } = Object;
const { isSafeInteger } = Number;

const defaultLoggedErrorsBudget = 1000;
const defaultArgsPerErrorBudget = 100;

/**
 * @param {number} [errorsBudget]
 * @param {number} [argsPerErrorBudget]
 */
       const makeNoteLogArgsArrayKit = (
  errorsBudget = defaultLoggedErrorsBudget,
  argsPerErrorBudget = defaultArgsPerErrorBudget,
) => {
  if (!isSafeInteger(argsPerErrorBudget) || argsPerErrorBudget < 1) {
    throw TypeError(
      'argsPerErrorBudget must be a safe positive integer number',
    );
  }

  /**
   * Maps from an error to an array of log args, where each log args is
   * remembered as an annotation on that error. This can be used, for example,
   * to keep track of additional causes of the error. The elements of any
   * log args may include errors which are associated with further annotations.
   * An augmented console, like the causal console of `console.js`, could
   * then retrieve the graph of such annotations.
   *
   * @type {CacheMapKit<WeakMapConstructor, Error, LogArgs[]>}
   */
  const { cache: noteLogArgsArrayMap } = makeCacheMapKit(errorsBudget);

  /**
   * @param {Error} error
   * @param {LogArgs} logArgs
   */
  const addLogArgs = (error, logArgs) => {
    const logArgsArray = noteLogArgsArrayMap.get(error);
    if (logArgsArray !== undefined) {
      if (logArgsArray.length >= argsPerErrorBudget) {
        logArgsArray.shift();
      }
      logArgsArray.push(logArgs);
    } else {
      noteLogArgsArrayMap.set(error, [logArgs]);
    }
  };
  freeze(addLogArgs);

  /**
   * @param {Error} error
   * @returns {LogArgs[] | undefined}
   */
  const takeLogArgsArray = error => {
    const result = noteLogArgsArrayMap.get(error);
    noteLogArgsArrayMap.delete(error);
    return result;
  };
  freeze(takeLogArgsArray);

  return freeze({
    addLogArgs,
    takeLogArgsArray,
  });
};$h͏_once.makeNoteLogArgsArrayKit(makeNoteLogArgsArrayKit);
freeze(makeNoteLogArgsArrayKit);
})()
,
// === 13. ses ./src/error/assert.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let RangeError,TypeError,WeakMap,arrayJoin,arrayMap,arrayPop,arrayPush,assign,freeze,defineProperty,globalThis,is,isError,regexpExec,regexpReplace,sealRegexp,stringIndexOf,stringSlice,stringStartsWith,weakmapDelete,weakmapGet,weakmapHas,weakmapSet,AggregateError,getOwnPropertyDescriptors,ownKeys,create,objectPrototype,hasOwn,an,bestEffortStringify,makeNoteLogArgsArrayKit;$h͏_imports([["../commons.js", [["RangeError",[$h͏_a => (RangeError = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["WeakMap",[$h͏_a => (WeakMap = $h͏_a)]],["arrayJoin",[$h͏_a => (arrayJoin = $h͏_a)]],["arrayMap",[$h͏_a => (arrayMap = $h͏_a)]],["arrayPop",[$h͏_a => (arrayPop = $h͏_a)]],["arrayPush",[$h͏_a => (arrayPush = $h͏_a)]],["assign",[$h͏_a => (assign = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["globalThis",[$h͏_a => (globalThis = $h͏_a)]],["is",[$h͏_a => (is = $h͏_a)]],["isError",[$h͏_a => (isError = $h͏_a)]],["regexpExec",[$h͏_a => (regexpExec = $h͏_a)]],["regexpReplace",[$h͏_a => (regexpReplace = $h͏_a)]],["sealRegexp",[$h͏_a => (sealRegexp = $h͏_a)]],["stringIndexOf",[$h͏_a => (stringIndexOf = $h͏_a)]],["stringSlice",[$h͏_a => (stringSlice = $h͏_a)]],["stringStartsWith",[$h͏_a => (stringStartsWith = $h͏_a)]],["weakmapDelete",[$h͏_a => (weakmapDelete = $h͏_a)]],["weakmapGet",[$h͏_a => (weakmapGet = $h͏_a)]],["weakmapHas",[$h͏_a => (weakmapHas = $h͏_a)]],["weakmapSet",[$h͏_a => (weakmapSet = $h͏_a)]],["AggregateError",[$h͏_a => (AggregateError = $h͏_a)]],["getOwnPropertyDescriptors",[$h͏_a => (getOwnPropertyDescriptors = $h͏_a)]],["ownKeys",[$h͏_a => (ownKeys = $h͏_a)]],["create",[$h͏_a => (create = $h͏_a)]],["objectPrototype",[$h͏_a => (objectPrototype = $h͏_a)]],["hasOwn",[$h͏_a => (hasOwn = $h͏_a)]]]],["./stringify-utils.js", [["an",[$h͏_a => (an = $h͏_a)]],["bestEffortStringify",[$h͏_a => (bestEffortStringify = $h͏_a)]]]],["./types.js", []],["./internal-types.js", []],["./note-log-args.js", [["makeNoteLogArgsArrayKit",[$h͏_a => (makeNoteLogArgsArrayKit = $h͏_a)]]]]]);
















































/**
 * @import {BaseAssert, Assert, AssertionFunctions, AssertionUtilities, DeprecatedAssertionUtilities, Stringable, DetailsToken, MakeAssert} from '../../types.js';
 * @import {LogArgs, NoteCallback, LoggedErrorHandler} from './internal-types.js';
 */

// For internal debugging purposes, uncomment
// const internalDebugConsole = console;

// /////////////////////////////////////////////////////////////////////////////

/**
 * Maps the result of a `quote` or `bare` call back to its input value.
 *
 * @type {WeakMap<Stringable, any>}
 */
const declassifiers = new WeakMap();

/** @type {AssertionUtilities['quote']} */
const quote = (value, spaces = undefined) => {
  const result = freeze({
    toString: freeze(() => bestEffortStringify(value, spaces)),
  });
  weakmapSet(declassifiers, result, value);
  return result;
};$h͏_once.quote(quote);
freeze(quote);

const canBeBare = freeze(/^[\w:-]( ?[\w:-])*$/);

/**
 * @type {AssertionUtilities['bare']}
 */
const bare = (text, spaces = undefined) => {
  if (typeof text !== 'string' || !regexpExec(canBeBare, text)) {
    return quote(text, spaces);
  }
  const result = freeze({
    toString: freeze(() => text),
  });
  weakmapSet(declassifiers, result, text);
  return result;
};$h͏_once.bare(bare);
freeze(bare);

// /////////////////////////////////////////////////////////////////////////////

/**
 * @typedef {{ template: TemplateStringsArray | string[], args: any[] }} DetailsParts
 *
 * The contents of a `details` template literal tag: literal strings (always at
 * least one) and arbitrary substitution values from in between them.
 *
 * Unquoted substitution values are sensitive (and are redacted in error
 * `message` strings), so a DetailsPart must not leak outside of this file.
 */

/**
 * Maps the result of a `details` tagged template literal back to a record of
 * that template literal's contents.
 *
 * @type {WeakMap<DetailsToken, DetailsParts>}
 */
const hiddenDetailsMap = new WeakMap();

/**
 * Construct an error message string from `details` template literal contents,
 * replacing unquoted substitution values with redactions.
 *
 * @param {DetailsParts} hiddenDetails
 * @returns {string}
 */
const getMessageString = ({ template, args }) => {
  const parts = [template[0]];
  for (let i = 0; i < args.length; i += 1) {
    const arg = args[i];
    let argStr;
    if (weakmapHas(declassifiers, arg)) {
      argStr = `${arg}`;
    } else if (isError(arg)) {
      argStr = `(${an(arg.name)})`;
    } else {
      argStr = `(${an(typeof arg)})`;
    }
    arrayPush(parts, argStr, template[i + 1]);
  }
  return arrayJoin(parts, '');
};

/**
 * Define `toString` behavior for DetailsToken. To minimize the overhead of
 * creating new instances, we do this with an inherited `this`-sensitive method,
 * even though we normally avoid such sensitivity. To protect the method from
 * inappropriate application, it verifies that `this` is registered in
 * `redactedDetails` before doing interesting work.
 *
 * The behavior must not reveal anything redacted, so we use `getMessageString`
 * to return the same value as the message for a thrown assertion-failure error.
 */
const DetailsTokenProto = freeze({
  toString() {
    const hiddenDetails = weakmapGet(hiddenDetailsMap, this);
    if (hiddenDetails === undefined) {
      return '[Not a DetailsToken]';
    }
    return getMessageString(hiddenDetails);
  },
});
freeze(DetailsTokenProto.toString);

/**
 * Normally this is the function exported as `assert.details` and often
 * spelled `X`. However, if the `{errorTaming: 'unsafe'}` or
 * `{errorTaming: 'unsafe-debug'}` option is
 * given to `lockdown`, then `unredactedDetails` is used instead.
 *
 * There are some unconditional uses of `redactedDetails` in this module. All
 * of them should be uses where the template literal has no redacted (unquoted)
 * substitution values. In those cases, `redactedDetails` is equivalent to
 * `unredactedDetails`.
 *
 * @type {AssertionUtilities['details']}
 */
const redactedDetails = (template, ...args) => {
  // In case the result of this call is never used, perform as little processing
  // as possible here to keep things fast.
  const detailsToken = freeze({ __proto__: DetailsTokenProto });
  weakmapSet(hiddenDetailsMap, detailsToken, { template, args });
  return /** @type {DetailsToken} */ (/** @type {unknown} */ (detailsToken));
};$h͏_once.redactedDetails(redactedDetails);
freeze(redactedDetails);

/**
 * `unredactedDetails` is like `details` except that it does not redact
 * anything. It acts like `details` would act if all substitution values
 * were wrapped with the `quote` function above (the function normally
 * spelled `q`). If the `{errorTaming: 'unsafe'}`
 * or `{errorTaming: 'unsafe-debug'}` option is given to
 * `lockdown`, then the lockdown-shim arranges for the global `assert` to be
 * one whose `details` property is `unredactedDetails`.
 * This setting optimizes the debugging and testing experience at the price
 * of safety. `unredactedDetails` also sacrifices the speed of `details`,
 * which is usually fine in debugging and testing.
 *
 * @type {AssertionUtilities['details']}
 */
const unredactedDetails = (template, ...args) => {
  args = arrayMap(args, arg =>
    weakmapHas(declassifiers, arg) ? arg : quote(arg),
  );
  return redactedDetails(template, ...args);
};$h͏_once.unredactedDetails(unredactedDetails);
freeze(unredactedDetails);


const leadingSpacePattern = sealRegexp(/^ /);
const trailingSpacePattern = sealRegexp(/ $/);

/**
 * Get arguments suitable for a console logger function (e.g., `console.error`)
 * from `details` template literal contents, unquoting quoted substitution
 * values.
 *
 * @param {DetailsParts} hiddenDetails
 * @returns {LogArgs}
 */
const getLogArgs = ({ template, args }) => {
  const logArgs = [template[0]];
  for (let i = 0; i < args.length; i += 1) {
    let arg = args[i];
    if (weakmapHas(declassifiers, arg)) {
      arg = weakmapGet(declassifiers, arg);
    }
    // Remove substitution-adjacent spaces from template fixed-string parts
    // (since console logging inserts its own argument-separating spaces).
    const prevLiteralPart = regexpReplace(
      trailingSpacePattern,
      arrayPop(logArgs) || '',
      '',
    );
    if (prevLiteralPart !== '') {
      arrayPush(logArgs, prevLiteralPart);
    }
    const nextLiteralPart = regexpReplace(
      leadingSpacePattern,
      template[i + 1],
      '',
    );
    arrayPush(logArgs, arg, nextLiteralPart);
  }
  if (logArgs[logArgs.length - 1] === '') {
    arrayPop(logArgs);
  }
  return logArgs;
};

/**
 * Maps from an error object to arguments suitable for a privileged console
 * logger function such as `console.error`, including values that may be
 * redacted in the error's `message`.
 *
 * @type {WeakMap<Error, LogArgs>}
 */
const hiddenMessageLogArgs = new WeakMap();

// So each error tag will be unique.
let errorTagNum = 0;

/**
 * @type {WeakMap<Error, string>}
 */
const errorTags = new WeakMap();

/**
 * @param {Error} err
 * @param {string=} optErrorName
 * @returns {string}
 */
const tagError = (err, optErrorName = err.name) => {
  let errorTag = weakmapGet(errorTags, err);
  if (errorTag !== undefined) {
    return errorTag;
  }
  errorTagNum += 1;
  errorTag = `${optErrorName}#${errorTagNum}`;
  weakmapSet(errorTags, err, errorTag);
  return errorTag;
};

/**
 * Make reasonable best efforts to make a `Passable` error.
 *   - `sanitizeError` will remove any "extraneous" own properties already added
 *     by the host,
 *     such as `fileName`,`lineNumber` on FireFox or `line` on Safari.
 *   - If any such "extraneous" properties were removed, `sanitizeError` will
 *     annotate
 *     the error with them, so they still appear on the causal console
 *     log output for diagnostic purposes, but not be otherwise visible.
 *   - `sanitizeError` will ensure that any expected properties already
 *     added by the host are data
 *     properties, converting accessor properties to data properties as needed,
 *     such as `stack` on v8 (Chrome, Brave, Edge?)
 *   - `sanitizeError` will freeze the error, preventing any correct engine from
 *     adding or
 *     altering any of the error's own properties `sanitizeError` is done.
 *
 * However, `sanitizeError` will not, for example, `harden`
 * (i.e., deeply freeze)
 * or ensure that the `cause` or `errors` property satisfy the `Passable`
 * constraints. The purpose of `sanitizeError` is only to protect against
 * mischief the host may have already added to the error as created,
 * not to ensure that the error is actually Passable. For that,
 * see `toPassableError` in `@endo/pass-style`.
 *
 * @param {Error} error
 */
       const sanitizeError = error => {
  const descs = getOwnPropertyDescriptors(error);
  const {
    name: _nameDesc,
    message: _messageDesc,
    errors: _errorsDesc = undefined,
    cause: _causeDesc = undefined,
    stack: _stackDesc = undefined,
    ...restDescs
  } = descs;

  const restNames = ownKeys(restDescs);
  if (restNames.length >= 1) {
    for (const name of restNames) {
      delete error[name];
    }
    const dropped = create(objectPrototype, restDescs);
    const droppedDetails = redactedDetails`originally with properties ${quote(dropped)}`;
    // eslint-disable-next-line no-use-before-define
    note(error, droppedDetails);
  }
  for (const name of ownKeys(error)) {
    // @ts-expect-error TypeScript is still confused by symbols as property keys
    const desc = descs[name];
    if (desc && hasOwn(desc, 'get')) {
      const value = error[name]; // invokes the getter
      defineProperty(error, name, { value });
    }
  }
  freeze(error);
};

/**
 * @type {AssertionUtilities['makeError']}
 */$h͏_once.sanitizeError(sanitizeError);
const makeError = (
  optDetails = redactedDetails`Assert failed`,
  errConstructor = globalThis.Error,
  {
    errorName = undefined,
    cause = undefined,
    errors = undefined,
    sanitize = true,
  } = {},
) => {
  // Promote string-valued `optDetails` into a minimal DetailsParts
  // consisting of that string as the sole literal part with no substitutions.
  if (typeof optDetails === 'string') {
    optDetails = redactedDetails([optDetails]);
  }
  const hiddenDetails = weakmapGet(hiddenDetailsMap, optDetails);
  if (hiddenDetails === undefined) {
    throw TypeError(`unrecognized details ${quote(optDetails)}`);
  }
  const messageString = getMessageString(hiddenDetails);
  const opts = cause && { cause };
  let error;
  if (
    typeof AggregateError !== 'undefined' &&
    errConstructor === AggregateError
  ) {
    error = AggregateError(errors || [], messageString, opts);
  } else {
    const ErrorCtor = /** @type {ErrorConstructor} */ (errConstructor);
    error = ErrorCtor(messageString, opts);
    // Since we need to tolerate `errors` on an AggregateError, we may as well
    // tolerate it on all errors.
    if (errors !== undefined) {
      defineProperty(error, 'errors', {
        value: errors,
        writable: true,
        enumerable: false,
        configurable: true,
      });
    }
  }
  weakmapSet(hiddenMessageLogArgs, error, getLogArgs(hiddenDetails));
  if (errorName !== undefined) {
    tagError(error, errorName);
  }
  if (sanitize) {
    sanitizeError(error);
  }
  // The next line is a particularly fruitful place to put a breakpoint.
  return error;
};$h͏_once.makeError(makeError);
freeze(makeError);

// /////////////////////////////////////////////////////////////////////////////

const { addLogArgs: addNoteLogArgs, takeLogArgsArray: takeAllNoteLogArgs } =
  makeNoteLogArgsArrayKit();

/**
 * An augmented console will normally only take the hidden noteArgs array once,
 * when it logs the error being annotated. Once that happens, further
 * annotations of that error should go to the console immediately. We arrange
 * that by accepting a note-callback function from the console as an optional
 * part of that taking operation. Normally there will only be at most one
 * callback per error, but that depends on console behavior which we should not
 * assume. We make this an array of callbacks so multiple registrations
 * are independent.
 *
 * @type {WeakMap<Error, NoteCallback[]>}
 */
const hiddenNoteCallbacks = new WeakMap();

/** @type {AssertionUtilities['note']} */
const note = (error, detailsNote) => {
  // Promote string-valued `detailsNote` into a minimal DetailsParts consisting
  // of that string as the sole literal part with no substitutions.
  if (typeof detailsNote === 'string') {
    detailsNote = redactedDetails([detailsNote]);
  }
  const hiddenDetails = weakmapGet(hiddenDetailsMap, detailsNote);
  if (hiddenDetails === undefined) {
    throw TypeError(`unrecognized details ${quote(detailsNote)}`);
  }
  const logArgs = getLogArgs(hiddenDetails);
  const callbacks = weakmapGet(hiddenNoteCallbacks, error);
  if (callbacks !== undefined) {
    for (const callback of callbacks) {
      callback(error, logArgs);
    }
  } else {
    addNoteLogArgs(error, logArgs);
  }
};$h͏_once.note(note);
freeze(note);

/**
 * The unprivileged form that just uses the de facto `error.stack` property.
 * The start compartment normally has a privileged `globalThis.getStackString`
 * which should be preferred if present.
 *
 * @param {Error} error
 * @returns {string}
 */
const defaultGetStackString = error => {
  if (!('stack' in error)) {
    return '';
  }
  const stackString = `${error.stack}`;
  const pos = stringIndexOf(stackString, '\n');
  if (stringStartsWith(stackString, ' ') || pos === -1) {
    return stackString;
  }
  return stringSlice(stackString, pos + 1); // exclude the initial newline
};

/** @type {LoggedErrorHandler} */
const loggedErrorHandler = {
  getStackString: globalThis.getStackString || defaultGetStackString,
  tagError: error => tagError(error),
  resetErrorTagNum: () => {
    errorTagNum = 0;
  },
  getMessageLogArgs: error => weakmapGet(hiddenMessageLogArgs, error),
  takeMessageLogArgs: error => {
    const logArgs = weakmapGet(hiddenMessageLogArgs, error);
    weakmapDelete(hiddenMessageLogArgs, error);
    return logArgs;
  },
  takeNoteLogArgsArray: (error, callback) => {
    const logArgsArray = takeAllNoteLogArgs(error);
    if (callback !== undefined) {
      const callbacks = weakmapGet(hiddenNoteCallbacks, error);
      if (callbacks) {
        arrayPush(callbacks, callback);
      } else {
        weakmapSet(hiddenNoteCallbacks, error, [callback]);
      }
    }
    return logArgsArray || [];
  },
};$h͏_once.loggedErrorHandler(loggedErrorHandler);
freeze(loggedErrorHandler);


// /////////////////////////////////////////////////////////////////////////////

/**
 * @type {MakeAssert}
 */
       const makeAssert = (optRaise = undefined, unredacted = false) => {
  const details = unredacted ? unredactedDetails : redactedDetails;
  const assertFailedDetails = details`Check failed`;

  /** @type {AssertionFunctions['fail']} */
  const fail = (
    optDetails = assertFailedDetails,
    errConstructor = undefined,
    options = undefined,
  ) => {
    const reason = makeError(optDetails, errConstructor, options);
    if (optRaise !== undefined) {
      optRaise(reason);
    }
    throw reason;
  };
  freeze(fail);

  /** @type {AssertionUtilities['Fail']} */
  const Fail = (template, ...args) => fail(details(template, ...args));

  // Don't freeze or export `assert` until we add methods.
  /** @type {BaseAssert} */
  const assert = (
    condition,
    optDetails = undefined,
    errConstructor = undefined,
    options = undefined,
  ) => {
    condition || fail(optDetails, errConstructor, options);
  };

  /** @type {AssertionFunctions['equal']} */
  const equal = (
    actual,
    expected,
    optDetails = undefined,
    errConstructor = undefined,
    options = undefined,
  ) => {
    is(actual, expected) ||
      fail(
        optDetails || details`Expected ${actual} is same as ${expected}`,
        errConstructor || RangeError,
        options,
      );
  };
  freeze(equal);

  /** @type {AssertionFunctions['typeof']} */
  const assertTypeof = (specimen, typename, optDetails) => {
    // This will safely fall through if typename is not a string,
    // which is what we want.
    // eslint-disable-next-line valid-typeof
    if (typeof specimen === typename) {
      return;
    }
    typeof typename === 'string' || Fail`${quote(typename)} must be a string`;

    if (optDetails === undefined) {
      // Embed the type phrase without quotes.
      const typeWithDeterminer = an(typename);
      optDetails = details`${specimen} must be ${bare(typeWithDeterminer)}`;
    }
    fail(optDetails, TypeError);
  };
  freeze(assertTypeof);

  /** @type {AssertionFunctions['string']} */
  const assertString = (specimen, optDetails = undefined) =>
    assertTypeof(specimen, 'string', optDetails);

  /** @type {Pick<AssertionFunctions, keyof AssertionFunctions>} */
  const assertionFunctions = {
    equal,
    typeof: assertTypeof,
    string: assertString,
    fail,
  };

  /** @type {AssertionUtilities} */
  const assertionUtilities = {
    makeError,
    note,
    details,
    Fail,
    quote,
    bare,
  };

  /** @type {DeprecatedAssertionUtilities} */
  const deprecated = { error: makeError, makeAssert };

  /** @type {Assert} */
  const finishedAssert = assign(assert, {
    ...assertionFunctions,
    ...assertionUtilities,
    ...deprecated,
  });
  return freeze(finishedAssert);
};$h͏_once.makeAssert(makeAssert);
freeze(makeAssert);

/** @type {Assert} */
const assert = makeAssert();$h͏_once.assert(assert);


// Internal, to obviate polymorphic dispatch, but may become rigorously
// consistent with @endo/error:

/** @type {AssertionFunctions['equal']} */
const assertEqual = assert.equal;$h͏_once.assertEqual(assertEqual);
})()
,
// === 14. ses ./src/make-hardener.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let Set,String,TypeError,WeakSet,globalThis,apply,arrayForEach,defineProperty,freeze,getOwnPropertyDescriptor,getOwnPropertyDescriptors,getPrototypeOf,isInteger,isPrimitive,hasOwn,ownKeys,preventExtensions,setAdd,setForEach,setHas,toStringTagSymbol,typedArrayPrototype,weaksetAdd,weaksetHas,FERAL_STACK_GETTER,FERAL_STACK_SETTER,isError,assert;$h͏_imports([["./commons.js", [["Set",[$h͏_a => (Set = $h͏_a)]],["String",[$h͏_a => (String = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["WeakSet",[$h͏_a => (WeakSet = $h͏_a)]],["globalThis",[$h͏_a => (globalThis = $h͏_a)]],["apply",[$h͏_a => (apply = $h͏_a)]],["arrayForEach",[$h͏_a => (arrayForEach = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["getOwnPropertyDescriptor",[$h͏_a => (getOwnPropertyDescriptor = $h͏_a)]],["getOwnPropertyDescriptors",[$h͏_a => (getOwnPropertyDescriptors = $h͏_a)]],["getPrototypeOf",[$h͏_a => (getPrototypeOf = $h͏_a)]],["isInteger",[$h͏_a => (isInteger = $h͏_a)]],["isPrimitive",[$h͏_a => (isPrimitive = $h͏_a)]],["hasOwn",[$h͏_a => (hasOwn = $h͏_a)]],["ownKeys",[$h͏_a => (ownKeys = $h͏_a)]],["preventExtensions",[$h͏_a => (preventExtensions = $h͏_a)]],["setAdd",[$h͏_a => (setAdd = $h͏_a)]],["setForEach",[$h͏_a => (setForEach = $h͏_a)]],["setHas",[$h͏_a => (setHas = $h͏_a)]],["toStringTagSymbol",[$h͏_a => (toStringTagSymbol = $h͏_a)]],["typedArrayPrototype",[$h͏_a => (typedArrayPrototype = $h͏_a)]],["weaksetAdd",[$h͏_a => (weaksetAdd = $h͏_a)]],["weaksetHas",[$h͏_a => (weaksetHas = $h͏_a)]],["FERAL_STACK_GETTER",[$h͏_a => (FERAL_STACK_GETTER = $h͏_a)]],["FERAL_STACK_SETTER",[$h͏_a => (FERAL_STACK_SETTER = $h͏_a)]],["isError",[$h͏_a => (isError = $h͏_a)]]]],["./error/assert.js", [["assert",[$h͏_a => (assert = $h͏_a)]]]]]);





















































/**
 * @import {Harden} from '../types.js'
 */

// Obtain the string tag accessor of of TypedArray so we can indirectly use the
// TypedArray brand check it employs.
const typedArrayToStringTag = getOwnPropertyDescriptor(
  typedArrayPrototype,
  toStringTagSymbol,
);
assert(typedArrayToStringTag);
const getTypedArrayToStringTag = typedArrayToStringTag.get;
assert(getTypedArrayToStringTag);

// Exported for tests.
/**
 * Duplicates packages/marshal/src/helpers/passStyle-helpers.js to avoid a dependency.
 *
 * @param {unknown} object
 */
       const isTypedArray = object => {
  // The object must pass a brand check or toStringTag will return undefined.
  const tag = apply(getTypedArrayToStringTag, object, []);
  return tag !== undefined;
};

/**
 * Tests if a property key is an integer-valued canonical numeric index.
 * https://tc39.es/ecma262/#sec-canonicalnumericindexstring
 *
 * @param {string | symbol} propertyKey
 */$h͏_once.isTypedArray(isTypedArray);
const isCanonicalIntegerIndexString = propertyKey => {
  const n = +String(propertyKey);
  return isInteger(n) && String(n) === propertyKey;
};

/**
 * @template T
 * @param {ArrayLike<T>} array
 */
const freezeTypedArray = array => {
  preventExtensions(array);

  // Downgrade writable expandos to readonly, even if non-configurable.
  // We get each descriptor individually rather than using
  // getOwnPropertyDescriptors in order to fail safe when encountering
  // an obscure GraalJS issue where getOwnPropertyDescriptor returns
  // undefined for a property that does exist.
  arrayForEach(ownKeys(array), (/** @type {string | symbol} */ name) => {
    const desc = getOwnPropertyDescriptor(array, name);
    assert(desc);
    // TypedArrays are integer-indexed exotic objects, which define special
    // treatment for property names in canonical numeric form:
    // integers in range are permanently writable and non-configurable.
    // https://tc39.es/ecma262/#sec-integer-indexed-exotic-objects
    //
    // This is analogous to the data of a hardened Map or Set,
    // so we carve out this exceptional behavior but make all other
    // properties non-configurable.
    if (!isCanonicalIntegerIndexString(name)) {
      defineProperty(array, name, {
        ...desc,
        writable: false,
        configurable: false,
      });
    }
  });
};

/**
 * Create a `harden` function.
 *
 * @returns {Harden}
 */
       const makeHardener = () => {
  // Use a native hardener if possible.
  if (typeof globalThis.harden === 'function') {
    const safeHarden = globalThis.harden;
    return safeHarden;
  }

  const hardened = new WeakSet();

  const { harden } = {
    /**
     * @template T
     * @param {T} root
     * @returns {T}
     */
    harden(root) {
      const toFreeze = new Set();

      // If val is something we should be freezing but aren't yet,
      // add it to toFreeze.
      /**
       * @param {any} val
       */
      function enqueue(val) {
        if (isPrimitive(val)) {
          // ignore primitives
          return;
        }
        const type = typeof val;
        if (type !== 'object' && type !== 'function') {
          // future proof: break until someone figures out what it should do
          throw TypeError(`Unexpected typeof: ${type}`);
        }
        if (weaksetHas(hardened, val) || setHas(toFreeze, val)) {
          // Ignore if this is an exit, or we've already visited it
          return;
        }
        // console.warn(`adding ${val} to toFreeze`, val);
        setAdd(toFreeze, val);
      }

      /**
       * @param {any} obj
       */
      const baseFreezeAndTraverse = obj => {
        // Now freeze the object to ensure reactive
        // objects such as proxies won't add properties
        // during traversal, before they get frozen.

        // Object are verified before being enqueued,
        // therefore this is a valid candidate.
        // Throws if this fails (strict mode).
        // Also throws if the object is an ArrayBuffer or any TypedArray.
        if (isTypedArray(obj)) {
          freezeTypedArray(obj);
        } else {
          freeze(obj);
        }

        // we rely upon certain commitments of Object.freeze and proxies here

        // get stable/immutable outbound links before a Proxy has a chance to do
        // something sneaky.
        const descs = getOwnPropertyDescriptors(obj);
        const proto = getPrototypeOf(obj);
        enqueue(proto);

        arrayForEach(ownKeys(descs), (/** @type {string | symbol} */ name) => {
          // The 'name' may be a symbol, and TypeScript doesn't like us to
          // index arbitrary symbols on objects, so we pretend they're just
          // strings.
          const desc = descs[/** @type {string} */ (name)];
          // getOwnPropertyDescriptors is guaranteed to return well-formed
          // descriptors, but they still inherit from Object.prototype. If
          // someone has poisoned Object.prototype to add 'value' or 'get'
          // properties, then a simple 'if ("value" in desc)' or 'desc.value'
          // test could be confused. We use hasOwnProperty to be sure about
          // whether 'value' is present or not, which tells us for sure that
          // this is a data property.
          if (hasOwn(desc, 'value')) {
            enqueue(desc.value);
          } else {
            enqueue(desc.get);
            enqueue(desc.set);
          }
        });
      };

      const freezeAndTraverse =
        FERAL_STACK_GETTER === undefined && FERAL_STACK_SETTER === undefined
          ? // On platforms without v8's error own stack accessor problem,
            // don't pay for any extra overhead.
            baseFreezeAndTraverse
          : obj => {
              if (isError(obj)) {
                // Only pay the overhead if it first passes this cheap isError
                // check. Otherwise, it will be unrepaired, but won't be judged
                // to be a passable error anyway, so will not be unsafe.
                const stackDesc = getOwnPropertyDescriptor(obj, 'stack');
                if (
                  stackDesc &&
                  stackDesc.get === FERAL_STACK_GETTER &&
                  stackDesc.configurable
                ) {
                  // Can only repair if it is configurable. Otherwise, leave
                  // unrepaired, in which case it will not be judged passable,
                  // avoiding a safety problem.
                  defineProperty(obj, 'stack', {
                    // NOTE: Calls getter during harden, which seems dangerous.
                    // But we're only calling the problematic getter whose
                    // hazards we think we understand.
                    // @ts-expect-error TS should know FERAL_STACK_GETTER
                    // cannot be `undefined` here.
                    // See https://github.com/endojs/endo/pull/2232#discussion_r1575179471
                    value: apply(FERAL_STACK_GETTER, obj, []),
                  });
                }
              }
              return baseFreezeAndTraverse(obj);
            };

      const dequeue = () => {
        // New values added before forEach() has finished will be visited.
        setForEach(toFreeze, freezeAndTraverse);
      };

      /** @param {any} value */
      const markHardened = value => {
        weaksetAdd(hardened, value);
      };

      const commit = () => {
        setForEach(toFreeze, markHardened);
      };

      enqueue(root);
      dequeue();
      // console.warn("toFreeze set:", toFreeze);
      commit();

      return root;
    },
  };

  return harden;
};$h͏_once.makeHardener(makeHardener);
})()
,
// === 15. ses ./src/cauterize-property.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let hasOwn;$h͏_imports([["./commons.js", [["hasOwn",[$h͏_a => (hasOwn = $h͏_a)]]]]]);

/**
 * @import {Reporter} from './reporting-types.js'
 */

/**
 * Delete `obj[prop]` or at least make it harmless.
 *
 * If the property was not expected, then emit a reporter-dependent warning
 * to bring attention to this case, so someone can determine what to do with it.
 *
 * If the property to be deleted is a function's `.prototype` property, this
 * will normally be because the function was supposed to be a
 * - builtin method or non-constructor function
 * - arrow function
 * - concise method
 *
 * all of whom are not supposed to have a `.prototype` property. Nevertheless,
 * on some platforms (like older versions of Hermes), or as a result of
 * some shim-based mods to the primordials (like core-js?), some of these
 * functions may accidentally be more like `function` functions with
 * an undeletable `.prototype` property. In these cases, if we can
 * set the value of that bogus `.prototype` property to `undefined`,
 * we do so, issuing a warning, rather than failing to initialize ses.
 *
 * @param {object} obj
 * @param {PropertyKey} prop
 * @param {boolean} known If deletion is expected, don't warn
 * @param {string} subPath Used for warning messages
 * @param {Reporter} reporter Where to issue warning or error.
 * @returns {void}
 */
       const cauterizeProperty = (
  obj,
  prop,
  known,
  subPath,
  { warn, error },
) => {
  // Either the object lacks a permit or the object doesn't match the
  // permit.
  // If the permit is specifically false, not merely undefined,
  // this is a property we expect to see because we know it exists in
  // some environments and we have expressly decided to exclude it.
  // Any other disallowed property is one we have not audited and we log
  // that we are removing it so we know to look into it, as happens when
  // the language evolves new features to existing intrinsics.
  if (!known) {
    warn(`Removing ${subPath}`);
  }
  try {
    delete obj[prop];
  } catch (err) {
    if (hasOwn(obj, prop)) {
      if (typeof obj === 'function' && prop === 'prototype') {
        obj.prototype = undefined;
        if (obj.prototype === undefined) {
          warn(`Tolerating undeletable ${subPath} === undefined`);
          return;
        }
      }
      error(`failed to delete ${subPath}`, err);
    } else {
      error(`deleting ${subPath} threw`, err);
    }
    throw err;
  }
};$h͏_once.cauterizeProperty(cauterizeProperty);
})()
,
// === 16. ses ./src/permits.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let arrayPush,arrayForEach;$h͏_imports([["./commons.js", [["arrayPush",[$h͏_a => (arrayPush = $h͏_a)]],["arrayForEach",[$h͏_a => (arrayForEach = $h͏_a)]]]]]);




/** @import {GenericErrorConstructor} from '../types.js' */

/**
 * Exports {@code permits}, a recursively defined
 * JSON record enumerating all intrinsics and their properties
 * according to ECMA specs.
 *
 * @author JF Paradis
 * @author Mark S. Miller
 *
 * @module
 */

/**
 * constantProperties
 * non-configurable, non-writable data properties of all global objects.
 * Must be powerless.
 * Maps from property name to the actual value
 */
       const constantProperties = {
  // *** Value Properties of the Global Object

  Infinity,
  NaN,
  undefined,
};

/**
 * universalPropertyNames
 * Properties of all global objects.
 * Must be powerless.
 * Maps from property name to the intrinsic name in the permits.
 */$h͏_once.constantProperties(constantProperties);
       const universalPropertyNames = {
  // *** Function Properties of the Global Object

  isFinite: 'isFinite',
  isNaN: 'isNaN',
  parseFloat: 'parseFloat',
  parseInt: 'parseInt',

  decodeURI: 'decodeURI',
  decodeURIComponent: 'decodeURIComponent',
  encodeURI: 'encodeURI',
  encodeURIComponent: 'encodeURIComponent',

  // *** Constructor Properties of the Global Object

  Array: 'Array',
  ArrayBuffer: 'ArrayBuffer',
  BigInt: 'BigInt',
  BigInt64Array: 'BigInt64Array',
  BigUint64Array: 'BigUint64Array',
  Boolean: 'Boolean',
  DataView: 'DataView',
  EvalError: 'EvalError',
  // https://github.com/tc39/proposal-float16array
  Float16Array: 'Float16Array',
  Float32Array: 'Float32Array',
  Float64Array: 'Float64Array',
  Int8Array: 'Int8Array',
  Int16Array: 'Int16Array',
  Int32Array: 'Int32Array',
  Map: 'Map',
  Number: 'Number',
  Object: 'Object',
  Promise: 'Promise',
  Proxy: 'Proxy',
  RangeError: 'RangeError',
  ReferenceError: 'ReferenceError',
  Set: 'Set',
  String: 'String',
  SyntaxError: 'SyntaxError',
  TypeError: 'TypeError',
  Uint8Array: 'Uint8Array',
  Uint8ClampedArray: 'Uint8ClampedArray',
  Uint16Array: 'Uint16Array',
  Uint32Array: 'Uint32Array',
  URIError: 'URIError',
  WeakMap: 'WeakMap',
  WeakSet: 'WeakSet',
  // https://github.com/tc39/proposal-iterator-helpers
  Iterator: 'Iterator',
  // https://github.com/tc39/proposal-async-iterator-helpers
  AsyncIterator: 'AsyncIterator',
  // https://github.com/endojs/endo/issues/550
  AggregateError: 'AggregateError',

  // https://github.com/tc39/proposal-explicit-resource-management
  // TODO DisposableStack, AsyncDisposableStack
  // DisposableStack: 'DisposableStack',
  // AsyncDisposableStack: 'AsyncDisposableStack',

  // https://tc39.es/proposal-shadowrealm/
  // TODO ShadowRealm
  // ShadowRealm: 'ShadowRealm',

  // *** Other Properties of the Global Object

  JSON: 'JSON',
  Reflect: 'Reflect',

  // *** Annex B

  escape: 'escape',
  unescape: 'unescape',

  // ESNext

  // https://github.com/tc39/proposal-source-phase-imports?tab=readme-ov-file#js-module-source
  ModuleSource: 'ModuleSource',

  lockdown: 'lockdown',
  harden: 'harden',

  HandledPromise: 'HandledPromise'  // TODO: Until Promise.delegate (see below).
};

/**
 * initialGlobalPropertyNames
 * Those found only on the initial global, i.e., the global of the
 * start compartment, as well as any compartments created before lockdown.
 * These may provide much of the power provided by the original.
 * Maps from property name to the intrinsic name in the permits.
 */$h͏_once.universalPropertyNames(universalPropertyNames);
       const initialGlobalPropertyNames = {
  // *** Constructor Properties of the Global Object

  Date: '%InitialDate%',
  Error: '%InitialError%',
  RegExp: '%InitialRegExp%',

  // Omit `Symbol`, because we want the original to appear on the
  // start compartment without passing through the permits mechanism, since
  // we want to preserve all its properties, even if we never heard of them.
  // Symbol: '%InitialSymbol%',

  // *** Other Properties of the Global Object

  Math: '%InitialMath%',

  // ESNext

  // From Error-stack proposal
  // Only on initial global. No corresponding
  // powerless form for other globals.
  getStackString: '%InitialGetStackString%'

  // TODO https://github.com/Agoric/SES-shim/issues/551
  // Need initial WeakRef and FinalizationGroup in
  // start compartment only.

  // TODO Temporal
  // https://github.com/tc39/proposal-temporal
  // Temporal: '%InitialTemporal%' // with Temporal.Now
};

/**
 * sharedGlobalPropertyNames
 * Those found only on the globals of new compartments created after lockdown,
 * which must therefore be powerless.
 * Maps from property name to the intrinsic name in the permits.
 */$h͏_once.initialGlobalPropertyNames(initialGlobalPropertyNames);
       const sharedGlobalPropertyNames = {
  // *** Constructor Properties of the Global Object

  Date: '%SharedDate%',
  Error: '%SharedError%',
  RegExp: '%SharedRegExp%',
  Symbol: '%SharedSymbol%',

  // *** Other Properties of the Global Object

  Math: '%SharedMath%'

  // TODO Temporal
  // https://github.com/tc39/proposal-temporal
  // Temporal: '%SharedTemporal%' // without Temporal.Now
};

/**
 * uniqueGlobalPropertyNames
 * Those made separately for each global, including the initial global
 * of the start compartment.
 * Maps from property name to the intrinsic name in the permits
 * (which is currently always the same).
 */$h͏_once.sharedGlobalPropertyNames(sharedGlobalPropertyNames);
       const uniqueGlobalPropertyNames = {
  // *** Value Properties of the Global Object

  globalThis: '%UniqueGlobalThis%',

  // *** Function Properties of the Global Object

  eval: '%UniqueEval%',

  // *** Constructor Properties of the Global Object

  Function: '%UniqueFunction%',

  // *** Other Properties of the Global Object

  // ESNext

  Compartment: '%UniqueCompartment%'
  // According to current agreements, eventually the Realm constructor too.
  // 'Realm',
};

// All the "subclasses" of Error. These are collectively represented in the
// ECMAScript spec by the meta variable NativeError.
/** @type {GenericErrorConstructor[]} */$h͏_once.uniqueGlobalPropertyNames(uniqueGlobalPropertyNames);
const NativeErrors = [
  EvalError,
  RangeError,
  ReferenceError,
  SyntaxError,
  TypeError,
  URIError
  // https://github.com/endojs/endo/issues/550
  // Commented out to accommodate platforms prior to AggregateError.
  // Instead, conditional push below.
  // AggregateError,
];$h͏_once.NativeErrors(NativeErrors);

if (typeof AggregateError !== 'undefined') {
  // Conditional, to accommodate platforms prior to AggregateError
  arrayPush(NativeErrors, AggregateError);
}



/**
 * <p>Each JSON record enumerates the disposition of the properties on
 *    some corresponding intrinsic object.
 *
 * <p>All records are made of key-value pairs where the key
 *    is the property to process, and the value is the associated
 *    dispositions a.k.a. the "permit". Those permits can be:
 * <ul>
 * <li>The boolean value "false", in which case this property is
 *     blacklisted and simply removed. Properties not mentioned
 *     are also considered blacklisted and are removed.
 * <li>A string value equal to a primitive ("number", "string", etc),
 *     in which case the property is permitted if its value property
 *     is typeof the given type. For example, {@code "Infinity"} leads to
 *     "number" and property values that fail {@code typeof "number"}.
 *     are removed.
 * <li>A string value equal to an intinsic name ("ObjectPrototype",
 *     "Array", etc), in which case the property permitted if its
 *     value property is equal to the value of the corresponfing
 *     intrinsics. For example, {@code Map.prototype} leads to
 *     "MapPrototype" and the property is removed if its value is
 *     not equal to %MapPrototype%
 * <li>Another record, in which case this property is simply
 *     permitted and that next record represents the disposition of
 *     the object which is its value. For example, {@code "Object"}
 *     leads to another record explaining what properties {@code
 *     "Object"} may have and how each such property should be treated.
 *
 * <p>Notes:
 * <li>"[[Proto]]" is used to refer to the "[[Prototype]]" internal
 *     slot, which says which object this object inherits from.
 * <li>"--proto--" is used to refer to the "__proto__" property name,
 *     which is the name of an accessor property on Object.prototype.
 *     In practice, it is used to access the [[Proto]] internal slot,
 *     but is distinct from the internal slot itself. We use
 *     "--proto--" rather than "__proto__" below because "__proto__"
 *     in an object literal is special syntax rather than a normal
 *     property definition.
 * <li>"ObjectPrototype" is the default "[[Proto]]" (when not specified).
 * <li>Constants "fn" and "getter" are used to keep the structure DRY.
 * <li>Symbol properties are listed as follow:
 *     <li>Well-known symbols use the "@@name" form.
 *     <li>Registered symbols use the "RegisteredSymbol(key)" form.
 *     <li>Unique symbols use the "UniqueSymbol(description)" form.
 */

// Function Instances
       const FunctionInstance = {
  '[[Proto]]': '%FunctionPrototype%',
  length: 'number',
  name: 'string'
  // Do not specify "prototype" here, since only Function instances that can
  // be used as a constructor have a prototype property. For constructors,
  // since prototype properties are instance-specific, we define it there.
};

// AsyncFunction Instances
$h͏_once.FunctionInstance(FunctionInstance);const AsyncFunctionInstance={
  // This property is not mentioned in ECMA 262, but is present in V8 and
  // necessary for lockdown to succeed.
  '[[Proto]]': '%AsyncFunctionPrototype%',
};

// Aliases
$h͏_once.AsyncFunctionInstance(AsyncFunctionInstance);const fn=FunctionInstance;
const asyncFn = AsyncFunctionInstance;

const getter = {
  get: fn,
  set: 'undefined',
};

// Possible but not encountered in the specs
// export const setter = {
//   get: 'undefined',
//   set: fn,
// };

const accessor = {
  get: fn,
  set: fn,
};

// eslint-disable-next-line func-names
const strict = function () {
  'use strict';
};

// TODO Remove this once we no longer support the Hermes that needed this.
arrayForEach(['caller', 'arguments'], prop => {
  try {
    strict[prop];
  } catch (e) {
    // https://github.com/facebook/hermes/blob/main/test/hermes/function-non-strict.js
    if (e.message === 'Restricted in strict mode') {
      // Fixed in Static Hermes: https://github.com/facebook/hermes/issues/1582
      FunctionInstance[prop] = accessor;
    }
  }
});

       const isAccessorPermit = permit => {
  return permit === getter || permit === accessor;
};

// NativeError Object Structure
$h͏_once.isAccessorPermit(isAccessorPermit);function NativeError(prototype){
  return {
    // Properties of the NativeError Constructors
    '[[Proto]]': '%SharedError%',

    // NativeError.prototype
    prototype,
  };
}

function NativeErrorPrototype(constructor) {
  return {
    // Properties of the NativeError Prototype Objects
    '[[Proto]]': '%ErrorPrototype%',
    constructor,
    message: 'string',
    name: 'string',
    // Redundantly present only on v8. Safe to remove.
    toString: false,
    // Superfluously present in some versions of V8.
    // https://github.com/tc39/notes/blob/master/meetings/2021-10/oct-26.md#:~:text=However%2C%20Chrome%2093,and%20node%2016.11.
    cause: false,
  };
}

// The TypedArray Constructors
function TypedArray(prototype) {
  return {
    // Properties of the TypedArray Constructors
    '[[Proto]]': '%TypedArray%',
    BYTES_PER_ELEMENT: 'number',
    prototype,
  };
}

function TypedArrayPrototype(constructor) {
  return {
    // Properties of the TypedArray Prototype Objects
    '[[Proto]]': '%TypedArrayPrototype%',
    BYTES_PER_ELEMENT: 'number',
    constructor,
  };
}

// Without Math.random
const CommonMath = {
  E: 'number',
  LN10: 'number',
  LN2: 'number',
  LOG10E: 'number',
  LOG2E: 'number',
  PI: 'number',
  SQRT1_2: 'number',
  SQRT2: 'number',
  '@@toStringTag': 'string',
  abs: fn,
  acos: fn,
  acosh: fn,
  asin: fn,
  asinh: fn,
  atan: fn,
  atanh: fn,
  atan2: fn,
  cbrt: fn,
  ceil: fn,
  clz32: fn,
  cos: fn,
  cosh: fn,
  exp: fn,
  expm1: fn,
  floor: fn,
  fround: fn,
  hypot: fn,
  imul: fn,
  log: fn,
  log1p: fn,
  log10: fn,
  log2: fn,
  max: fn,
  min: fn,
  pow: fn,
  round: fn,
  sign: fn,
  sin: fn,
  sinh: fn,
  sqrt: fn,
  tan: fn,
  tanh: fn,
  trunc: fn,
  // https://github.com/tc39/proposal-float16array
  f16round: fn,
  // https://github.com/tc39/proposal-math-sum
  sumPrecise: fn,

  // See https://github.com/Moddable-OpenSource/moddable/issues/523
  idiv: false,
  // See https://github.com/Moddable-OpenSource/moddable/issues/523
  idivmod: false,
  // See https://github.com/Moddable-OpenSource/moddable/issues/523
  imod: false,
  // See https://github.com/Moddable-OpenSource/moddable/issues/523
  imuldiv: false,
  // See https://github.com/Moddable-OpenSource/moddable/issues/523
  irem: false,
  // See https://github.com/Moddable-OpenSource/moddable/issues/523
  mod: false,
  // See https://github.com/Moddable-OpenSource/moddable/issues/523#issuecomment-1942904505
  irandom: false,
};

       const permitted = {
  // ECMA https://tc39.es/ecma262

  // The intrinsics object has no prototype to avoid conflicts.
  '[[Proto]]': null,

  // %ThrowTypeError%
  '%ThrowTypeError%': fn,

  // *** The Global Object

  // *** Value Properties of the Global Object
  Infinity: 'number',
  NaN: 'number',
  undefined: 'undefined',

  // *** Function Properties of the Global Object

  // eval
  '%UniqueEval%': fn,
  isFinite: fn,
  isNaN: fn,
  parseFloat: fn,
  parseInt: fn,
  decodeURI: fn,
  decodeURIComponent: fn,
  encodeURI: fn,
  encodeURIComponent: fn,

  // *** Fundamental Objects

  Object: {
    // Properties of the Object Constructor
    '[[Proto]]': '%FunctionPrototype%',
    assign: fn,
    create: fn,
    defineProperties: fn,
    defineProperty: fn,
    entries: fn,
    freeze: fn,
    fromEntries: fn,
    getOwnPropertyDescriptor: fn,
    getOwnPropertyDescriptors: fn,
    getOwnPropertyNames: fn,
    getOwnPropertySymbols: fn,
    getPrototypeOf: fn,
    is: fn,
    isExtensible: fn,
    isFrozen: fn,
    isSealed: fn,
    keys: fn,
    preventExtensions: fn,
    prototype: '%ObjectPrototype%',
    seal: fn,
    setPrototypeOf: fn,
    values: fn,
    'RegisteredSymbol(harden)': {
      ...fn,
      // Installed with hardenTaming: 'unsafe'
      isFake: 'boolean',
    },
    // https://github.com/tc39/proposal-accessible-object-hasownproperty
    hasOwn: fn,
    // https://github.com/tc39/proposal-array-grouping
    groupBy: fn,
    // Seen on QuickJS
    __getClass: false,
  },

  '%ObjectPrototype%': {
    // Properties of the Object Prototype Object
    '[[Proto]]': null,
    constructor: 'Object',
    hasOwnProperty: fn,
    isPrototypeOf: fn,
    propertyIsEnumerable: fn,
    toLocaleString: fn,
    toString: fn,
    valueOf: fn,

    // Annex B: Additional Properties of the Object.prototype Object

    // See note in header about the difference between [[Proto]] and --proto--
    // special notations.
    '--proto--': accessor,
    __defineGetter__: fn,
    __defineSetter__: fn,
    __lookupGetter__: fn,
    __lookupSetter__: fn,
  },

  '%UniqueFunction%': {
    // Properties of the Function Constructor
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%FunctionPrototype%',
  },

  '%InertFunction%': {
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%FunctionPrototype%',
  },

  '%FunctionPrototype%': {
    apply: fn,
    bind: fn,
    call: fn,
    constructor: '%InertFunction%',
    toString: fn,
    '@@hasInstance': fn,
    // proposed but not yet std. To be removed if there
    caller: false,
    // proposed but not yet std. To be removed if there
    arguments: false,
    // Seen on QuickJS. TODO grab getter for use by console
    fileName: false,
    // Seen on QuickJS. TODO grab getter for use by console
    lineNumber: false,
  },

  Boolean: {
    // Properties of the Boolean Constructor
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%BooleanPrototype%',
  },

  '%BooleanPrototype%': {
    constructor: 'Boolean',
    toString: fn,
    valueOf: fn,
  },

  '%SharedSymbol%': {
    // Properties of the Symbol Constructor
    '[[Proto]]': '%FunctionPrototype%',
    asyncIterator: 'symbol',
    for: fn,
    hasInstance: 'symbol',
    isConcatSpreadable: 'symbol',
    iterator: 'symbol',
    keyFor: fn,
    match: 'symbol',
    matchAll: 'symbol',
    prototype: '%SymbolPrototype%',
    replace: 'symbol',
    search: 'symbol',
    species: 'symbol',
    split: 'symbol',
    toPrimitive: 'symbol',
    toStringTag: 'symbol',
    unscopables: 'symbol',
    // https://github.com/tc39/proposal-explicit-resource-management
    asyncDispose: 'symbol',
    // https://github.com/tc39/proposal-explicit-resource-management
    dispose: 'symbol',
    // Seen at core-js https://github.com/zloirock/core-js#ecmascript-symbol
    useSimple: false,
    // Seen at core-js https://github.com/zloirock/core-js#ecmascript-symbol
    useSetter: false,
    // Seen on QuickJS
    operatorSet: false,
  },

  '%SymbolPrototype%': {
    // Properties of the Symbol Prototype Object
    constructor: '%SharedSymbol%',
    description: getter,
    toString: fn,
    valueOf: fn,
    '@@toPrimitive': fn,
    '@@toStringTag': 'string',
  },

  '%InitialError%': {
    // Properties of the Error Constructor
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%ErrorPrototype%',
    // Non standard, v8 only, used by tap
    captureStackTrace: fn,
    // Non standard, v8 only, used by tap, tamed to accessor
    stackTraceLimit: accessor,
    // Non standard, v8 only, used by several, tamed to accessor
    prepareStackTrace: accessor,
    // https://github.com/tc39/proposal-is-error
    isError: fn,
  },

  '%SharedError%': {
    // Properties of the Error Constructor
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%ErrorPrototype%',
    // Non standard, v8 only, used by tap
    captureStackTrace: fn,
    // Non standard, v8 only, used by tap, tamed to accessor
    stackTraceLimit: accessor,
    // Non standard, v8 only, used by several, tamed to accessor
    prepareStackTrace: accessor,
    // https://github.com/tc39/proposal-is-error
    isError: fn,
  },

  '%ErrorPrototype%': {
    constructor: '%SharedError%',
    message: 'string',
    name: 'string',
    toString: fn,
    // proposed de-facto, assumed TODO
    // Seen on FF Nightly 88.0a1
    at: false,
    // Seen on FF and XS
    stack: accessor,
    // Superfluously present in some versions of V8.
    // https://github.com/tc39/notes/blob/master/meetings/2021-10/oct-26.md#:~:text=However%2C%20Chrome%2093,and%20node%2016.11.
    cause: false,
  },

  // NativeError

  EvalError: NativeError('%EvalErrorPrototype%'),
  RangeError: NativeError('%RangeErrorPrototype%'),
  ReferenceError: NativeError('%ReferenceErrorPrototype%'),
  SyntaxError: NativeError('%SyntaxErrorPrototype%'),
  TypeError: NativeError('%TypeErrorPrototype%'),
  URIError: NativeError('%URIErrorPrototype%'),
  // https://github.com/endojs/endo/issues/550
  AggregateError: NativeError('%AggregateErrorPrototype%'),

  // TODO SuppressedError
  // https://github.com/tc39/proposal-explicit-resource-management
  // SuppressedError: NativeError('%SuppressedErrorPrototype%'),

  '%EvalErrorPrototype%': NativeErrorPrototype('EvalError'),
  '%RangeErrorPrototype%': NativeErrorPrototype('RangeError'),
  '%ReferenceErrorPrototype%': NativeErrorPrototype('ReferenceError'),
  '%SyntaxErrorPrototype%': NativeErrorPrototype('SyntaxError'),
  '%TypeErrorPrototype%': NativeErrorPrototype('TypeError'),
  '%URIErrorPrototype%': NativeErrorPrototype('URIError'),
  // https://github.com/endojs/endo/issues/550
  '%AggregateErrorPrototype%': NativeErrorPrototype('AggregateError'),
  // TODO AggregateError .errors

  // TODO SuppressedError
  // https://github.com/tc39/proposal-explicit-resource-management
  // '%SuppressedErrorPrototype%': NativeErrorPrototype('SuppressedError'),
  // TODO SuppressedError .error
  // TODO SuppressedError .suppressed

  // *** Numbers and Dates

  Number: {
    // Properties of the Number Constructor
    '[[Proto]]': '%FunctionPrototype%',
    EPSILON: 'number',
    isFinite: fn,
    isInteger: fn,
    isNaN: fn,
    isSafeInteger: fn,
    MAX_SAFE_INTEGER: 'number',
    MAX_VALUE: 'number',
    MIN_SAFE_INTEGER: 'number',
    MIN_VALUE: 'number',
    NaN: 'number',
    NEGATIVE_INFINITY: 'number',
    parseFloat: fn,
    parseInt: fn,
    POSITIVE_INFINITY: 'number',
    prototype: '%NumberPrototype%',
  },

  '%NumberPrototype%': {
    // Properties of the Number Prototype Object
    constructor: 'Number',
    toExponential: fn,
    toFixed: fn,
    toLocaleString: fn,
    toPrecision: fn,
    toString: fn,
    valueOf: fn,
  },

  BigInt: {
    // Properties of the BigInt Constructor
    '[[Proto]]': '%FunctionPrototype%',
    asIntN: fn,
    asUintN: fn,
    prototype: '%BigIntPrototype%',
    // See https://github.com/Moddable-OpenSource/moddable/issues/523
    bitLength: false,
    // See https://github.com/Moddable-OpenSource/moddable/issues/523
    fromArrayBuffer: false,
    // Seen on QuickJS
    tdiv: false,
    // Seen on QuickJS
    fdiv: false,
    // Seen on QuickJS
    cdiv: false,
    // Seen on QuickJS
    ediv: false,
    // Seen on QuickJS
    tdivrem: false,
    // Seen on QuickJS
    fdivrem: false,
    // Seen on QuickJS
    cdivrem: false,
    // Seen on QuickJS
    edivrem: false,
    // Seen on QuickJS
    sqrt: false,
    // Seen on QuickJS
    sqrtrem: false,
    // Seen on QuickJS
    floorLog2: false,
    // Seen on QuickJS
    ctz: false,
  },

  '%BigIntPrototype%': {
    constructor: 'BigInt',
    toLocaleString: fn,
    toString: fn,
    valueOf: fn,
    '@@toStringTag': 'string',
  },

  '%InitialMath%': {
    ...CommonMath,
    // `%InitialMath%.random()` has the standard unsafe behavior
    random: fn,
  },

  '%SharedMath%': {
    ...CommonMath,
    // `%SharedMath%.random()` is tamed to always throw
    random: fn,
  },

  '%InitialDate%': {
    // Properties of the Date Constructor
    '[[Proto]]': '%FunctionPrototype%',
    now: fn,
    parse: fn,
    prototype: '%DatePrototype%',
    UTC: fn,
  },

  '%SharedDate%': {
    // Properties of the Date Constructor
    '[[Proto]]': '%FunctionPrototype%',
    // `%SharedDate%.now()` is tamed to always throw
    now: fn,
    parse: fn,
    prototype: '%DatePrototype%',
    UTC: fn,
  },

  '%DatePrototype%': {
    constructor: '%SharedDate%',
    getDate: fn,
    getDay: fn,
    getFullYear: fn,
    getHours: fn,
    getMilliseconds: fn,
    getMinutes: fn,
    getMonth: fn,
    getSeconds: fn,
    getTime: fn,
    getTimezoneOffset: fn,
    getUTCDate: fn,
    getUTCDay: fn,
    getUTCFullYear: fn,
    getUTCHours: fn,
    getUTCMilliseconds: fn,
    getUTCMinutes: fn,
    getUTCMonth: fn,
    getUTCSeconds: fn,
    setDate: fn,
    setFullYear: fn,
    setHours: fn,
    setMilliseconds: fn,
    setMinutes: fn,
    setMonth: fn,
    setSeconds: fn,
    setTime: fn,
    setUTCDate: fn,
    setUTCFullYear: fn,
    setUTCHours: fn,
    setUTCMilliseconds: fn,
    setUTCMinutes: fn,
    setUTCMonth: fn,
    setUTCSeconds: fn,
    toDateString: fn,
    toISOString: fn,
    toJSON: fn,
    toLocaleDateString: fn,
    toLocaleString: fn,
    toLocaleTimeString: fn,
    toString: fn,
    toTimeString: fn,
    toUTCString: fn,
    valueOf: fn,
    '@@toPrimitive': fn,

    // Annex B: Additional Properties of the Date.prototype Object
    getYear: fn,
    setYear: fn,
    toGMTString: fn,
  },

  // Text Processing

  String: {
    // Properties of the String Constructor
    '[[Proto]]': '%FunctionPrototype%',
    fromCharCode: fn,
    fromCodePoint: fn,
    prototype: '%StringPrototype%',
    raw: fn,
    // See https://github.com/Moddable-OpenSource/moddable/issues/523
    fromArrayBuffer: false,
  },

  '%StringPrototype%': {
    // Properties of the String Prototype Object
    length: 'number',
    charAt: fn,
    charCodeAt: fn,
    codePointAt: fn,
    concat: fn,
    constructor: 'String',
    endsWith: fn,
    includes: fn,
    indexOf: fn,
    lastIndexOf: fn,
    localeCompare: fn,
    match: fn,
    matchAll: fn,
    normalize: fn,
    padEnd: fn,
    padStart: fn,
    repeat: fn,
    replace: fn,
    replaceAll: fn, // ES2021
    search: fn,
    slice: fn,
    split: fn,
    startsWith: fn,
    substring: fn,
    toLocaleLowerCase: fn,
    toLocaleUpperCase: fn,
    toLowerCase: fn,
    toString: fn,
    toUpperCase: fn,
    trim: fn,
    trimEnd: fn,
    trimStart: fn,
    valueOf: fn,
    '@@iterator': fn,
    // Failed tc39 proposal
    // https://github.com/tc39/proposal-relative-indexing-method
    at: fn,
    // https://github.com/tc39/proposal-is-usv-string
    isWellFormed: fn,
    toWellFormed: fn,
    unicodeSets: fn,

    // Annex B: Additional Properties of the String.prototype Object
    substr: fn,
    anchor: fn,
    big: fn,
    blink: fn,
    bold: fn,
    fixed: fn,
    fontcolor: fn,
    fontsize: fn,
    italics: fn,
    link: fn,
    small: fn,
    strike: fn,
    sub: fn,
    sup: fn,
    trimLeft: fn,
    trimRight: fn,
    // See https://github.com/Moddable-OpenSource/moddable/issues/523
    compare: false,
    // Seen on QuickJS
    __quote: false,
  },

  '%StringIteratorPrototype%': {
    '[[Proto]]': '%IteratorPrototype%',
    next: fn,
    '@@toStringTag': 'string',
  },

  '%InitialRegExp%': {
    // Properties of the RegExp Constructor
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%RegExpPrototype%',
    '@@species': getter,
    // https://github.com/tc39/proposal-regex-escaping
    escape: fn,

    // The https://github.com/tc39/proposal-regexp-legacy-features
    // are all optional, unsafe, and omitted
    input: false,
    $_: false,
    lastMatch: false,
    '$&': false,
    lastParen: false,
    '$+': false,
    leftContext: false,
    '$`': false,
    rightContext: false,
    "$'": false,
    $1: false,
    $2: false,
    $3: false,
    $4: false,
    $5: false,
    $6: false,
    $7: false,
    $8: false,
    $9: false,
  },

  '%SharedRegExp%': {
    // Properties of the RegExp Constructor
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%RegExpPrototype%',
    '@@species': getter,
    // https://github.com/tc39/proposal-regex-escaping
    escape: fn,
  },

  '%RegExpPrototype%': {
    // Properties of the RegExp Prototype Object
    constructor: '%SharedRegExp%',
    exec: fn,
    dotAll: getter,
    flags: getter,
    global: getter,
    hasIndices: getter,
    ignoreCase: getter,
    '@@match': fn,
    '@@matchAll': fn,
    multiline: getter,
    '@@replace': fn,
    '@@search': fn,
    source: getter,
    '@@split': fn,
    sticky: getter,
    test: fn,
    toString: fn,
    unicode: getter,
    unicodeSets: getter,

    // Annex B: Additional Properties of the RegExp.prototype Object
    compile: false  // UNSAFE and suppressed.
  },

  '%RegExpStringIteratorPrototype%': {
    // The %RegExpStringIteratorPrototype% Object
    '[[Proto]]': '%IteratorPrototype%',
    next: fn,
    '@@toStringTag': 'string',
  },

  // Indexed Collections

  Array: {
    // Properties of the Array Constructor
    '[[Proto]]': '%FunctionPrototype%',
    from: fn,
    isArray: fn,
    of: fn,
    prototype: '%ArrayPrototype%',
    '@@species': getter,

    // Failed tc39 proposal
    // https://tc39.es/proposal-relative-indexing-method/
    at: fn,
    // https://tc39.es/proposal-array-from-async/
    fromAsync: fn,
  },

  '%ArrayPrototype%': {
    // Properties of the Array Prototype Object
    length: 'number',
    concat: fn,
    constructor: 'Array',
    copyWithin: fn,
    entries: fn,
    every: fn,
    fill: fn,
    filter: fn,
    find: fn,
    findIndex: fn,
    flat: fn,
    flatMap: fn,
    forEach: fn,
    includes: fn,
    indexOf: fn,
    join: fn,
    keys: fn,
    lastIndexOf: fn,
    map: fn,
    pop: fn,
    push: fn,
    reduce: fn,
    reduceRight: fn,
    reverse: fn,
    shift: fn,
    slice: fn,
    some: fn,
    sort: fn,
    splice: fn,
    toLocaleString: fn,
    toString: fn,
    unshift: fn,
    values: fn,
    '@@iterator': fn,
    '@@unscopables': {
      '[[Proto]]': null,
      copyWithin: 'boolean',
      entries: 'boolean',
      fill: 'boolean',
      find: 'boolean',
      findIndex: 'boolean',
      flat: 'boolean',
      flatMap: 'boolean',
      includes: 'boolean',
      keys: 'boolean',
      values: 'boolean',
      // Failed tc39 proposal
      // https://tc39.es/proposal-relative-indexing-method/
      // Seen on FF Nightly 88.0a1
      at: 'boolean',
      // See https://github.com/tc39/proposal-array-find-from-last
      findLast: 'boolean',
      findLastIndex: 'boolean',
      // https://github.com/tc39/proposal-change-array-by-copy
      toReversed: 'boolean',
      toSorted: 'boolean',
      toSpliced: 'boolean',
      with: 'boolean',
      // https://github.com/tc39/proposal-array-grouping
      group: 'boolean',
      groupToMap: 'boolean',
      groupBy: 'boolean',
    },
    // See https://github.com/tc39/proposal-array-find-from-last
    findLast: fn,
    findLastIndex: fn,
    // https://github.com/tc39/proposal-change-array-by-copy
    toReversed: fn,
    toSorted: fn,
    toSpliced: fn,
    with: fn,
    // https://github.com/tc39/proposal-array-grouping
    group: fn, // Not in proposal? Where?
    groupToMap: fn, // Not in proposal? Where?
    groupBy: fn,
    // Failed tc39 proposal
    // https://tc39.es/proposal-relative-indexing-method/
    at: fn,
  },

  '%ArrayIteratorPrototype%': {
    // The %ArrayIteratorPrototype% Object
    '[[Proto]]': '%IteratorPrototype%',
    next: fn,
    '@@toStringTag': 'string',
  },

  // *** TypedArray Objects

  '%TypedArray%': {
    // Properties of the %TypedArray% Intrinsic Object
    '[[Proto]]': '%FunctionPrototype%',
    from: fn,
    of: fn,
    prototype: '%TypedArrayPrototype%',
    '@@species': getter,
  },

  '%TypedArrayPrototype%': {
    buffer: getter,
    byteLength: getter,
    byteOffset: getter,
    constructor: '%TypedArray%',
    copyWithin: fn,
    entries: fn,
    every: fn,
    fill: fn,
    filter: fn,
    find: fn,
    findIndex: fn,
    forEach: fn,
    includes: fn,
    indexOf: fn,
    join: fn,
    keys: fn,
    lastIndexOf: fn,
    length: getter,
    map: fn,
    reduce: fn,
    reduceRight: fn,
    reverse: fn,
    set: fn,
    slice: fn,
    some: fn,
    sort: fn,
    subarray: fn,
    toLocaleString: fn,
    toString: fn,
    values: fn,
    '@@iterator': fn,
    '@@toStringTag': getter,
    // Failed tc39 proposal
    // https://tc39.es/proposal-relative-indexing-method/
    at: fn,
    // See https://github.com/tc39/proposal-array-find-from-last
    findLast: fn,
    findLastIndex: fn,
    // https://github.com/tc39/proposal-change-array-by-copy
    toReversed: fn,
    toSorted: fn,
    with: fn,
  },

  // The TypedArray Constructors

  BigInt64Array: TypedArray('%BigInt64ArrayPrototype%'),
  BigUint64Array: TypedArray('%BigUint64ArrayPrototype%'),
  // https://github.com/tc39/proposal-float16array
  Float16Array: TypedArray('%Float16ArrayPrototype%'),
  Float32Array: TypedArray('%Float32ArrayPrototype%'),
  Float64Array: TypedArray('%Float64ArrayPrototype%'),
  Int16Array: TypedArray('%Int16ArrayPrototype%'),
  Int32Array: TypedArray('%Int32ArrayPrototype%'),
  Int8Array: TypedArray('%Int8ArrayPrototype%'),
  Uint16Array: TypedArray('%Uint16ArrayPrototype%'),
  Uint32Array: TypedArray('%Uint32ArrayPrototype%'),
  Uint8ClampedArray: TypedArray('%Uint8ClampedArrayPrototype%'),
  Uint8Array: {
    ...TypedArray('%Uint8ArrayPrototype%'),
    // https://github.com/tc39/proposal-arraybuffer-base64
    fromBase64: fn,
    // https://github.com/tc39/proposal-arraybuffer-base64
    fromHex: fn,
  },

  '%BigInt64ArrayPrototype%': TypedArrayPrototype('BigInt64Array'),
  '%BigUint64ArrayPrototype%': TypedArrayPrototype('BigUint64Array'),
  // https://github.com/tc39/proposal-float16array
  '%Float16ArrayPrototype%': TypedArrayPrototype('Float16Array'),
  '%Float32ArrayPrototype%': TypedArrayPrototype('Float32Array'),
  '%Float64ArrayPrototype%': TypedArrayPrototype('Float64Array'),
  '%Int16ArrayPrototype%': TypedArrayPrototype('Int16Array'),
  '%Int32ArrayPrototype%': TypedArrayPrototype('Int32Array'),
  '%Int8ArrayPrototype%': TypedArrayPrototype('Int8Array'),
  '%Uint16ArrayPrototype%': TypedArrayPrototype('Uint16Array'),
  '%Uint32ArrayPrototype%': TypedArrayPrototype('Uint32Array'),
  '%Uint8ClampedArrayPrototype%': TypedArrayPrototype('Uint8ClampedArray'),
  '%Uint8ArrayPrototype%': {
    ...TypedArrayPrototype('Uint8Array'),
    // https://github.com/tc39/proposal-arraybuffer-base64
    setFromBase64: fn,
    // https://github.com/tc39/proposal-arraybuffer-base64
    setFromHex: fn,
    // https://github.com/tc39/proposal-arraybuffer-base64
    toBase64: fn,
    // https://github.com/tc39/proposal-arraybuffer-base64
    toHex: fn,
  },

  // *** Keyed Collections

  Map: {
    // Properties of the Map Constructor
    '[[Proto]]': '%FunctionPrototype%',
    '@@species': getter,
    prototype: '%MapPrototype%',
    // https://github.com/tc39/proposal-array-grouping
    groupBy: fn,
  },

  '%MapPrototype%': {
    clear: fn,
    constructor: 'Map',
    delete: fn,
    entries: fn,
    forEach: fn,
    get: fn,
    has: fn,
    keys: fn,
    set: fn,
    size: getter,
    values: fn,
    '@@iterator': fn,
    '@@toStringTag': 'string',
  },

  '%MapIteratorPrototype%': {
    // The %MapIteratorPrototype% Object
    '[[Proto]]': '%IteratorPrototype%',
    next: fn,
    '@@toStringTag': 'string',
  },

  Set: {
    // Properties of the Set Constructor
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%SetPrototype%',
    '@@species': getter,
    // Seen on QuickJS
    groupBy: false,
  },

  '%SetPrototype%': {
    add: fn,
    clear: fn,
    constructor: 'Set',
    delete: fn,
    entries: fn,
    forEach: fn,
    has: fn,
    keys: fn,
    size: getter,
    values: fn,
    '@@iterator': fn,
    '@@toStringTag': 'string',
    // See https://github.com/tc39/proposal-set-methods
    intersection: fn,
    // See https://github.com/tc39/proposal-set-methods
    union: fn,
    // See https://github.com/tc39/proposal-set-methods
    difference: fn,
    // See https://github.com/tc39/proposal-set-methods
    symmetricDifference: fn,
    // See https://github.com/tc39/proposal-set-methods
    isSubsetOf: fn,
    // See https://github.com/tc39/proposal-set-methods
    isSupersetOf: fn,
    // See https://github.com/tc39/proposal-set-methods
    isDisjointFrom: fn,
  },

  '%SetIteratorPrototype%': {
    // The %SetIteratorPrototype% Object
    '[[Proto]]': '%IteratorPrototype%',
    next: fn,
    '@@toStringTag': 'string',
  },

  WeakMap: {
    // Properties of the WeakMap Constructor
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%WeakMapPrototype%',
  },

  '%WeakMapPrototype%': {
    constructor: 'WeakMap',
    delete: fn,
    get: fn,
    has: fn,
    set: fn,
    '@@toStringTag': 'string',
  },

  WeakSet: {
    // Properties of the WeakSet Constructor
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%WeakSetPrototype%',
  },

  '%WeakSetPrototype%': {
    add: fn,
    constructor: 'WeakSet',
    delete: fn,
    has: fn,
    '@@toStringTag': 'string',
  },

  // *** Structured Data

  ArrayBuffer: {
    // Properties of the ArrayBuffer Constructor
    '[[Proto]]': '%FunctionPrototype%',
    isView: fn,
    prototype: '%ArrayBufferPrototype%',
    '@@species': getter,
    // See https://github.com/Moddable-OpenSource/moddable/issues/523
    fromString: false,
    // See https://github.com/Moddable-OpenSource/moddable/issues/523
    fromBigInt: false,
  },

  '%ArrayBufferPrototype%': {
    byteLength: getter,
    constructor: 'ArrayBuffer',
    slice: fn,
    '@@toStringTag': 'string',
    // See https://github.com/Moddable-OpenSource/moddable/issues/523
    concat: false,
    // See https://github.com/tc39/proposal-resizablearraybuffer
    transfer: fn,
    resize: fn,
    resizable: getter,
    maxByteLength: getter,
    // https://github.com/tc39/proposal-arraybuffer-transfer
    transferToFixedLength: fn,
    detached: getter,
    // https://github.com/endojs/endo/pull/2309#issuecomment-2155513240
    // to be proposed
    transferToImmutable: fn,
    sliceToImmutable: fn,
    immutable: getter,
  },

  // If this exists, it is purely an artifact of how we currently shim
  // `transferToImmutable`. As natively implemented, there would be no
  // such extra prototype.
  '%ImmutableArrayBufferPrototype%': {
    '[[Proto]]': '%ArrayBufferPrototype%',
    byteLength: getter,
    slice: fn,
    // See https://github.com/endojs/endo/tree/master/packages/immutable-arraybuffer#purposeful-violation
    '@@toStringTag': 'string',
    // See https://github.com/tc39/proposal-resizablearraybuffer
    transfer: fn,
    resize: fn,
    resizable: getter,
    maxByteLength: getter,
    // https://github.com/tc39/proposal-arraybuffer-transfer
    transferToFixedLength: fn,
    detached: getter,
    // https://github.com/endojs/endo/pull/2309#issuecomment-2155513240
    // to be proposed
    transferToImmutable: fn,
    sliceToImmutable: fn,
    immutable: getter,
  },

  // SharedArrayBuffer Objects
  SharedArrayBuffer: false, // UNSAFE and purposely suppressed.
  '%SharedArrayBufferPrototype%': false, // UNSAFE and purposely suppressed.

  DataView: {
    // Properties of the DataView Constructor
    '[[Proto]]': '%FunctionPrototype%',
    BYTES_PER_ELEMENT: 'number', // Non std but undeletable on Safari.
    prototype: '%DataViewPrototype%',
  },

  '%DataViewPrototype%': {
    buffer: getter,
    byteLength: getter,
    byteOffset: getter,
    constructor: 'DataView',
    getBigInt64: fn,
    getBigUint64: fn,
    // https://github.com/tc39/proposal-float16array
    getFloat16: fn,
    getFloat32: fn,
    getFloat64: fn,
    getInt8: fn,
    getInt16: fn,
    getInt32: fn,
    getUint8: fn,
    getUint16: fn,
    getUint32: fn,
    setBigInt64: fn,
    setBigUint64: fn,
    // https://github.com/tc39/proposal-float16array
    setFloat16: fn,
    setFloat32: fn,
    setFloat64: fn,
    setInt8: fn,
    setInt16: fn,
    setInt32: fn,
    setUint8: fn,
    setUint16: fn,
    setUint32: fn,
    '@@toStringTag': 'string',
  },

  // Atomics
  Atomics: false, // UNSAFE and suppressed.

  JSON: {
    parse: fn,
    stringify: fn,
    '@@toStringTag': 'string',
    // https://github.com/tc39/proposal-json-parse-with-source/
    rawJSON: fn,
    isRawJSON: fn,
  },

  // *** Control Abstraction Objects

  // https://github.com/tc39/proposal-iterator-helpers
  Iterator: {
    // Properties of the Iterator Constructor
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%IteratorPrototype%',
    from: fn,
    // https://github.com/tc39/proposal-joint-iteration
    zip: fn,
    zipKeyed: fn,
    // https://github.com/tc39/proposal-iterator-sequencing
    concat: fn,
  },

  '%IteratorPrototype%': {
    // The %IteratorPrototype% Object
    '@@iterator': fn,
    // https://github.com/tc39/proposal-iterator-helpers
    constructor: 'Iterator',
    map: fn,
    filter: fn,
    take: fn,
    drop: fn,
    flatMap: fn,
    reduce: fn,
    toArray: fn,
    forEach: fn,
    some: fn,
    every: fn,
    find: fn,
    '@@toStringTag': 'string',
    // https://github.com/tc39/proposal-async-iterator-helpers
    toAsync: fn,
    // https://github.com/tc39/proposal-explicit-resource-management
    // See https://github.com/Moddable-OpenSource/moddable/issues/523#issuecomment-1942904505
    '@@dispose': false,
  },

  // https://github.com/tc39/proposal-iterator-helpers
  '%WrapForValidIteratorPrototype%': {
    '[[Proto]]': '%IteratorPrototype%',
    next: fn,
    return: fn,
  },

  // https://github.com/tc39/proposal-iterator-helpers
  '%IteratorHelperPrototype%': {
    '[[Proto]]': '%IteratorPrototype%',
    next: fn,
    return: fn,
    '@@toStringTag': 'string',
  },

  // https://github.com/tc39/proposal-async-iterator-helpers
  AsyncIterator: {
    // Properties of the Iterator Constructor
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%AsyncIteratorPrototype%',
    from: fn,
  },

  '%AsyncIteratorPrototype%': {
    // The %AsyncIteratorPrototype% Object
    '@@asyncIterator': fn,
    // https://github.com/tc39/proposal-async-iterator-helpers
    constructor: 'AsyncIterator',
    map: fn,
    filter: fn,
    take: fn,
    drop: fn,
    flatMap: fn,
    reduce: fn,
    toArray: fn,
    forEach: fn,
    some: fn,
    every: fn,
    find: fn,
    '@@toStringTag': 'string',
    // https://github.com/tc39/proposal-explicit-resource-management
    // See https://github.com/Moddable-OpenSource/moddable/issues/523#issuecomment-1942904505
    '@@asyncDispose': false,
  },

  // https://github.com/tc39/proposal-async-iterator-helpers
  '%WrapForValidAsyncIteratorPrototype%': {
    '[[Proto]]': '%AsyncIteratorPrototype%',
    next: fn,
    return: fn,
  },

  // https://github.com/tc39/proposal-async-iterator-helpers
  '%AsyncIteratorHelperPrototype%': {
    '[[Proto]]': '%AsyncIteratorPrototype%',
    next: fn,
    return: fn,
    '@@toStringTag': 'string',
  },

  '%InertGeneratorFunction%': {
    // Properties of the GeneratorFunction Constructor
    '[[Proto]]': '%InertFunction%',
    prototype: '%Generator%',
  },

  '%Generator%': {
    // Properties of the GeneratorFunction Prototype Object
    '[[Proto]]': '%FunctionPrototype%',
    constructor: '%InertGeneratorFunction%',
    prototype: '%GeneratorPrototype%',
    '@@toStringTag': 'string',
  },

  '%InertAsyncGeneratorFunction%': {
    // Properties of the AsyncGeneratorFunction Constructor
    '[[Proto]]': '%InertFunction%',
    prototype: '%AsyncGenerator%',
  },

  '%AsyncGenerator%': {
    // Properties of the AsyncGeneratorFunction Prototype Object
    '[[Proto]]': '%FunctionPrototype%',
    constructor: '%InertAsyncGeneratorFunction%',
    prototype: '%AsyncGeneratorPrototype%',
    // length prop added here for React Native jsc-android
    // https://github.com/endojs/endo/issues/660
    // https://github.com/react-native-community/jsc-android-buildscripts/issues/181
    length: 'number',
    '@@toStringTag': 'string',
  },

  '%GeneratorPrototype%': {
    // Properties of the Generator Prototype Object
    '[[Proto]]': '%IteratorPrototype%',
    constructor: '%Generator%',
    next: fn,
    return: fn,
    throw: fn,
    '@@toStringTag': 'string',
  },

  '%AsyncGeneratorPrototype%': {
    // Properties of the AsyncGenerator Prototype Object
    '[[Proto]]': '%AsyncIteratorPrototype%',
    constructor: '%AsyncGenerator%',
    next: fn,
    return: fn,
    throw: fn,
    '@@toStringTag': 'string',
  },

  // TODO: To be replaced with Promise.delegate
  //
  // The HandledPromise global variable shimmed by `@agoric/eventual-send/shim`
  // implements an initial version of the eventual send specification at:
  // https://github.com/tc39/proposal-eventual-send
  //
  // We will likely change this to add a property to Promise called
  // Promise.delegate and put static methods on it, which will necessitate
  // another permits change to update to the current proposed standard.
  HandledPromise: {
    '[[Proto]]': 'Promise',
    applyFunction: fn,
    applyFunctionSendOnly: fn,
    applyMethod: fn,
    applyMethodSendOnly: fn,
    get: fn,
    getSendOnly: fn,
    prototype: '%PromisePrototype%',
    resolve: fn,
  },

  // https://github.com/tc39/proposal-source-phase-imports?tab=readme-ov-file#js-module-source

  ModuleSource: {
    '[[Proto]]': '%AbstractModuleSource%',
    prototype: '%ModuleSourcePrototype%',
  },

  '%ModuleSourcePrototype%': {
    '[[Proto]]': '%AbstractModuleSourcePrototype%',
    constructor: 'ModuleSource',
    '@@toStringTag': 'string',
    // https://github.com/tc39/proposal-compartments
    bindings: getter,
    needsImport: getter,
    needsImportMeta: getter,
    // @endo/module-source provides a legacy interface
    imports: getter,
    exports: getter,
    reexports: getter,
  },

  '%AbstractModuleSource%': {
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%AbstractModuleSourcePrototype%',
  },

  '%AbstractModuleSourcePrototype%': {
    constructor: '%AbstractModuleSource%',
  },

  Promise: {
    // Properties of the Promise Constructor
    '[[Proto]]': '%FunctionPrototype%',
    all: fn,
    allSettled: fn,
    // https://github.com/Agoric/SES-shim/issues/550
    any: fn,
    prototype: '%PromisePrototype%',
    race: fn,
    reject: fn,
    resolve: fn,
    // https://github.com/tc39/proposal-promise-with-resolvers
    withResolvers: fn,
    '@@species': getter,
    // https://github.com/tc39/proposal-promise-try
    try: fn,
  },

  '%PromisePrototype%': {
    // Properties of the Promise Prototype Object
    catch: fn,
    constructor: 'Promise',
    finally: fn,
    then: fn,
    '@@toStringTag': 'string',
    // Non-standard, used in node to prevent async_hooks from breaking
    'UniqueSymbol(async_id_symbol)': accessor,
    'UniqueSymbol(trigger_async_id_symbol)': accessor,
    'UniqueSymbol(destroyed)': accessor,
  },

  '%InertAsyncFunction%': {
    // Properties of the AsyncFunction Constructor
    '[[Proto]]': '%InertFunction%',
    prototype: '%AsyncFunctionPrototype%',
  },

  '%AsyncFunctionPrototype%': {
    // Properties of the AsyncFunction Prototype Object
    '[[Proto]]': '%FunctionPrototype%',
    constructor: '%InertAsyncFunction%',
    // length prop added here for React Native jsc-android
    // https://github.com/endojs/endo/issues/660
    // https://github.com/react-native-community/jsc-android-buildscripts/issues/181
    length: 'number',
    '@@toStringTag': 'string',
  },

  // Reflection

  Reflect: {
    // The Reflect Object
    // Not a function object.
    apply: fn,
    construct: fn,
    defineProperty: fn,
    deleteProperty: fn,
    get: fn,
    getOwnPropertyDescriptor: fn,
    getPrototypeOf: fn,
    has: fn,
    isExtensible: fn,
    ownKeys: fn,
    preventExtensions: fn,
    set: fn,
    setPrototypeOf: fn,
    '@@toStringTag': 'string',
  },

  Proxy: {
    // Properties of the Proxy Constructor
    '[[Proto]]': '%FunctionPrototype%',
    revocable: fn,
  },

  // Appendix B

  // Annex B: Additional Properties of the Global Object

  escape: fn,
  unescape: fn,

  // Proposed

  '%UniqueCompartment%': {
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%CompartmentPrototype%',
    toString: fn,
  },

  '%InertCompartment%': {
    '[[Proto]]': '%FunctionPrototype%',
    prototype: '%CompartmentPrototype%',
    toString: fn,
  },

  '%CompartmentPrototype%': {
    constructor: '%InertCompartment%',
    evaluate: fn,
    globalThis: getter,
    name: getter,
    import: asyncFn,
    load: asyncFn,
    importNow: fn,
    module: fn,
    '@@toStringTag': 'string',
  },

  lockdown: fn,
  harden: { ...fn, isFake: 'boolean' },

  '%InitialGetStackString%': fn,
};$h͏_once.permitted(permitted);
})()
,
// === 17. ses ./src/intrinsics.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let cauterizeProperty,TypeError,WeakSet,arrayFilter,create,defineProperty,entries,freeze,getOwnPropertyDescriptor,getOwnPropertyDescriptors,globalThis,is,isPrimitive,hasOwn,values,weaksetHas,constantProperties,sharedGlobalPropertyNames,universalPropertyNames,permitted;$h͏_imports([["./cauterize-property.js", [["cauterizeProperty",[$h͏_a => (cauterizeProperty = $h͏_a)]]]],["./commons.js", [["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["WeakSet",[$h͏_a => (WeakSet = $h͏_a)]],["arrayFilter",[$h͏_a => (arrayFilter = $h͏_a)]],["create",[$h͏_a => (create = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["entries",[$h͏_a => (entries = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["getOwnPropertyDescriptor",[$h͏_a => (getOwnPropertyDescriptor = $h͏_a)]],["getOwnPropertyDescriptors",[$h͏_a => (getOwnPropertyDescriptors = $h͏_a)]],["globalThis",[$h͏_a => (globalThis = $h͏_a)]],["is",[$h͏_a => (is = $h͏_a)]],["isPrimitive",[$h͏_a => (isPrimitive = $h͏_a)]],["hasOwn",[$h͏_a => (hasOwn = $h͏_a)]],["values",[$h͏_a => (values = $h͏_a)]],["weaksetHas",[$h͏_a => (weaksetHas = $h͏_a)]]]],["./permits.js", [["constantProperties",[$h͏_a => (constantProperties = $h͏_a)]],["sharedGlobalPropertyNames",[$h͏_a => (sharedGlobalPropertyNames = $h͏_a)]],["universalPropertyNames",[$h͏_a => (universalPropertyNames = $h͏_a)]],["permitted",[$h͏_a => (permitted = $h͏_a)]]]]]);

























/**
 * @import {Reporter} from './reporting-types.js'
 */

const isFunction = obj => typeof obj === 'function';

// Like defineProperty, but throws if it would modify an existing property.
// We use this to ensure that two conflicting attempts to define the same
// property throws, causing SES initialization to fail. Otherwise, a
// conflict between, for example, two of SES's internal permits might
// get masked as one overwrites the other. Accordingly, the thrown error
// complains of a "Conflicting definition".
function initProperty(obj, name, desc) {
  if (hasOwn(obj, name)) {
    const preDesc = getOwnPropertyDescriptor(obj, name);
    if (
      !preDesc ||
      !is(preDesc.value, desc.value) ||
      preDesc.get !== desc.get ||
      preDesc.set !== desc.set ||
      preDesc.writable !== desc.writable ||
      preDesc.enumerable !== desc.enumerable ||
      preDesc.configurable !== desc.configurable
    ) {
      throw TypeError(`Conflicting definitions of ${name}`);
    }
  }
  defineProperty(obj, name, desc);
}

// Like defineProperties, but throws if it would modify an existing property.
// This ensures that the intrinsics added to the intrinsics collector object
// graph do not overlap.
function initProperties(obj, descs) {
  for (const [name, desc] of entries(descs)) {
    initProperty(obj, name, desc);
  }
}

// sampleGlobals creates an intrinsics object, suitable for
// interinsicsCollector.addIntrinsics, from the named properties of a global
// object.
function sampleGlobals(globalObject, newPropertyNames) {
  const newIntrinsics = { __proto__: null };
  for (const [globalName, intrinsicName] of entries(newPropertyNames)) {
    if (hasOwn(globalObject, globalName)) {
      newIntrinsics[intrinsicName] = globalObject[globalName];
    }
  }
  return newIntrinsics;
}

/**
 * @param {Reporter} reporter
 */
       const makeIntrinsicsCollector = reporter => {
  /** @type {Record<any, any>} */
  const intrinsics = create(null);
  let pseudoNatives;

  const addIntrinsics = newIntrinsics => {
    initProperties(intrinsics, getOwnPropertyDescriptors(newIntrinsics));
  };
  freeze(addIntrinsics);

  // For each intrinsic, if it has a `.prototype` property, use the
  // permits to find out the intrinsic name for that prototype and add it
  // to the intrinsics.
  const completePrototypes = () => {
    for (const [name, intrinsic] of entries(intrinsics)) {
      if (isPrimitive(intrinsic)) {
        // eslint-disable-next-line no-continue
        continue;
      }
      if (!hasOwn(intrinsic, 'prototype')) {
        // eslint-disable-next-line no-continue
        continue;
      }
      const permit = permitted[name];
      if (typeof permit !== 'object') {
        throw TypeError(`Expected permit object at permits.${name}`);
      }
      const namePrototype = permit.prototype;
      if (!namePrototype) {
        cauterizeProperty(
          intrinsic,
          'prototype',
          false,
          `${name}.prototype`,
          reporter,
        );
        // eslint-disable-next-line no-continue
        continue;
      }
      if (
        typeof namePrototype !== 'string' ||
        !hasOwn(permitted, namePrototype)
      ) {
        throw TypeError(`Unrecognized ${name}.prototype permits entry`);
      }
      const intrinsicPrototype = intrinsic.prototype;
      if (hasOwn(intrinsics, namePrototype)) {
        if (intrinsics[namePrototype] !== intrinsicPrototype) {
          throw TypeError(`Conflicting bindings of ${namePrototype}`);
        }
        // eslint-disable-next-line no-continue
        continue;
      }
      intrinsics[namePrototype] = intrinsicPrototype;
    }
  };
  freeze(completePrototypes);

  const finalIntrinsics = () => {
    freeze(intrinsics);
    pseudoNatives = new WeakSet(arrayFilter(values(intrinsics), isFunction));
    return intrinsics;
  };
  freeze(finalIntrinsics);

  const isPseudoNative = obj => {
    if (!pseudoNatives) {
      throw TypeError(
        'isPseudoNative can only be called after finalIntrinsics',
      );
    }
    return weaksetHas(pseudoNatives, obj);
  };
  freeze(isPseudoNative);

  const intrinsicsCollector = {
    addIntrinsics,
    completePrototypes,
    finalIntrinsics,
    isPseudoNative,
  };
  freeze(intrinsicsCollector);

  addIntrinsics(constantProperties);
  addIntrinsics(sampleGlobals(globalThis, universalPropertyNames));

  return intrinsicsCollector;
};

/**
 * getGlobalIntrinsics()
 * Doesn't tame, delete, or modify anything. Samples globalObject to create an
 * intrinsics record containing only the permitted global variables, listed
 * by the intrinsic names appropriate for new globals, i.e., the globals of
 * newly constructed compartments.
 *
 * WARNING:
 * If run before lockdown, the returned intrinsics record will carry the
 * *original* unsafe (feral, untamed) bindings of these global variables.
 *
 * @param {object} globalObject
 * @param {Reporter} reporter
 */$h͏_once.makeIntrinsicsCollector(makeIntrinsicsCollector);
       const getGlobalIntrinsics = (globalObject, reporter) => {
  // TODO pass a proper reporter to `makeIntrinsicsCollector`
  const { addIntrinsics, finalIntrinsics } = makeIntrinsicsCollector(reporter);

  addIntrinsics(sampleGlobals(globalObject, sharedGlobalPropertyNames));

  return finalIntrinsics();
};$h͏_once.getGlobalIntrinsics(getGlobalIntrinsics);
})()
,
// === 18. ses ./src/permits-intrinsics.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let permitted,FunctionInstance,isAccessorPermit,Map,String,Symbol,TypeError,arrayFilter,arrayIncludes,arrayMap,entries,getOwnPropertyDescriptor,getPrototypeOf,isPrimitive,mapGet,hasOwn,ownKeys,symbolKeyFor,cauterizeProperty;$h͏_imports([["./permits.js", [["permitted",[$h͏_a => (permitted = $h͏_a)]],["FunctionInstance",[$h͏_a => (FunctionInstance = $h͏_a)]],["isAccessorPermit",[$h͏_a => (isAccessorPermit = $h͏_a)]]]],["./commons.js", [["Map",[$h͏_a => (Map = $h͏_a)]],["String",[$h͏_a => (String = $h͏_a)]],["Symbol",[$h͏_a => (Symbol = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["arrayFilter",[$h͏_a => (arrayFilter = $h͏_a)]],["arrayIncludes",[$h͏_a => (arrayIncludes = $h͏_a)]],["arrayMap",[$h͏_a => (arrayMap = $h͏_a)]],["entries",[$h͏_a => (entries = $h͏_a)]],["getOwnPropertyDescriptor",[$h͏_a => (getOwnPropertyDescriptor = $h͏_a)]],["getPrototypeOf",[$h͏_a => (getPrototypeOf = $h͏_a)]],["isPrimitive",[$h͏_a => (isPrimitive = $h͏_a)]],["mapGet",[$h͏_a => (mapGet = $h͏_a)]],["hasOwn",[$h͏_a => (hasOwn = $h͏_a)]],["ownKeys",[$h͏_a => (ownKeys = $h͏_a)]],["symbolKeyFor",[$h͏_a => (symbolKeyFor = $h͏_a)]]]],["./cauterize-property.js", [["cauterizeProperty",[$h͏_a => (cauterizeProperty = $h͏_a)]]]]]);
































































/**
 * @import {Reporter} from './reporting-types.js'
 */

/**
 * Removes all non-allowed properties found by recursively and
 * reflectively walking own property chains.
 *
 * @param {object} intrinsics
 * @param {(virtualizedNativeFunction: object) => void} markVirtualizedNativeFunction
 * @param {Reporter} reporter
 */
               function removeUnpermittedIntrinsics(
  intrinsics,
  markVirtualizedNativeFunction,
  reporter,
) {
  // These primitives are allowed for permits.
  const primitives = ['undefined', 'boolean', 'number', 'string', 'symbol'];

  // These symbols are allowed as well-known symbols
  const wellKnownSymbolNames = new Map(
    Symbol
      ? arrayMap(
          arrayFilter(
            entries(permitted['%SharedSymbol%']),
            ([name, permit]) =>
              permit === 'symbol' && typeof Symbol[name] === 'symbol',
          ),
          ([name]) => [Symbol[name], `@@${name}`],
        )
      : [],
  );

  /**
   * asStringPropertyName()
   *
   * @param {string} path
   * @param {string | symbol} prop
   */
  function asStringPropertyName(path, prop) {
    if (typeof prop === 'string') {
      return prop;
    }

    const wellKnownSymbol = mapGet(wellKnownSymbolNames, prop);

    if (typeof prop === 'symbol') {
      if (wellKnownSymbol) {
        return wellKnownSymbol;
      } else {
        const registeredKey = symbolKeyFor(prop);
        if (registeredKey !== undefined) {
          return `RegisteredSymbol(${registeredKey})`;
        } else {
          return `Unique${String(prop)}`;
        }
      }
    }

    throw TypeError(`Unexpected property name type ${path} ${prop}`);
  }

  /*
   * visitPrototype()
   * Validate the object's [[prototype]] against a permit.
   */
  function visitPrototype(path, obj, protoName) {
    if (isPrimitive(obj)) {
      throw TypeError(`Object expected: ${path}, ${String(obj)}, ${protoName}`);
    }
    const proto = getPrototypeOf(obj);

    // Null prototype.
    if (proto === null && protoName === null) {
      return;
    }

    // Assert: protoName, if provided, is a string.
    if (protoName !== undefined && typeof protoName !== 'string') {
      throw TypeError(`Malformed permit ${path}.__proto__`);
    }

    // If permit not specified, default to Object.prototype.
    if (proto === intrinsics[protoName || '%ObjectPrototype%']) {
      return;
    }

    // We can't clean [[Prototype]], therefore abort.
    throw TypeError(
      `Unexpected [[Prototype]] at ${path}.__proto__ (expected ${protoName || '%ObjectPrototype%'})`,
    );
  }

  /*
   * isAllowedPropertyValue()
   * enforce permit for a single property value.
   */
  function isAllowedPropertyValue(path, value, prop, permit) {
    if (typeof permit === 'object') {
      // eslint-disable-next-line no-use-before-define
      visitProperties(path, value, permit);
      // The property is allowed.
      return true;
    }

    if (permit === false) {
      // A boolan 'false' permit specifies the removal of a property.
      // We require a more specific permit instead of allowing 'true'.
      return false;
    }

    if (typeof permit === 'string') {
      // A string permit can have one of two meanings:

      if (prop === 'prototype' || prop === 'constructor') {
        // For prototype and constructor value properties, the permit
        // is the name of an intrinsic.
        // Assumption: prototype and constructor cannot be primitives.
        // Assert: the permit is the name of an intrinsic.
        // Assert: the property value is equal to that intrinsic.

        if (hasOwn(intrinsics, permit)) {
          if (value !== intrinsics[permit]) {
            throw TypeError(`Does not match permit for ${path}`);
          }
          return true;
        }
      } else {
        // For all other properties, the permit is the name of a primitive.
        // Assert: the permit is the name of a primitive.
        // Assert: the property value type is equal to that primitive.

        // eslint-disable-next-line no-lonely-if
        if (arrayIncludes(primitives, permit)) {
          // eslint-disable-next-line valid-typeof
          if (typeof value !== permit) {
            throw TypeError(
              `At ${path} expected ${permit} not ${typeof value}`,
            );
          }
          return true;
        }
      }
    }

    throw TypeError(
      `Unexpected property ${prop} with permit ${permit} at ${path}`,
    );
  }

  /*
   * isAllowedProperty()
   * Check whether a single property is allowed.
   */
  function isAllowedProperty(path, obj, prop, permit) {
    const desc = getOwnPropertyDescriptor(obj, prop);
    if (!desc) {
      throw TypeError(`Property ${prop} not found at ${path}`);
    }

    // Is this a value property?
    if (hasOwn(desc, 'value')) {
      if (isAccessorPermit(permit)) {
        throw TypeError(`Accessor expected at ${path}`);
      }
      return isAllowedPropertyValue(path, desc.value, prop, permit);
    }
    if (!isAccessorPermit(permit)) {
      throw TypeError(`Accessor not expected at ${path}`);
    }
    return (
      isAllowedPropertyValue(`${path}<get>`, desc.get, prop, permit.get) &&
      isAllowedPropertyValue(`${path}<set>`, desc.set, prop, permit.set)
    );
  }

  /*
   * getSubPermit()
   */
  function getSubPermit(obj, permit, prop) {
    const permitProp = prop === '__proto__' ? '--proto--' : prop;
    if (hasOwn(permit, permitProp)) {
      return permit[permitProp];
    }

    if (typeof obj === 'function') {
      if (hasOwn(FunctionInstance, permitProp)) {
        return FunctionInstance[permitProp];
      }
    }

    return undefined;
  }

  /*
   * visitProperties()
   * Visit all properties for a permit.
   */
  function visitProperties(path, obj, permit) {
    if (obj === undefined || obj === null) {
      return;
    }

    const protoName = permit['[[Proto]]'];
    visitPrototype(path, obj, protoName);

    if (typeof obj === 'function') {
      markVirtualizedNativeFunction(obj);
    }

    for (const prop of ownKeys(obj)) {
      const propString = asStringPropertyName(path, prop);
      const subPath = `${path}.${propString}`;
      const subPermit = getSubPermit(obj, permit, propString);

      if (!subPermit || !isAllowedProperty(subPath, obj, prop, subPermit)) {
        cauterizeProperty(obj, prop, subPermit === false, subPath, reporter);
      }
    }
  }

  // Start path with 'intrinsics' to clarify that properties are not
  // removed from the global object by the permitting operation.
  visitProperties('intrinsics', intrinsics, permitted);
}$h͏_once.default(      removeUnpermittedIntrinsics);
})()
,
// === 19. ses ./src/tame-function-constructors.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let FERAL_FUNCTION,SyntaxError,TypeError,defineProperties,getPrototypeOf,setPrototypeOf,freeze,AsyncGeneratorFunctionInstance;$h͏_imports([["./commons.js", [["FERAL_FUNCTION",[$h͏_a => (FERAL_FUNCTION = $h͏_a)]],["SyntaxError",[$h͏_a => (SyntaxError = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["defineProperties",[$h͏_a => (defineProperties = $h͏_a)]],["getPrototypeOf",[$h͏_a => (getPrototypeOf = $h͏_a)]],["setPrototypeOf",[$h͏_a => (setPrototypeOf = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["AsyncGeneratorFunctionInstance",[$h͏_a => (AsyncGeneratorFunctionInstance = $h͏_a)]]]]]);










// This module replaces the original `Function` constructor, and the original
// `%GeneratorFunction%`, `%AsyncFunction%` and `%AsyncGeneratorFunction%`,
// with safe replacements that throw if invoked.
//
// These are all reachable via syntax, so it isn't sufficient to just
// replace global properties with safe versions. Our main goal is to prevent
// access to the `Function` constructor through these starting points.
//
// After modules block is done, the originals must no longer be reachable,
// unless a copy has been made, and functions can only be created by syntax
// (using eval) or by invoking a previously saved reference to the originals.
//
// Typically, this module will not be used directly, but via the
// [lockdown - shim] which handles all necessary repairs and taming in SES.
//
// Relation to ECMA specifications
//
// The taming of constructors really wants to be part of the standard, because
// new constructors may be added in the future, reachable from syntax, and this
// list must be updated to match.
//
// In addition, the standard needs to define four new intrinsics for the safe
// replacement functions. See [./permits-intrinsics.js].
//
// Adapted from SES/Caja
// Copyright (C) 2011 Google Inc.
// https://github.com/google/caja/blob/master/src/com/google/caja/ses/startSES.js
// https://github.com/google/caja/blob/master/src/com/google/caja/ses/repairES5.js

/**
 * tameFunctionConstructors()
 * This block replaces the original Function constructor, and the original
 * %GeneratorFunction% %AsyncFunction% and %AsyncGeneratorFunction%, with
 * safe replacements that throw if invoked.
 */
               function tameFunctionConstructors() {
  try {
    // Verify that the method is not callable.
    // eslint-disable-next-line @endo/no-polymorphic-call
    FERAL_FUNCTION.prototype.constructor('return 1');
  } catch (ignore) {
    // Throws, no need to patch.
    return freeze({});
  }

  const newIntrinsics = {};

  /*
   * The process to repair constructors:
   * 1. Create an instance of the function by evaluating syntax
   * 2. Obtain the prototype from the instance
   * 3. Create a substitute tamed constructor
   * 4. Replace the original constructor with the tamed constructor
   * 5. Replace tamed constructor prototype property with the original one
   * 6. Replace its [[Prototype]] slot with the tamed constructor of Function
   */
  function repairFunction(name, intrinsicName, declaration) {
    let FunctionInstance;
    try {
      // eslint-disable-next-line no-eval, no-restricted-globals
      FunctionInstance = (0, eval)(declaration);
    } catch (e) {
      if (e instanceof SyntaxError) {
        // Prevent failure on platforms where async and/or generators
        // are not supported.
        return;
      }
      // Re-throw
      throw e;
    }
    const FunctionPrototype = getPrototypeOf(FunctionInstance);

    // Prevents the evaluation of source when calling constructor on the
    // prototype of functions.
    // eslint-disable-next-line func-names
    const InertConstructor = function () {
      throw TypeError(
        'Function.prototype.constructor is not a valid constructor.',
      );
    };
    defineProperties(InertConstructor, {
      prototype: { value: FunctionPrototype },
      name: {
        value: name,
        writable: false,
        enumerable: false,
        configurable: true,
      },
    });

    defineProperties(FunctionPrototype, {
      constructor: { value: InertConstructor },
    });

    // Reconstructs the inheritance among the new tamed constructors
    // to mirror the original specified in normal JS.
    if (InertConstructor !== FERAL_FUNCTION.prototype.constructor) {
      setPrototypeOf(InertConstructor, FERAL_FUNCTION.prototype.constructor);
    }

    newIntrinsics[intrinsicName] = InertConstructor;
  }

  // Here, the order of operation is important: Function needs to be repaired
  // first since the other repaired constructors need to inherit from the
  // tamed Function function constructor.

  repairFunction('Function', '%InertFunction%', '(function(){})');
  repairFunction(
    'GeneratorFunction',
    '%InertGeneratorFunction%',
    '(function*(){})',
  );
  repairFunction(
    'AsyncFunction',
    '%InertAsyncFunction%',
    '(async function(){})',
  );

  if (AsyncGeneratorFunctionInstance !== undefined) {
    repairFunction(
      'AsyncGeneratorFunction',
      '%InertAsyncGeneratorFunction%',
      '(async function*(){})',
    );
  }

  return newIntrinsics;
}$h͏_once.default(      tameFunctionConstructors);
})()
,
// === 20. ses ./src/tame-date-constructor.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let Date,TypeError,apply,construct,defineProperties;$h͏_imports([["./commons.js", [["Date",[$h͏_a => (Date = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["apply",[$h͏_a => (apply = $h͏_a)]],["construct",[$h͏_a => (construct = $h͏_a)]],["defineProperties",[$h͏_a => (defineProperties = $h͏_a)]]]]]);









               function tameDateConstructor() {
  const OriginalDate = Date;
  const DatePrototype = OriginalDate.prototype;

  // Use concise methods to obtain named functions without constructors.
  const tamedMethods = {
    /**
     * `%SharedDate%.now()` throw a `TypeError` starting with "secure mode".
     * See https://github.com/endojs/endo/issues/910#issuecomment-1581855420
     */
    now() {
      throw TypeError('secure mode Calling %SharedDate%.now() throws');
    },
  };

  /**
   * Tame the Date constructor.
   * See https://github.com/endojs/endo/issues/910#issuecomment-1581855420
   *
   * Common behavior
   *   * `new Date(x)` coerces x into a number and then returns a Date
   *     for that number of millis since the epoch
   *   * `new Date(NaN)` returns a Date object which stringifies to
   *     'Invalid Date'
   *   * `new Date(undefined)` returns a Date object which stringifies to
   *     'Invalid Date'
   *
   * OriginalDate (normal standard) behavior preserved by
   * `%InitialDate%`.
   *   * `Date(anything)` gives a string with the current time
   *   * `new Date()` returns the current time, as a Date object
   *
   * `%SharedDate%` behavior
   *   * `Date(anything)` throws a TypeError starting with "secure mode"
   *   * `new Date()` throws a TypeError starting with "secure mode"
   *
   * @param {{powers?: string}} [opts]
   */
  const makeDateConstructor = ({ powers = 'none' } = {}) => {
    let ResultDate;
    if (powers === 'original') {
      // eslint-disable-next-line no-shadow
      ResultDate = function Date(...rest) {
        if (new.target === undefined) {
          return apply(OriginalDate, undefined, rest);
        }
        return construct(OriginalDate, rest, new.target);
      };
    } else {
      // eslint-disable-next-line no-shadow
      ResultDate = function Date(...rest) {
        if (new.target === undefined) {
          throw TypeError(
            'secure mode Calling %SharedDate% constructor as a function throws',
          );
        }
        if (rest.length === 0) {
          throw TypeError(
            'secure mode Calling new %SharedDate%() with no arguments throws',
          );
        }
        return construct(OriginalDate, rest, new.target);
      };
    }

    defineProperties(ResultDate, {
      length: { value: 7 },
      prototype: {
        value: DatePrototype,
        writable: false,
        enumerable: false,
        configurable: false,
      },
      parse: {
        value: OriginalDate.parse,
        writable: true,
        enumerable: false,
        configurable: true,
      },
      UTC: {
        value: OriginalDate.UTC,
        writable: true,
        enumerable: false,
        configurable: true,
      },
    });
    return ResultDate;
  };
  const InitialDate = makeDateConstructor({ powers: 'original' });
  const SharedDate = makeDateConstructor({ powers: 'none' });

  defineProperties(InitialDate, {
    now: {
      value: OriginalDate.now,
      writable: true,
      enumerable: false,
      configurable: true,
    },
  });
  defineProperties(SharedDate, {
    now: {
      value: tamedMethods.now,
      writable: true,
      enumerable: false,
      configurable: true,
    },
  });

  defineProperties(DatePrototype, {
    constructor: { value: SharedDate },
  });

  return {
    '%InitialDate%': InitialDate,
    '%SharedDate%': SharedDate,
  };
}$h͏_once.default(      tameDateConstructor);
})()
,
// === 21. ses ./src/tame-math-object.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let Math,TypeError,create,getOwnPropertyDescriptors,objectPrototype;$h͏_imports([["./commons.js", [["Math",[$h͏_a => (Math = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["create",[$h͏_a => (create = $h͏_a)]],["getOwnPropertyDescriptors",[$h͏_a => (getOwnPropertyDescriptors = $h͏_a)]],["objectPrototype",[$h͏_a => (objectPrototype = $h͏_a)]]]]]);







               function tameMathObject() {
  const originalMath = Math;
  const initialMath = originalMath; // to follow the naming pattern

  const { random: _, ...otherDescriptors } =
    getOwnPropertyDescriptors(originalMath);

  // Use concise methods to obtain named functions without constructors.
  const tamedMethods = {
    /**
     * `%SharedMath%.random()` throws a TypeError starting with "secure mode".
     * See https://github.com/endojs/endo/issues/910#issuecomment-1581855420
     */
    random() {
      throw TypeError('secure mode %SharedMath%.random() throws');
    },
  };

  const sharedMath = create(objectPrototype, {
    ...otherDescriptors,
    random: {
      value: tamedMethods.random,
      writable: true,
      enumerable: false,
      configurable: true,
    },
  });

  return {
    '%InitialMath%': initialMath,
    '%SharedMath%': sharedMath,
  };
}$h͏_once.default(      tameMathObject);
})()
,
// === 22. ses ./src/tame-regexp-constructor.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let FERAL_REG_EXP,TypeError,construct,defineProperties,getOwnPropertyDescriptor,speciesSymbol;$h͏_imports([["./commons.js", [["FERAL_REG_EXP",[$h͏_a => (FERAL_REG_EXP = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["construct",[$h͏_a => (construct = $h͏_a)]],["defineProperties",[$h͏_a => (defineProperties = $h͏_a)]],["getOwnPropertyDescriptor",[$h͏_a => (getOwnPropertyDescriptor = $h͏_a)]],["speciesSymbol",[$h͏_a => (speciesSymbol = $h͏_a)]]]]]);








               function tameRegExpConstructor(regExpTaming = 'safe') {
  const RegExpPrototype = FERAL_REG_EXP.prototype;

  const makeRegExpConstructor = (_ = {}) => {
    // RegExp has non-writable static properties we need to omit.
    /**
     * @param  {Parameters<typeof FERAL_REG_EXP>} rest
     */
    const ResultRegExp = function RegExp(...rest) {
      if (new.target === undefined) {
        return FERAL_REG_EXP(...rest);
      }
      return construct(FERAL_REG_EXP, rest, new.target);
    };

    defineProperties(ResultRegExp, {
      length: { value: 2 },
      prototype: {
        value: RegExpPrototype,
        writable: false,
        enumerable: false,
        configurable: false,
      },
    });
    // Hermes does not have `Symbol.species`. We should support such platforms.
    if (speciesSymbol) {
      const speciesDesc = getOwnPropertyDescriptor(
        FERAL_REG_EXP,
        speciesSymbol,
      );
      if (!speciesDesc) {
        throw TypeError('no RegExp[Symbol.species] descriptor');
      }
      defineProperties(ResultRegExp, {
        [speciesSymbol]: speciesDesc,
      });
    }
    return ResultRegExp;
  };

  const InitialRegExp = makeRegExpConstructor();
  const SharedRegExp = makeRegExpConstructor();

  if (regExpTaming !== 'unsafe') {
    // @ts-expect-error Deleted properties must be optional
    delete RegExpPrototype.compile;
  }
  defineProperties(RegExpPrototype, {
    constructor: { value: SharedRegExp },
  });

  return {
    '%InitialRegExp%': InitialRegExp,
    '%SharedRegExp%': SharedRegExp,
  };
}$h͏_once.default(      tameRegExpConstructor);
})()
,
// === 23. ses ./src/enablements.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let toStringTagSymbol,iteratorSymbol;$h͏_imports([["./commons.js", [["toStringTagSymbol",[$h͏_a => (toStringTagSymbol = $h͏_a)]],["iteratorSymbol",[$h͏_a => (iteratorSymbol = $h͏_a)]]]]]);

/**
 * Exports {@code enablements}, a recursively defined
 * JSON record defining the optimum set of intrinsics properties
 * that need to be "repaired" before hardening is applied on
 * enviromments subject to the override mistake.
 *
 * @author JF Paradis
 * @author Mark S. Miller
 *
 * @module
 */

/**
 * <p>Because "repairing" replaces data properties with accessors, every
 * time a repaired property is accessed, the associated getter is invoked,
 * which degrades the runtime performance of all code executing in the
 * repaired enviromment, compared to the non-repaired case. In order
 * to maintain performance, we only repair the properties of objects
 * for which hardening causes a breakage of their normal intended usage.
 *
 * There are three unwanted cases:
 * <ul>
 * <li>Overriding properties on objects typically used as records,
 *     namely {@code "Object"} and {@code "Array"}. In the case of arrays,
 *     the situation is unintentional, a given program might not be aware
 *     that non-numerical properties are stored on the underlying object
 *     instance, not on the array. When an object is typically used as a
 *     map, we repair all of its prototype properties.
 * <li>Overriding properties on objects that provide defaults on their
 *     prototype and that programs typically set using an assignment, such as
 *     {@code "Error.prototype.message"} and {@code "Function.prototype.name"}
 *     (both default to "").
 * <li>Setting-up a prototype chain, where a constructor is set to extend
 *     another one. This is typically set by assignment, for example
 *     {@code "Child.prototype.constructor = Child"}, instead of invoking
 *     Object.defineProperty();
 *
 * <p>Each JSON record enumerates the disposition of the properties on
 * some corresponding intrinsic object.
 *
 * <p>For each such record, the values associated with its property
 * names can be:
 * <ul>
 * <li>true, in which case this property is simply repaired. The
 *     value associated with that property is not traversed. For
 *     example, {@code "Function.prototype.name"} leads to true,
 *     meaning that the {@code "name"} property of {@code
 *     "Function.prototype"} should be repaired (which is needed
 *     when inheriting from @code{Function} and setting the subclass's
 *     {@code "prototype.name"} property). If the property is
 *     already an accessor property, it is not repaired (because
 *     accessors are not subject to the override mistake).
 * <li>"*", in which case this property is not repaired but the
 *     value associated with that property are traversed and repaired.
 * <li>Another record, in which case this property is not repaired
 *     and that next record represents the disposition of the object
 *     which is its value. For example,{@code "FunctionPrototype"}
 *     leads to another record explaining which properties {@code
 *     Function.prototype} need to be repaired.
 */

/**
 * Minimal enablements when all the code is modern and known not to
 * step into the override mistake, except for the following pervasive
 * cases.
 */
       const minEnablements = {
  '%ObjectPrototype%': {
    toString: true,
  },

  '%FunctionPrototype%': {
    toString: true  // set by "rollup"
  },

  '%ErrorPrototype%': {
    name: true  // set by "precond", "ava", "node-fetch"
  },

  '%IteratorPrototype%': {
    toString: true,
    // https://github.com/tc39/proposal-iterator-helpers
    constructor: true,
    // https://github.com/tc39/proposal-iterator-helpers
    [toStringTagSymbol]: true,
  },
};

/**
 * Moderate enablements are usually good enough for legacy compat.
 */$h͏_once.minEnablements(minEnablements);
       const moderateEnablements = {
  ...minEnablements,

  '%ObjectPrototype%': {
    toString: true,
    valueOf: true,
  },

  '%ArrayPrototype%': {
    toString: true,
    push: true, // set by "Google Analytics"
    concat: true, // set by mobx generated code (old TS compiler?)
    [iteratorSymbol]: true  // set by mobx generated code (old TS compiler?)
  },

  '%IteratorPrototype%': {
    [iteratorSymbol]: true  // is sometimes used in custom iterators and generators implementations eg. @rive-app/canvas
  },

  // Function.prototype has no 'prototype' property to enable.
  // Function instances have their own 'name' and 'length' properties
  // which are configurable and non-writable. Thus, they are already
  // non-assignable anyway.
  '%FunctionPrototype%': {
    constructor: true, // set by "regenerator-runtime"
    bind: true, // set by "underscore", "express"
    toString: true  // set by "rollup"
  },

  '%ErrorPrototype%': {
    constructor: true, // set by "fast-json-patch", "node-fetch"
    message: true,
    name: true, // set by "precond", "ava", "node-fetch", "node 14"
    toString: true  // set by "bluebird"
  },

  '%TypeErrorPrototype%': {
    constructor: true, // set by "readable-stream"
    message: true, // set by "tape"
    name: true  // set by "readable-stream", "node 14"
  },

  '%SyntaxErrorPrototype%': {
    message: true, // to match TypeErrorPrototype.message
    name: true  // set by "node 14"
  },

  '%RangeErrorPrototype%': {
    message: true, // to match TypeErrorPrototype.message
    name: true  // set by "node 14"
  },

  '%URIErrorPrototype%': {
    message: true, // to match TypeErrorPrototype.message
    name: true  // set by "node 14"
  },

  '%EvalErrorPrototype%': {
    message: true, // to match TypeErrorPrototype.message
    name: true  // set by "node 14"
  },

  '%ReferenceErrorPrototype%': {
    message: true, // to match TypeErrorPrototype.message
    name: true  // set by "node 14"
  },

  // https://github.com/endojs/endo/issues/550
  '%AggregateErrorPrototype%': {
    message: true, // to match TypeErrorPrototype.message
    name: true  // set by "node 14"?
  },

  '%PromisePrototype%': {
    constructor: true  // set by "core-js"
  },

  '%TypedArrayPrototype%': '*', // set by https://github.com/feross/buffer

  '%Generator%': {
    constructor: true,
    name: true,
    toString: true,
  },
};

/**
 * The 'severe' enablement are needed because of issues tracked at
 * https://github.com/endojs/endo/issues/576
 *
 * They are like the `moderate` enablements except for the entries below.
 */$h͏_once.moderateEnablements(moderateEnablements);
       const severeEnablements = {
  ...moderateEnablements,

  /**
   * Rollup (as used at least by vega) and webpack
   * (as used at least by regenerator) both turn exports into assignments
   * to a big `exports` object that inherits directly from
   * `Object.prototype`. Some of the exported names we've seen include
   * `hasOwnProperty`, `constructor`, and `toString`. But the strategy used
   * by rollup and webpack potentionally turns any exported name
   * into an assignment rejected by the override mistake. That's why
   * the `severe` enablements takes the extreme step of enabling
   * everything on `Object.prototype`.
   *
   * In addition, code doing inheritance manually will often override
   * the `constructor` property on the new prototype by assignment. We've
   * seen this several times.
   *
   * The cost of enabling all these is that they create a miserable debugging
   * experience specifically on Node.
   * https://github.com/Agoric/agoric-sdk/issues/2324
   * explains how it confused the Node console.
   *
   * (TODO Reexamine the vscode situation. I think it may have improved
   * since the following paragraph was written.)
   *
   * The vscode debugger's object inspector shows the own data properties of
   * an object, which is typically what you want, but also shows both getter
   * and setter for every accessor property whether inherited or own.
   * With the `'*'` setting here, all the properties inherited from
   * `Object.prototype` are accessors, creating an unusable display as seen
   * at As explained at
   * https://github.com/endojs/endo/blob/master/packages/ses/docs/lockdown.md#overridetaming-options
   * Open the triangles at the bottom of that section.
   */
  '%ObjectPrototype%': '*',

  /**
   * The widely used Buffer defined at https://github.com/feross/buffer
   * on initialization, manually creates the equivalent of a subclass of
   * `TypedArray`, which it then initializes by assignment. These assignments
   * include enough of the `TypeArray` methods that here, the `severe`
   * enablements just enable them all.
   */
  '%TypedArrayPrototype%': '*',

  /**
   * Needed to work with Immer before https://github.com/immerjs/immer/pull/914
   * is accepted.
   */
  '%MapPrototype%': '*',

  /**
   * Needed to work with Immer before https://github.com/immerjs/immer/pull/914
   * is accepted.
   */
  '%SetPrototype%': '*',
};$h͏_once.severeEnablements(severeEnablements);
})()
,
// === 24. ses ./src/enable-property-overrides.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let Set,String,TypeError,arrayForEach,defineProperty,getOwnPropertyDescriptor,getOwnPropertyDescriptors,isPrimitive,hasOwn,ownKeys,setHas,minEnablements,moderateEnablements,severeEnablements;$h͏_imports([["./commons.js", [["Set",[$h͏_a => (Set = $h͏_a)]],["String",[$h͏_a => (String = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["arrayForEach",[$h͏_a => (arrayForEach = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["getOwnPropertyDescriptor",[$h͏_a => (getOwnPropertyDescriptor = $h͏_a)]],["getOwnPropertyDescriptors",[$h͏_a => (getOwnPropertyDescriptors = $h͏_a)]],["isPrimitive",[$h͏_a => (isPrimitive = $h͏_a)]],["hasOwn",[$h͏_a => (hasOwn = $h͏_a)]],["ownKeys",[$h͏_a => (ownKeys = $h͏_a)]],["setHas",[$h͏_a => (setHas = $h͏_a)]]]],["./enablements.js", [["minEnablements",[$h͏_a => (minEnablements = $h͏_a)]],["moderateEnablements",[$h͏_a => (moderateEnablements = $h͏_a)]],["severeEnablements",[$h͏_a => (severeEnablements = $h͏_a)]]]]]);
























/** @import {Reporter} from './reporting-types.js' */

/**
 * For a special set of properties defined in the `enablement` list,
 * `enablePropertyOverrides` ensures that the effect of freezing does not
 * suppress the ability to override these properties on derived objects by
 * simple assignment.
 *
 * Because of lack of sufficient foresight at the time, ES5 unfortunately
 * specified that a simple assignment to a non-existent property must fail if
 * it would override an non-writable data property of the same name in the
 * shadow of the prototype chain. In retrospect, this was a mistake, the
 * so-called "override mistake". But it is now too late and we must live with
 * the consequences.
 *
 * As a result, simply freezing an object to make it tamper proof has the
 * unfortunate side effect of breaking previously correct code that is
 * considered to have followed JS best practices, if this previous code used
 * assignment to override.
 *
 * For the enabled properties, `enablePropertyOverrides` effectively shims what
 * the assignment behavior would have been in the absence of the override
 * mistake. However, the shim produces an imperfect emulation. It shims the
 * behavior by turning these data properties into accessor properties, where
 * the accessor's getter and setter provide the desired behavior. For
 * non-reflective operations, the illusion is perfect. However, reflective
 * operations like `getOwnPropertyDescriptor` see the descriptor of an accessor
 * property rather than the descriptor of a data property. At the time of this
 * writing, this is the best we know how to do.
 *
 * To the getter of the accessor we add a property named
 * `'originalValue'` whose value is, as it says, the value that the
 * data property had before being converted to an accessor property. We add
 * this extra property to the getter for two reason:
 *
 * The harden algorithm walks the own properties reflectively, i.e., with
 * `getOwnPropertyDescriptor` semantics, rather than `[[Get]]` semantics. When
 * it sees an accessor property, it does not invoke the getter. Rather, it
 * proceeds to walk both the getter and setter as part of its transitive
 * traversal. Without this extra property, `enablePropertyOverrides` would have
 * hidden the original data property value from `harden`, which would be bad.
 * Instead, by exposing that value in an own data property on the getter,
 * `harden` finds and walks it anyway.
 *
 * We enable a form of cooperative emulation, giving reflective code an
 * opportunity to cooperate in upholding the illusion. When such cooperative
 * reflective code sees an accessor property, where the accessor's getter
 * has an `originalValue` property, it knows that the getter is
 * alleging that it is the result of the `enablePropertyOverrides` conversion
 * pattern, so it can decide to cooperatively "pretend" that it sees a data
 * property with that value.
 *
 * @param {Record<string, any>} intrinsics
 * @param {'min' | 'moderate' | 'severe'} overrideTaming
 * @param {Reporter} reporter
 * @param {Iterable<string | symbol>} [overrideDebug]
 */
               function enablePropertyOverrides(
  intrinsics,
  overrideTaming,
  { warn },
  overrideDebug = [],
) {
  const debugProperties = new Set(overrideDebug);
  function enable(path, obj, prop, desc) {
    if ('value' in desc && desc.configurable) {
      const { value } = desc;

      const isDebug = setHas(debugProperties, prop);

      // We use concise method syntax to be `this` sensitive, but still
      // omit a prototype property or [[Construct]] behavior.
      // @ts-expect-error We know there is an accessor descriptor there
      const { get: getter, set: setter } = getOwnPropertyDescriptor(
        {
          get [prop]() {
            return value;
          },
          set [prop](newValue) {
            if (obj === this) {
              throw TypeError(
                `Cannot assign to read only property '${String(
                  prop,
                )}' of '${path}'`,
              );
            }
            if (hasOwn(this, prop)) {
              this[prop] = newValue;
            } else {
              if (isDebug) {
                warn(TypeError(`Override property ${prop}`));
              }
              defineProperty(this, prop, {
                value: newValue,
                writable: true,
                enumerable: true,
                configurable: true,
              });
            }
          },
        },
        prop,
      );

      defineProperty(getter, 'originalValue', {
        value,
        writable: false,
        enumerable: false,
        configurable: false,
      });

      defineProperty(obj, prop, {
        get: getter,
        set: setter,
        enumerable: desc.enumerable,
        configurable: desc.configurable,
      });
    }
  }

  function enableProperty(path, obj, prop) {
    const desc = getOwnPropertyDescriptor(obj, prop);
    if (!desc) {
      return;
    }
    enable(path, obj, prop, desc);
  }

  function enableAllProperties(path, obj) {
    const descs = getOwnPropertyDescriptors(obj);
    if (!descs) {
      return;
    }
    // TypeScript does not allow symbols to be used as indexes because it
    // cannot recokon types of symbolized properties.
    arrayForEach(ownKeys(descs), prop => enable(path, obj, prop, descs[prop]));
  }

  function enableProperties(path, obj, plan) {
    for (const prop of ownKeys(plan)) {
      const desc = getOwnPropertyDescriptor(obj, prop);
      if (!desc || desc.get || desc.set) {
        // No not a value property, nothing to do.
        // eslint-disable-next-line no-continue
        continue;
      }

      // In case `prop` is a symbol, we first coerce it with `String`,
      // purely for diagnostic purposes.
      const subPath = `${path}.${String(prop)}`;
      const subPlan = plan[prop];

      if (subPlan === true) {
        enableProperty(subPath, obj, prop);
      } else if (subPlan === '*') {
        enableAllProperties(subPath, desc.value);
      } else if (!isPrimitive(subPlan)) {
        enableProperties(subPath, desc.value, subPlan);
      } else {
        throw TypeError(`Unexpected override enablement plan ${subPath}`);
      }
    }
  }

  let plan;
  switch (overrideTaming) {
    case 'min': {
      plan = minEnablements;
      break;
    }
    case 'moderate': {
      plan = moderateEnablements;
      break;
    }
    case 'severe': {
      plan = severeEnablements;
      break;
    }
    default: {
      throw TypeError(`unrecognized overrideTaming ${overrideTaming}`);
    }
  }

  // Do the repair.
  enableProperties('root', intrinsics, plan);
}$h͏_once.default(      enablePropertyOverrides);
})()
,
// === 25. ses ./src/tame-locale-methods.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let Number,String,TypeError,defineProperty,getOwnPropertyNames,isPrimitive,regexpExec,assert;$h͏_imports([["./commons.js", [["Number",[$h͏_a => (Number = $h͏_a)]],["String",[$h͏_a => (String = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["getOwnPropertyNames",[$h͏_a => (getOwnPropertyNames = $h͏_a)]],["isPrimitive",[$h͏_a => (isPrimitive = $h͏_a)]],["regexpExec",[$h͏_a => (regexpExec = $h͏_a)]]]],["./error/assert.js", [["assert",[$h͏_a => (assert = $h͏_a)]]]]]);










const { Fail, quote: q } = assert;

const localePattern = /^(\w*[a-z])Locale([A-Z]\w*)$/;

// Use concise methods to obtain named functions without constructor
// behavior or `.prototype` property.
const tamedMethods = {
  // See https://tc39.es/ecma262/#sec-string.prototype.localecompare
  localeCompare(arg) {
    if (this === null || this === undefined) {
      throw TypeError(
        'Cannot localeCompare with null or undefined "this" value',
      );
    }
    const s = `${this}`;
    const that = `${arg}`;
    if (s < that) {
      return -1;
    }
    if (s > that) {
      return 1;
    }
    s === that || Fail`expected ${q(s)} and ${q(that)} to compare`;
    return 0;
  },

  toString() {
    return `${this}`;
  },
};

const nonLocaleCompare = tamedMethods.localeCompare;
const numberToString = tamedMethods.toString;

               function tameLocaleMethods(intrinsics, localeTaming = 'safe') {
  if (localeTaming === 'unsafe') {
    return;
  }

  defineProperty(String.prototype, 'localeCompare', {
    value: nonLocaleCompare,
  });

  for (const intrinsicName of getOwnPropertyNames(intrinsics)) {
    const intrinsic = intrinsics[intrinsicName];
    if (!isPrimitive(intrinsic)) {
      for (const methodName of getOwnPropertyNames(intrinsic)) {
        const match = regexpExec(localePattern, methodName);
        if (match) {
          typeof intrinsic[methodName] === 'function' ||
            Fail`expected ${q(methodName)} to be a function`;
          const nonLocaleMethodName = `${match[1]}${match[2]}`;
          const method = intrinsic[nonLocaleMethodName];
          typeof method === 'function' ||
            Fail`function ${q(nonLocaleMethodName)} not found`;
          defineProperty(intrinsic, methodName, { value: method });
        }
      }
    }
  }

  // Numbers are special because toString accepts a radix instead of ignoring
  // all of the arguments that we would otherwise forward.
  defineProperty(Number.prototype, 'toLocaleString', {
    value: numberToString,
  });
}$h͏_once.default(      tameLocaleMethods);
})()
,
// === 26. ses ./src/make-eval-function.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';$h͏_imports([]);/**
 * makeEvalFunction()
 * A safe version of the native eval function which relies on
 * the safety of `safe-eval` for confinement, unless `no-eval`
 * is specified (then a TypeError is thrown on use).
 *
 * @param {Function} evaluator
 */
       const makeEvalFunction = evaluator => {
  // We use the concise method syntax to create an eval without a
  // [[Construct]] behavior (such that the invocation "new eval()" throws
  // TypeError: eval is not a constructor"), but which still accepts a
  // 'this' binding.
  const newEval = {
    eval(source) {
      if (typeof source !== 'string') {
        // As per the runtime semantic of PerformEval [ECMAScript 18.2.1.1]:
        // If Type(source) is not String, return source.
        // TODO Recent proposals from Mike Samuel may change this non-string
        // rule. Track.
        return source;
      }
      return evaluator(source);
    },
  }.eval;

  return newEval;
};$h͏_once.makeEvalFunction(makeEvalFunction);
})()
,
// === 27. ses ./src/make-function-constructor.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let FERAL_FUNCTION,arrayJoin,arrayPop,defineProperties,getPrototypeOf,assert;$h͏_imports([["./commons.js", [["FERAL_FUNCTION",[$h͏_a => (FERAL_FUNCTION = $h͏_a)]],["arrayJoin",[$h͏_a => (arrayJoin = $h͏_a)]],["arrayPop",[$h͏_a => (arrayPop = $h͏_a)]],["defineProperties",[$h͏_a => (defineProperties = $h͏_a)]],["getPrototypeOf",[$h͏_a => (getPrototypeOf = $h͏_a)]]]],["./error/assert.js", [["assert",[$h͏_a => (assert = $h͏_a)]]]]]);








const { Fail } = assert;

/*
 * makeFunctionConstructor()
 * A safe version of the native Function which relies on
 * the safety of `safe-eval` for confinement, unless `no-eval`
 * is specified (then a TypeError is thrown on use).
 */
       const makeFunctionConstructor = evaluator => {
  // Define an unused parameter to ensure Function.length === 1
  const newFunction = function Function(_body) {
    // Sanitize all parameters at the entry point.
    // eslint-disable-next-line prefer-rest-params
    const bodyText = `${arrayPop(arguments) || ''}`;
    // eslint-disable-next-line prefer-rest-params
    const parameters = `${arrayJoin(arguments, ',')}`;

    // Are parameters and bodyText valid code, or is someone
    // attempting an injection attack? This will throw a SyntaxError if:
    // - parameters doesn't parse as parameters
    // - bodyText doesn't parse as a function body
    // - either contain a call to super() or references a super property.
    //
    // It seems that XS may still be vulnerable to the attack explained at
    // https://github.com/tc39/ecma262/pull/2374#issuecomment-813769710
    // where `new Function('/*', '*/ ) {')` would incorrectly validate.
    // Before we worried about this, we check the parameters and bodyText
    // together in one call
    // ```js
    // new FERAL_FUNCTION(parameters, bodyTest);
    // ```
    // However, this check is vulnerable to that bug. Aside from that case,
    // all engines do seem to validate the parameters, taken by themselves,
    // correctly. And all engines do seem to validate the bodyText, taken
    // by itself correctly. So with the following two checks, SES builds a
    // correct safe `Function` constructor by composing two calls to an
    // original unsafe `Function` constructor that may suffer from this bug
    // but is otherwise correctly validating.
    //
    // eslint-disable-next-line no-new
    new FERAL_FUNCTION(parameters, '');
    // eslint-disable-next-line no-new
    new FERAL_FUNCTION(bodyText);

    // Safe to be combined. Defeat potential trailing comments.
    // TODO: since we create an anonymous function, the 'this' value
    // isn't bound to the global object as per specs, but set as undefined.
    const src = `(function anonymous(${parameters}\n) {\n${bodyText}\n})`;
    return evaluator(src);
  };

  defineProperties(newFunction, {
    // Ensure that any function created in any evaluator in a realm is an
    // instance of Function in any evaluator of the same realm.
    prototype: {
      value: FERAL_FUNCTION.prototype,
      writable: false,
      enumerable: false,
      configurable: false,
    },
  });

  // Assert identity of Function.__proto__ accross all compartments
  getPrototypeOf(FERAL_FUNCTION) === FERAL_FUNCTION.prototype ||
    Fail`Function prototype is the same accross compartments`;
  getPrototypeOf(newFunction) === FERAL_FUNCTION.prototype ||
    Fail`Function constructor prototype is the same across compartments`;

  return newFunction;
};$h͏_once.makeFunctionConstructor(makeFunctionConstructor);
})()
,
// === 28. ses ./src/global-object.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let TypeError,assign,create,defineProperty,entries,freeze,hasOwn,unscopablesSymbol,makeEvalFunction,makeFunctionConstructor,constantProperties,universalPropertyNames;$h͏_imports([["./commons.js", [["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["assign",[$h͏_a => (assign = $h͏_a)]],["create",[$h͏_a => (create = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["entries",[$h͏_a => (entries = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["hasOwn",[$h͏_a => (hasOwn = $h͏_a)]],["unscopablesSymbol",[$h͏_a => (unscopablesSymbol = $h͏_a)]]]],["./make-eval-function.js", [["makeEvalFunction",[$h͏_a => (makeEvalFunction = $h͏_a)]]]],["./make-function-constructor.js", [["makeFunctionConstructor",[$h͏_a => (makeFunctionConstructor = $h͏_a)]]]],["./permits.js", [["constantProperties",[$h͏_a => (constantProperties = $h͏_a)]],["universalPropertyNames",[$h͏_a => (universalPropertyNames = $h͏_a)]]]]]);













/**
 * The host's ordinary global object is not provided by a `with` block, so
 * assigning to Symbol.unscopables has no effect.
 * Since this shim uses `with` blocks to create a confined lexical scope for
 * guest programs, we cannot emulate the proper behavior.
 * With this shim, assigning Symbol.unscopables causes the given lexical
 * names to fall through to the terminal scope proxy.
 * But, we can install this setter to prevent a program from proceding on
 * this false assumption.
 *
 * @param {object} globalObject
 */
       const setGlobalObjectSymbolUnscopables = globalObject => {
  defineProperty(
    globalObject,
    unscopablesSymbol,
    freeze(
      assign(create(null), {
        set: freeze(() => {
          throw TypeError(
            `Cannot set Symbol.unscopables of a Compartment's globalThis`,
          );
        }),
        enumerable: false,
        configurable: false,
      }),
    ),
  );
};

/**
 * setGlobalObjectConstantProperties()
 * Initializes a new global object using a process similar to ECMA specifications
 * (SetDefaultGlobalBindings). This process is split between this function and
 * `setGlobalObjectMutableProperties`.
 *
 * @param {object} globalObject
 */$h͏_once.setGlobalObjectSymbolUnscopables(setGlobalObjectSymbolUnscopables);
       const setGlobalObjectConstantProperties = globalObject => {
  for (const [name, constant] of entries(constantProperties)) {
    defineProperty(globalObject, name, {
      value: constant,
      writable: false,
      enumerable: false,
      configurable: false,
    });
  }
};

/**
 * setGlobalObjectMutableProperties()
 * Create new global object using a process similar to ECMA specifications
 * (portions of SetRealmGlobalObject and SetDefaultGlobalBindings).
 * `newGlobalPropertyNames` should be either `initialGlobalPropertyNames` or
 * `sharedGlobalPropertyNames`.
 *
 * @param {object} globalObject
 * @param {object} args
 * @param {object} args.intrinsics
 * @param {object} args.newGlobalPropertyNames
 * @param {Function} args.makeCompartmentConstructor
 * @param {(object) => void} args.markVirtualizedNativeFunction
 * @param {Compartment} [args.parentCompartment]
 */$h͏_once.setGlobalObjectConstantProperties(setGlobalObjectConstantProperties);
       const setGlobalObjectMutableProperties = (
  globalObject,
  {
    intrinsics,
    newGlobalPropertyNames,
    makeCompartmentConstructor,
    markVirtualizedNativeFunction,
    parentCompartment,
  },
) => {
  for (const [name, intrinsicName] of entries(universalPropertyNames)) {
    if (hasOwn(intrinsics, intrinsicName)) {
      defineProperty(globalObject, name, {
        value: intrinsics[intrinsicName],
        writable: true,
        enumerable: false,
        configurable: true,
      });
    }
  }

  for (const [name, intrinsicName] of entries(newGlobalPropertyNames)) {
    if (hasOwn(intrinsics, intrinsicName)) {
      defineProperty(globalObject, name, {
        value: intrinsics[intrinsicName],
        writable: true,
        enumerable: false,
        configurable: true,
      });
    }
  }

  const perCompartmentGlobals = {
    globalThis: globalObject,
  };

  perCompartmentGlobals.Compartment = freeze(
    makeCompartmentConstructor(
      makeCompartmentConstructor,
      intrinsics,
      markVirtualizedNativeFunction,
      {
        parentCompartment,
        enforceNew: true,
      },
    ),
  );

  // TODO These should still be tamed according to the permits before
  // being made available.
  for (const [name, value] of entries(perCompartmentGlobals)) {
    defineProperty(globalObject, name, {
      value,
      writable: true,
      enumerable: false,
      configurable: true,
    });
    if (typeof value === 'function') {
      markVirtualizedNativeFunction(value);
    }
  }
};

/**
 * setGlobalObjectEvaluators()
 * Set the eval and the Function evaluator on the global object with given evalTaming policy.
 *
 * @param {object} globalObject
 * @param {Function} evaluator
 * @param {(object) => void} markVirtualizedNativeFunction
 */$h͏_once.setGlobalObjectMutableProperties(setGlobalObjectMutableProperties);
       const setGlobalObjectEvaluators = (
  globalObject,
  evaluator,
  markVirtualizedNativeFunction,
) => {
  {
    const f = freeze(makeEvalFunction(evaluator));
    markVirtualizedNativeFunction(f);
    defineProperty(globalObject, 'eval', {
      value: f,
      writable: true,
      enumerable: false,
      configurable: true,
    });
  }
  {
    const f = freeze(makeFunctionConstructor(evaluator));
    markVirtualizedNativeFunction(f);
    defineProperty(globalObject, 'Function', {
      value: f,
      writable: true,
      enumerable: false,
      configurable: true,
    });
  }
};$h͏_once.setGlobalObjectEvaluators(setGlobalObjectEvaluators);
})()
,
// === 29. ses ./src/strict-scope-terminator.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let Proxy,String,TypeError,ReferenceError,create,freeze,getOwnPropertyDescriptors,assert;$h͏_imports([["./commons.js", [["Proxy",[$h͏_a => (Proxy = $h͏_a)]],["String",[$h͏_a => (String = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["ReferenceError",[$h͏_a => (ReferenceError = $h͏_a)]],["create",[$h͏_a => (create = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["getOwnPropertyDescriptors",[$h͏_a => (getOwnPropertyDescriptors = $h͏_a)]]]],["./error/assert.js", [["assert",[$h͏_a => (assert = $h͏_a)]]]]]);










const { Fail, quote: q } = assert;

/**
 * `freeze` but not `harden` the proxy target so it remains trapping.
 * Thus, it should not be shared outside this module.
 *
 * @see https://github.com/endojs/endo/blob/master/packages/ses/docs/preparing-for-stabilize.md
 */
const objTarget = freeze({ __proto__: null });

/**
 * alwaysThrowHandler
 * This is an object that throws if any property is called. It's used as
 * a proxy handler which throws on any trap called.
 * It's made from a proxy with a get trap that throws. It's safe to
 * create one and share it between all Proxy handlers.
 */
       const alwaysThrowHandler = new Proxy(
  objTarget,
  freeze({
    get(_shadow, prop) {
      Fail`Please report unexpected scope handler trap: ${q(String(prop))}`;
    },
  }),
);

/*
 * scopeProxyHandlerProperties
 * scopeTerminatorHandler manages a strictScopeTerminator Proxy which serves as
 * the final scope boundary that will always return "undefined" in order
 * to prevent access to "start compartment globals".
 */$h͏_once.alwaysThrowHandler(alwaysThrowHandler);
const scopeProxyHandlerProperties = {
  get(_shadow, _prop) {
    return undefined;
  },

  set(_shadow, prop, _value) {
    // We should only hit this if the has() hook returned true matches the v8
    // ReferenceError message "Uncaught ReferenceError: xyz is not defined"
    throw ReferenceError(`${String(prop)} is not defined`);
  },

  has(_shadow, prop) {
    // we must at least return true for all properties on the realm globalThis
    return true;
  },

  // note: this is likely a bug of safari
  // https://bugs.webkit.org/show_bug.cgi?id=195534
  getPrototypeOf(_shadow) {
    return null;
  },

  // See https://github.com/endojs/endo/issues/1510
  // TODO: report as bug to v8 or Chrome, and record issue link here.
  getOwnPropertyDescriptor(_shadow, prop) {
    // Coerce with `String` in case prop is a symbol.
    const quotedProp = q(String(prop));
    // eslint-disable-next-line @endo/no-polymorphic-call
    console.warn(
      `getOwnPropertyDescriptor trap on scopeTerminatorHandler for ${quotedProp}`,
      TypeError().stack,
    );
    return undefined;
  },

  // See https://github.com/endojs/endo/issues/1490
  // TODO Report bug to JSC or Safari
  ownKeys(_shadow) {
    return [];
  },
};

// The scope handler's prototype is a proxy that throws if any trap other
// than get/set/has are run (like getOwnPropertyDescriptors, apply,
// getPrototypeOf).
       const strictScopeTerminatorHandler = freeze(
  create(
    alwaysThrowHandler,
    getOwnPropertyDescriptors(scopeProxyHandlerProperties),
  ),
);$h͏_once.strictScopeTerminatorHandler(strictScopeTerminatorHandler);

       const strictScopeTerminator = new Proxy(
  objTarget,
  strictScopeTerminatorHandler,
);$h͏_once.strictScopeTerminator(strictScopeTerminator);
})()
,
// === 30. ses ./src/sloppy-globals-scope-terminator.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let Proxy,create,freeze,getOwnPropertyDescriptors,reflectSet,strictScopeTerminatorHandler,alwaysThrowHandler;$h͏_imports([["./commons.js", [["Proxy",[$h͏_a => (Proxy = $h͏_a)]],["create",[$h͏_a => (create = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["getOwnPropertyDescriptors",[$h͏_a => (getOwnPropertyDescriptors = $h͏_a)]],["reflectSet",[$h͏_a => (reflectSet = $h͏_a)]]]],["./strict-scope-terminator.js", [["strictScopeTerminatorHandler",[$h͏_a => (strictScopeTerminatorHandler = $h͏_a)]],["alwaysThrowHandler",[$h͏_a => (alwaysThrowHandler = $h͏_a)]]]]]);











/**
 * `freeze` but not `harden` the proxy target so it remains trapping.
 * Thus, it should not be shared outside this module.
 *
 * @see https://github.com/endojs/endo/blob/master/packages/ses/docs/preparing-for-stabilize.md
 */
const objTarget = freeze({ __proto__: null });

/*
 * createSloppyGlobalsScopeTerminator()
 * strictScopeTerminatorHandler manages a scopeTerminator Proxy which serves as
 * the final scope boundary that will always return "undefined" in order
 * to prevent access to "start compartment globals". When "sloppyGlobalsMode"
 * is true, the Proxy will perform sets on the "globalObject".
 */
       const createSloppyGlobalsScopeTerminator = globalObject => {
  const scopeProxyHandlerProperties = {
    // inherit scopeTerminator behavior
    ...strictScopeTerminatorHandler,

    // Redirect set properties to the globalObject.
    set(_shadow, prop, value) {
      return reflectSet(globalObject, prop, value);
    },

    // Always claim to have a potential property in order to be the recipient of a set
    has(_shadow, _prop) {
      return true;
    },
  };

  // The scope handler's prototype is a proxy that throws if any trap other
  // than get/set/has are run (like getOwnPropertyDescriptors, apply,
  // getPrototypeOf).
  const sloppyGlobalsScopeTerminatorHandler = freeze(
    create(
      alwaysThrowHandler,
      getOwnPropertyDescriptors(scopeProxyHandlerProperties),
    ),
  );

  const sloppyGlobalsScopeTerminator = new Proxy(
    objTarget,
    sloppyGlobalsScopeTerminatorHandler,
  );

  return sloppyGlobalsScopeTerminator;
};$h͏_once.createSloppyGlobalsScopeTerminator(createSloppyGlobalsScopeTerminator);
freeze(createSloppyGlobalsScopeTerminator);
})()
,
// === 31. ses ./src/eval-scope.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let FERAL_EVAL,create,defineProperties,freeze,assert;$h͏_imports([["./commons.js", [["FERAL_EVAL",[$h͏_a => (FERAL_EVAL = $h͏_a)]],["create",[$h͏_a => (create = $h͏_a)]],["defineProperties",[$h͏_a => (defineProperties = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]]]],["./error/assert.js", [["assert",[$h͏_a => (assert = $h͏_a)]]]]]);



const { Fail } = assert;

// We attempt to frustrate stack bumping attacks on the safe evaluator
// (`make-safe-evaluator.js`).
// A stack bumping attack forces an API call to throw a stack overflow
// `RangeError` at an inopportune time.
// The attacker arranges for the stack to be sufficiently deep that the API
// consumes exactly enough stack frames to throw an exception.
//
// For the safe evaluator, an exception thrown between adding and then deleting
// `eval` on `evalScope` could leak the real `eval` to an attacker's lexical
// scope.
// This would be sufficiently disastrous that we guard against it twice.
// First, we delete `eval` from `evalScope` immediately before rendering it to
// the guest program's lexical scope.
//
// If the attacker manages to arrange for `eval` to throw an exception after we
// call `allowNextEvalToBeUnsafe` but before the guest program accesses `eval`,
// it would be able to access `eval` once more in its own code.
// Although they could do no harm with a direct `eval`, they would be able to
// escape to the true global scope with an indirect `eval`.
//
//   prepareStack(depth, () => {
//     (eval)('');
//   });
//   const unsafeEval = (eval);
//   const safeEval = (eval);
//   const realGlobal = unsafeEval('globalThis');
//
// To protect against that case, we also delete `eval` from the `evalScope` in
// a `finally` block surrounding the call to the safe evaluator.
// The only way to reach this case is if `eval` remains on `evalScope` due to
// an attack, so we assume that attack would have have invalided our isolation
// and revoke all future access to the evaluator.
//
// To defeat a stack bumping attack, we must use fewer stack frames to recover
// in that `finally` block than we used in the `try` block.
// We have no reliable guarantees about how many stack frames a block of
// JavaScript will consume.
// Function inlining, tail-call optimization, variations in the size of a stack
// frame, and block scopes may affect the depth of the stack.
// The only number of acceptable stack frames to use in the finally block is
// zero.
// We only use property assignment and deletion in the safe evaluator's
// `finally` block.
// We use `delete evalScope.eval` to withhold the evaluator.
// We assign an envelope object over `evalScopeKit.revoked` to revoke the
// evaluator.
//
// This is why we supply a meaningfully named function for
// `allowNextEvalToBeUnsafe` but do not provide a corresponding
// `revokeAccessToUnsafeEval` or even simply `revoke`.
// These recovery routines are expressed inline in the safe evaluator.

       const makeEvalScopeKit = () => {
  const evalScope = create(null);
  const oneTimeEvalProperties = freeze({
    eval: {
      get() {
        delete evalScope.eval;
        return FERAL_EVAL;
      },
      enumerable: false,
      configurable: true,
    },
  });

  const evalScopeKit = {
    evalScope,
    allowNextEvalToBeUnsafe() {
      const { revoked } = evalScopeKit;
      if (revoked !== null) {
        Fail`a handler did not reset allowNextEvalToBeUnsafe ${revoked.err}`;
      }
      // Allow next reference to eval produce the unsafe FERAL_EVAL.
      // We avoid defineProperty because it consumes an extra stack frame taming
      // its return value.
      defineProperties(evalScope, oneTimeEvalProperties);
    },
    /** @type {null | { err: any }} */
    revoked: null,
  };

  return evalScopeKit;
};$h͏_once.makeEvalScopeKit(makeEvalScopeKit);
})()
,
// === 32. ses ./src/get-source-url.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let FERAL_REG_EXP,regexpExec,stringSlice;$h͏_imports([["./commons.js", [["FERAL_REG_EXP",[$h͏_a => (FERAL_REG_EXP = $h͏_a)]],["regexpExec",[$h͏_a => (regexpExec = $h͏_a)]],["stringSlice",[$h͏_a => (stringSlice = $h͏_a)]]]]]);

// Captures a key and value of the form #key=value or @key=value
const sourceMetaEntryRegExp =
  '\\s*[@#]\\s*([a-zA-Z][a-zA-Z0-9]*)\\s*=\\s*([^\\s\\*]*)';
// Captures either a one-line or multi-line comment containing
// one #key=value or @key=value.
// Produces two pairs of capture groups, but the initial two may be undefined.
// On account of the mechanics of regular expressions, scanning from the end
// does not allow us to capture every pair, so getSourceURL must capture and
// trim until there are no matching comments.
const sourceMetaEntriesRegExp = new FERAL_REG_EXP(
  `(?:\\s*//${sourceMetaEntryRegExp}|/\\*${sourceMetaEntryRegExp}\\s*\\*/)\\s*$`,
);

/**
 * @param {string} src
 */
       const getSourceURL = src => {
  let sourceURL = '<unknown>';

  // Our regular expression matches the last one or two comments with key value
  // pairs at the end of the source, avoiding a scan over the entire length of
  // the string, but at the expense of being able to capture all the (key,
  // value) pair meta comments at the end of the source, which may include
  // sourceMapURL in addition to sourceURL.
  // So, we sublimate the comments out of the source until no source or no
  // comments remain.
  while (src.length > 0) {
    const match = regexpExec(sourceMetaEntriesRegExp, src);
    if (match === null) {
      break;
    }
    src = stringSlice(src, 0, src.length - match[0].length);

    // We skip $0 since it contains the entire match.
    // The match contains four capture groups,
    // two (key, value) pairs, the first of which
    // may be undefined.
    // On the off-chance someone put two sourceURL comments in their code with
    // different commenting conventions, the latter has precedence.
    if (match[3] === 'sourceURL') {
      sourceURL = match[4];
    } else if (match[1] === 'sourceURL') {
      sourceURL = match[2];
    }
  }

  return sourceURL;
};$h͏_once.getSourceURL(getSourceURL);
})()
,
// === 33. ses ./src/transforms.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let FERAL_REG_EXP,SyntaxError,regexpReplace,sealRegexp,stringSearch,stringSlice,stringSplit,freeze,getSourceURL;$h͏_imports([["./commons.js", [["FERAL_REG_EXP",[$h͏_a => (FERAL_REG_EXP = $h͏_a)]],["SyntaxError",[$h͏_a => (SyntaxError = $h͏_a)]],["regexpReplace",[$h͏_a => (regexpReplace = $h͏_a)]],["sealRegexp",[$h͏_a => (sealRegexp = $h͏_a)]],["stringSearch",[$h͏_a => (stringSearch = $h͏_a)]],["stringSlice",[$h͏_a => (stringSlice = $h͏_a)]],["stringSplit",[$h͏_a => (stringSplit = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]]]],["./get-source-url.js", [["getSourceURL",[$h͏_a => (getSourceURL = $h͏_a)]]]]]);













/**
 * Find the first occurence of the given pattern and return
 * the location as the approximate line number.
 *
 * @param {string} src
 * @param {RegExp} pattern
 * @returns {number}
 */
function getLineNumber(src, pattern) {
  const index = stringSearch(src, pattern);
  if (index < 0) {
    return -1;
  }

  // The importPattern incidentally captures an initial \n in
  // an attempt to reject a . prefix, so we need to offset
  // the line number in that case.
  const adjustment = src[index] === '\n' ? 1 : 0;

  return stringSplit(stringSlice(src, 0, index), '\n').length + adjustment;
}

// /////////////////////////////////////////////////////////////////////////////

const htmlCommentPattern = sealRegexp(
  new FERAL_REG_EXP(`(?:${'<'}!--|--${'>'})`, 'g'),
);

/**
 * Conservatively reject the source text if it may contain text that some
 * JavaScript parsers may treat as an html-like comment. To reject without
 * parsing, `rejectHtmlComments` will also reject some other text as well.
 *
 * https://www.ecma-international.org/ecma-262/9.0/index.html#sec-html-like-comments
 * explains that JavaScript parsers may or may not recognize html
 * comment tokens "<" immediately followed by "!--" and "--"
 * immediately followed by ">" in non-module source text, and treat
 * them as a kind of line comment. Since otherwise both of these can
 * appear in normal JavaScript source code as a sequence of operators,
 * we have the terrifying possibility of the same source code parsing
 * one way on one correct JavaScript implementation, and another way
 * on another.
 *
 * This shim takes the conservative strategy of just rejecting source
 * text that contains these strings anywhere. Note that this very
 * source file is written strangely to avoid mentioning these
 * character strings explicitly.
 *
 * We do not write the regexp in a straightforward way, so that an
 * apparennt html comment does not appear in this file. Thus, we avoid
 * rejection by the overly eager rejectDangerousSources.
 *
 * @param {string} src
 * @returns {string}
 */
       const rejectHtmlComments = src => {
  const lineNumber = getLineNumber(src, htmlCommentPattern);
  if (lineNumber < 0) {
    return src;
  }
  const name = getSourceURL(src);
  // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_HTML_COMMENT_REJECTED.md
  throw SyntaxError(
    `Possible HTML comment rejected at ${name}:${lineNumber}. (SES_HTML_COMMENT_REJECTED)`,
  );
};

/**
 * An optional transform to place ahead of `rejectHtmlComments` to evade *that*
 * rejection. However, it may change the meaning of the program.
 *
 * This evasion replaces each alleged html comment with the space-separated
 * JavaScript operator sequence that it may mean, assuming that it appears
 * outside of a comment or literal string, in source code where the JS
 * parser makes no special case for html comments (like module source code).
 * In that case, this evasion preserves the meaning of the program, though it
 * does change the souce column numbers on each effected line.
 *
 * If the html comment appeared in a literal (a string literal, regexp literal,
 * or a template literal), then this evasion will change the meaning of the
 * program by changing the text of that literal.
 *
 * If the html comment appeared in a JavaScript comment, then this evasion does
 * not change the meaning of the program because it only changes the contents of
 * those comments.
 *
 * @param {string} src
 * @returns {string}
 */$h͏_once.rejectHtmlComments(rejectHtmlComments);
       const evadeHtmlCommentTest = src => {
  const replaceFn = match => (match[0] === '<' ? '< ! --' : '-- >');
  return regexpReplace(htmlCommentPattern, src, replaceFn);
};

// /////////////////////////////////////////////////////////////////////////////
$h͏_once.evadeHtmlCommentTest(evadeHtmlCommentTest);
const importPattern = sealRegexp(
  new FERAL_REG_EXP('(^|[^.]|\\.\\.\\.)\\bimport(\\s*(?:\\(|/[/*]))', 'g'),
);

/**
 * Conservatively reject the source text if it may contain a dynamic
 * import expression. To reject without parsing, `rejectImportExpressions` will
 * also reject some other text as well.
 *
 * The proposed dynamic import expression is the only syntax currently
 * proposed, that can appear in non-module JavaScript code, that
 * enables direct access to the outside world that cannot be
 * suppressed or intercepted without parsing and rewriting. Instead,
 * this shim conservatively rejects any source text that seems to
 * contain such an expression. To do this safely without parsing, we
 * must also reject some valid programs, i.e., those containing
 * apparent import expressions in literal strings or comments.
 *
 * The current conservative rule looks for the identifier "import"
 * followed by either an open paren or something that looks like the
 * beginning of a comment. We assume that we do not need to worry
 * about html comment syntax because that was already rejected by
 * rejectHtmlComments.
 *
 * this \s *must* match all kinds of syntax-defined whitespace. If e.g.
 * U+2028 (LINE SEPARATOR) or U+2029 (PARAGRAPH SEPARATOR) is treated as
 * whitespace by the parser, but not matched by /\s/, then this would admit
 * an attack like: import\u2028('power.js') . We're trying to distinguish
 * something like that from something like importnotreally('power.js') which
 * is perfectly safe.
 *
 * @param {string} src
 * @returns {string}
 */
       const rejectImportExpressions = src => {
  const lineNumber = getLineNumber(src, importPattern);
  if (lineNumber < 0) {
    return src;
  }
  const name = getSourceURL(src);
  // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_IMPORT_REJECTED.md
  throw SyntaxError(
    `Possible import expression rejected at ${name}:${lineNumber}. (SES_IMPORT_REJECTED)`,
  );
};

/**
 * An optional transform to place ahead of `rejectImportExpressions` to evade
 * *that* rejection. However, it may change the meaning of the program.
 *
 * This evasion replaces each suspicious `import` identifier with `__import__`.
 * If the alleged import expression appears in a JavaScript comment, this
 * evasion will not change the meaning of the program. If it appears in a
 * literal (string literal, regexp literal, or a template literal), then this
 * evasion will change the contents of that literal. If it appears as code
 * where it would be parsed as an expression, then it might or might not change
 * the meaning of the program, depending on the binding, if any, of the lexical
 * variable `__import__`.
 *
 * @param {string} src
 * @returns {string}
 */$h͏_once.rejectImportExpressions(rejectImportExpressions);
       const evadeImportExpressionTest = src => {
  const replaceFn = (_, p1, p2) => `${p1}__import__${p2}`;
  return regexpReplace(importPattern, src, replaceFn);
};

// /////////////////////////////////////////////////////////////////////////////
$h͏_once.evadeImportExpressionTest(evadeImportExpressionTest);
const someDirectEvalPattern = new FERAL_REG_EXP(
  '(^|[^.])\\beval(\\s*\\()',
  'g',
);

/**
 * Heuristically reject some text that seems to contain a direct eval
 * expression, with both false positives and false negavives. To reject without
 * parsing, `rejectSomeDirectEvalExpressions` may will also reject some other
 * text as well. It may also accept source text that contains a direct eval
 * written oddly, such as `(eval)(src)`. This false negative is not a security
 * vulnerability. Rather it is a compat hazard because it will execute as
 * an indirect eval under the SES-shim but as a direct eval on platforms that
 * support SES directly (like XS).
 *
 * The shim cannot correctly emulate a direct eval as explained at
 * https://github.com/Agoric/realms-shim/issues/12
 * If we did not reject direct eval syntax, we would
 * accidentally evaluate these with an emulation of indirect eval. To
 * prevent future compatibility problems, in shifting from use of the
 * shim to genuine platform support for the proposal, we should
 * instead statically reject code that seems to contain a direct eval
 * expression.
 *
 * As with the dynamic import expression, to avoid a full parse, we do
 * this approximately with a regexp, that will also reject strings
 * that appear safely in comments or strings. Unlike dynamic import,
 * if we miss some, this only creates future compat problems, not
 * security problems. Thus, we are only trying to catch innocent
 * occurrences, not malicious one. In particular, `(eval)(...)` is
 * direct eval syntax that would not be caught by the following regexp.
 *
 * Exported for unit tests.
 *
 * @param {string} src
 * @returns {string}
 */
       const rejectSomeDirectEvalExpressions = src => {
  const lineNumber = getLineNumber(src, someDirectEvalPattern);
  if (lineNumber < 0) {
    return src;
  }
  const name = getSourceURL(src);
  // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_EVAL_REJECTED.md
  throw SyntaxError(
    `Possible direct eval expression rejected at ${name}:${lineNumber}. (SES_EVAL_REJECTED)`,
  );
};

// /////////////////////////////////////////////////////////////////////////////

/**
 * A transform that bundles together the transforms that must unconditionally
 * happen last in order to ensure safe evaluation without parsing.
 *
 * @param {string} source
 * @returns {string}
 */$h͏_once.rejectSomeDirectEvalExpressions(rejectSomeDirectEvalExpressions);
       const mandatoryTransforms = source => {
  source = rejectHtmlComments(source);
  source = rejectImportExpressions(source);
  return source;
};

/**
 * Starting with `source`, apply each transform to the result of the
 * previous one, returning the result of the last transformation.
 *
 * @param {string} source
 * @param {((str: string) => string)[]} transforms
 * @returns {string}
 */$h͏_once.mandatoryTransforms(mandatoryTransforms);
       const applyTransforms = (source, transforms) => {
  for (let i = 0, l = transforms.length; i < l; i += 1) {
    const transform = transforms[i];
    source = transform(source);
  }
  return source;
};

// export all as a frozen object
$h͏_once.applyTransforms(applyTransforms);const transforms=freeze({
  rejectHtmlComments: freeze(rejectHtmlComments),
  evadeHtmlCommentTest: freeze(evadeHtmlCommentTest),
  rejectImportExpressions: freeze(rejectImportExpressions),
  evadeImportExpressionTest: freeze(evadeImportExpressionTest),
  rejectSomeDirectEvalExpressions: freeze(rejectSomeDirectEvalExpressions),
  mandatoryTransforms: freeze(mandatoryTransforms),
  applyTransforms: freeze(applyTransforms),
});$h͏_once.transforms(transforms);
})()
,
// === 34. ses ./src/scope-constants.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let arrayFilter,arrayIncludes,getOwnPropertyDescriptor,getOwnPropertyNames,hasOwn,regexpExec,Set,setHas;$h͏_imports([["./commons.js", [["arrayFilter",[$h͏_a => (arrayFilter = $h͏_a)]],["arrayIncludes",[$h͏_a => (arrayIncludes = $h͏_a)]],["getOwnPropertyDescriptor",[$h͏_a => (getOwnPropertyDescriptor = $h͏_a)]],["getOwnPropertyNames",[$h͏_a => (getOwnPropertyNames = $h͏_a)]],["hasOwn",[$h͏_a => (hasOwn = $h͏_a)]],["regexpExec",[$h͏_a => (regexpExec = $h͏_a)]],["Set",[$h͏_a => (Set = $h͏_a)]],["setHas",[$h͏_a => (setHas = $h͏_a)]]]]]);










/**
 * reservedNames
 * In JavaScript you cannot use reserved words as variable names (except for
 * "eval", which is specially reserved to prevent shadowing).
 * https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#sec-identifier-names
 */
const reservedNames = new Set([
  // 11.6.2.1 Keywords
  'await',
  'break',
  'case',
  'catch',
  'class',
  'const',
  'continue',
  'debugger',
  'default',
  'delete',
  'do',
  'else',
  'export',
  'extends',
  'finally',
  'for',
  'function',
  'if',
  'import',
  'in',
  'instanceof',
  'new',
  'return',
  'super',
  'switch',
  'this',
  'throw',
  'try',
  'typeof',
  'var',
  'void',
  'while',
  'with',
  'yield',

  // Also reserved when parsing strict mode code
  'let',
  'static',

  // 11.6.2.2 Future Reserved Words
  'enum',

  // Also reserved when parsing strict mode code
  'implements',
  'package',
  'protected',
  'interface',
  'private',
  'public',

  // Reserved but not mentioned in specs
  'await',

  'null',
  'true',
  'false',

  'this',
  'arguments',

  // Reserved by us
  'eval',
]);

/**
 * identifierPattern
 * Simplified validation of identifier names: may only contain alphanumeric
 * characters (or "$" or "_"), and may not start with a digit. This is safe
 * and does not reduces the compatibility of the shim. The motivation for
 * this limitation was to decrease the complexity of the implementation,
 * and to maintain a resonable level of performance.
 * Note: \w is equivalent [a-zA-Z_0-9]
 * See 11.6.1 Identifier Names
 */
const identifierPattern = /^[a-zA-Z_$][\w$]*$/;

/**
 * isValidIdentifierName()
 * Is a value allowed as an arbitrary identifier name?
 *
 * @param {string} name
 */
       const isValidIdentifierName = name =>
  !setHas(reservedNames, name) && !!regexpExec(identifierPattern, name);

/*
 * isImmutableDataProperty
 */$h͏_once.isValidIdentifierName(isValidIdentifierName);

function isImmutableDataProperty(obj, name) {
  const desc = getOwnPropertyDescriptor(obj, name);
  return (
    desc &&
    //
    // The getters will not have .writable, don't let the falsyness of
    // 'undefined' trick us: test with === false, not ! . However descriptors
    // inherit from the (potentially poisoned) global object, so we might see
    // extra properties which weren't really there. Accessor properties have
    // 'get/set/enumerable/configurable', while data properties have
    // 'value/writable/enumerable/configurable'.
    desc.configurable === false &&
    desc.writable === false &&
    //
    // Checks for data properties because they're the only ones we can
    // optimize (accessors are most likely non-constant). Descriptors can't
    // can't have accessors and value properties at the same time, therefore
    // this check is sufficient. Using explicit own property deal with the
    // case where Object.prototype has been poisoned.
    hasOwn(desc, 'value')
  );
}

/**
 * getScopeConstants()
 * What variable names might be brought into scope? These include all
 * property names which can be variable names, including the names
 * of inherited properties. It excludes symbols and names which are
 * keywords. We drop symbols safely. Currently, this shim refuses
 * service if any of the names are keywords or keyword-like. This is
 * safe and only affects performance optimization.
 *
 * @param {object} globalObject
 * @param {object} moduleLexicals
 */
       const getScopeConstants = (globalObject, moduleLexicals = {}) => {
  // getOwnPropertyNames() does ignore Symbols so we don't need to
  // filter them out.
  const globalObjectNames = getOwnPropertyNames(globalObject);
  const moduleLexicalNames = getOwnPropertyNames(moduleLexicals);

  // Collect all valid & immutable identifiers from the endowments.
  const moduleLexicalConstants = arrayFilter(
    moduleLexicalNames,
    name =>
      isValidIdentifierName(name) &&
      isImmutableDataProperty(moduleLexicals, name),
  );

  // Collect all valid & immutable identifiers from the global that
  // are also not present in the endowments (immutable or not).
  const globalObjectConstants = arrayFilter(
    globalObjectNames,
    name =>
      // Can't define a constant: it would prevent a
      // lookup on the endowments.
      !arrayIncludes(moduleLexicalNames, name) &&
      isValidIdentifierName(name) &&
      isImmutableDataProperty(globalObject, name),
  );

  return {
    globalObjectConstants,
    moduleLexicalConstants,
  };
};$h͏_once.getScopeConstants(getScopeConstants);
})()
,
// === 35. ses ./src/make-evaluate.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let FERAL_FUNCTION,arrayJoin,apply,getScopeConstants;$h͏_imports([["./commons.js", [["FERAL_FUNCTION",[$h͏_a => (FERAL_FUNCTION = $h͏_a)]],["arrayJoin",[$h͏_a => (arrayJoin = $h͏_a)]],["apply",[$h͏_a => (apply = $h͏_a)]]]],["./scope-constants.js", [["getScopeConstants",[$h͏_a => (getScopeConstants = $h͏_a)]]]]]);




/**
 * buildOptimizer()
 * Given an array of identifiers, the optimizer returns a `const` declaration
 * destructuring `this.${name}`.
 *
 * @param {Array<string>} constants
 * @param {string} name
 */
function buildOptimizer(constants, name) {
  // No need to build an optimizer when there are no constants.
  if (constants.length === 0) return '';
  // Use 'this' to avoid going through the scope proxy, which is unnecessary
  // since the optimizer only needs references to the safe global.
  // Destructure the constants from the target scope object.
  return `const {${arrayJoin(constants, ',')}} = this.${name};`;
}

/**
 * makeEvaluate()
 * Create an 'evaluate' function with the correct optimizer inserted.
 *
 * @param {object} context
 * @param {object} context.evalScope
 * @param {object} context.moduleLexicals
 * @param {object} context.globalObject
 * @param {object} context.scopeTerminator
 */
       const makeEvaluate = context => {
  const { globalObjectConstants, moduleLexicalConstants } = getScopeConstants(
    context.globalObject,
    context.moduleLexicals,
  );
  const globalObjectOptimizer = buildOptimizer(
    globalObjectConstants,
    'globalObject',
  );
  const moduleLexicalOptimizer = buildOptimizer(
    moduleLexicalConstants,
    'moduleLexicals',
  );

  // Create a function in sloppy mode, so that we can use 'with'. It returns
  // a function in strict mode that evaluates the provided code using direct
  // eval, and thus in strict mode in the same scope. We must be very careful
  // to not create new names in this scope

  // 1: we use multiple nested 'with' to catch all free variable names. The
  // `this` value of the outer sloppy function holds the different scope
  // layers, from inner to outer:
  //    a) `evalScope` which must release the `FERAL_EVAL` as 'eval' once for
  //       every invocation of the inner `evaluate` function in order to
  //       trigger direct eval. The direct eval semantics is what allows the
  //       evaluated code to lookup free variable names on the other scope
  //       objects and not in global scope.
  //    b) `moduleLexicals` which provide a way to introduce free variables
  //       that are not available on the globalObject.
  //    c) `globalObject` is the global scope object of the evaluator, aka the
  //       Compartment's `globalThis`.
  //    d) `scopeTerminator` is a proxy object which prevents free variable
  //       lookups to escape to the start compartment's global object.
  // 2: `optimizer`s catch constant variable names for speed.
  // 3: The inner strict `evaluate` function should be passed two parameters:
  //    a) its arguments[0] is the source to be directly evaluated.
  //    b) its 'this' is the this binding seen by the code being
  //       directly evaluated (the globalObject).

  // Notes:
  // - The `optimizer` strings only lookup values on the `globalObject` and
  //   `moduleLexicals` objects by construct. Keywords like 'function' are
  //   reserved and cannot be used as a variable, so they are excluded from the
  //   optimizer. Furthermore to prevent shadowing 'eval', while a valid
  //   identifier, that name is also explicitly excluded.
  // - when 'eval' is looked up in the `evalScope`, the powerful unsafe eval
  //   intrinsic is returned after automatically removing it from the
  //   `evalScope`. Any further reference to 'eval' in the evaluate string will
  //   get the tamed evaluator from the `globalObject`, if any.

  // TODO https://github.com/endojs/endo/issues/816
  // The optimizer currently runs under sloppy mode, and although we doubt that
  // there is any vulnerability introduced just by running the optimizer
  // sloppy, we are much more confident in the semantics of strict mode.
  // The `evaluate` function can be and is reused across multiple evaluations.
  // Since the optimizer should not be re-evaluated every time, it cannot be
  // inside the `evaluate` closure. While we could potentially nest an
  // intermediate layer of `() => {'use strict'; ${optimizers}; ...`, it
  // doesn't seem worth the overhead and complexity.
  const evaluateFactory = FERAL_FUNCTION(`
    with (this.scopeTerminator) {
      with (this.globalObject) {
        with (this.moduleLexicals) {
          with (this.evalScope) {
            ${globalObjectOptimizer}
            ${moduleLexicalOptimizer}
            return function() {
              'use strict';
              return eval(arguments[0]);
            };
          }
        }
      }
    }
  `);

  return apply(evaluateFactory, context, []);
};$h͏_once.makeEvaluate(makeEvaluate);
})()
,
// === 36. ses ./src/make-safe-evaluator.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let apply,arrayFlatMap,freeze,identity,strictScopeTerminator,createSloppyGlobalsScopeTerminator,makeEvalScopeKit,applyTransforms,mandatoryTransforms,makeEvaluate,assert;$h͏_imports([["./commons.js", [["apply",[$h͏_a => (apply = $h͏_a)]],["arrayFlatMap",[$h͏_a => (arrayFlatMap = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["identity",[$h͏_a => (identity = $h͏_a)]]]],["./strict-scope-terminator.js", [["strictScopeTerminator",[$h͏_a => (strictScopeTerminator = $h͏_a)]]]],["./sloppy-globals-scope-terminator.js", [["createSloppyGlobalsScopeTerminator",[$h͏_a => (createSloppyGlobalsScopeTerminator = $h͏_a)]]]],["./eval-scope.js", [["makeEvalScopeKit",[$h͏_a => (makeEvalScopeKit = $h͏_a)]]]],["./transforms.js", [["applyTransforms",[$h͏_a => (applyTransforms = $h͏_a)]],["mandatoryTransforms",[$h͏_a => (mandatoryTransforms = $h͏_a)]]]],["./make-evaluate.js", [["makeEvaluate",[$h͏_a => (makeEvaluate = $h͏_a)]]]],["./error/assert.js", [["assert",[$h͏_a => (assert = $h͏_a)]]]]]);










const { Fail } = assert;

/**
 * makeSafeEvaluator()
 * Build the low-level operation used by all evaluators:
 * eval(), Function(), Compartment.prototype.evaluate().
 *
 * @param {object} options
 * @param {object} options.globalObject
 * @param {object} [options.moduleLexicals]
 * @param {Array<import('./lockdown.js').Transform>} [options.globalTransforms]
 * @param {boolean} [options.sloppyGlobalsMode]
 */
       const makeSafeEvaluator = ({
  globalObject,
  moduleLexicals = {},
  globalTransforms = [],
  sloppyGlobalsMode = false,
}) => {
  const scopeTerminator = sloppyGlobalsMode
    ? createSloppyGlobalsScopeTerminator(globalObject)
    : strictScopeTerminator;
  const evalScopeKit = makeEvalScopeKit();
  const { evalScope } = evalScopeKit;

  const evaluateContext = freeze({
    evalScope,
    moduleLexicals,
    globalObject,
    scopeTerminator,
  });

  // Defer creating the actual evaluator to first use.
  // Creating a compartment should be possible in no-eval environments
  // It also allows more global constants to be captured by the optimizer
  let evaluate;
  const provideEvaluate = () => {
    if (!evaluate) {
      evaluate = makeEvaluate(evaluateContext);
    }
  };

  /**
   * @param {string} source
   * @param {object} [options]
   * @param {Array<import('./lockdown.js').Transform>} [options.localTransforms]
   */
  const safeEvaluate = (source, options) => {
    const { localTransforms = [] } = options || {};
    provideEvaluate();

    // Execute the mandatory transforms last to ensure that any rewritten code
    // meets those mandatory requirements.
    source = applyTransforms(
      source,
      arrayFlatMap(
        [localTransforms, globalTransforms, [mandatoryTransforms]],
        identity,
      ),
    );

    let err;
    try {
      // Allow next reference to eval produce the unsafe FERAL_EVAL.
      // eslint-disable-next-line @endo/no-polymorphic-call
      evalScopeKit.allowNextEvalToBeUnsafe();

      // Ensure that "this" resolves to the safe global.
      return apply(evaluate, globalObject, [source]);
    } catch (e) {
      // stash the child-code error in hopes of debugging the internal failure
      err = e;
      throw e;
    } finally {
      const unsafeEvalWasStillExposed = 'eval' in evalScope;
      delete evalScope.eval;
      if (unsafeEvalWasStillExposed) {
        // Barring a defect in the SES shim, the evalScope should allow the
        // powerful, unsafe  `eval` to be used by `evaluate` exactly once, as the
        // very first name that it attempts to access from the lexical scope.
        // A defect in the SES shim could throw an exception after we set
        // `evalScope.eval` and before `evaluate` calls `eval` internally.
        // If we get here, SES is very broken.
        // This condition is one where this vat is now hopelessly confused, and
        // the vat as a whole should be aborted.
        // No further code should run.
        // All immediately reachable state should be abandoned.
        // However, that is not yet possible, so we at least prevent further
        // variable resolution via the scopeHandler, and throw an error with
        // diagnostic info including the thrown error if any from evaluating the
        // source code.
        evalScopeKit.revoked = { err };
        // TODO A GOOD PLACE TO PANIC(), i.e., kill the vat incarnation.
        // See https://github.com/Agoric/SES-shim/issues/490
        Fail`handler did not reset allowNextEvalToBeUnsafe ${err}`;
      }
    }
  };

  return { safeEvaluate };
};$h͏_once.makeSafeEvaluator(makeSafeEvaluator);
})()
,
// === 37. ses ./src/tame-function-tostring.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let WeakSet,defineProperty,freeze,functionPrototype,functionToString,stringEndsWith,weaksetAdd,weaksetHas;$h͏_imports([["./commons.js", [["WeakSet",[$h͏_a => (WeakSet = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["functionPrototype",[$h͏_a => (functionPrototype = $h͏_a)]],["functionToString",[$h͏_a => (functionToString = $h͏_a)]],["stringEndsWith",[$h͏_a => (stringEndsWith = $h͏_a)]],["weaksetAdd",[$h͏_a => (weaksetAdd = $h͏_a)]],["weaksetHas",[$h͏_a => (weaksetHas = $h͏_a)]]]]]);










const nativeSuffix = ') { [native code] }';

// Note: Top level mutable state. Does not make anything worse, since the
// patching of `Function.prototype.toString` is also globally stateful. We
// use this top level state so that multiple calls to `tameFunctionToString` are
// idempotent, rather than creating redundant indirections.
let markVirtualizedNativeFunction;

/**
 * Replace `Function.prototype.toString` with one that recognizes
 * shimmed functions as honorary native functions.
 */
       const tameFunctionToString = () => {
  if (markVirtualizedNativeFunction === undefined) {
    const virtualizedNativeFunctions = new WeakSet();

    const tamingMethods = {
      toString() {
        const str = functionToString(this);
        if (
          stringEndsWith(str, nativeSuffix) ||
          !weaksetHas(virtualizedNativeFunctions, this)
        ) {
          return str;
        }
        return `function ${this.name}() { [native code] }`;
      },
    };

    defineProperty(functionPrototype, 'toString', {
      value: tamingMethods.toString,
    });

    markVirtualizedNativeFunction = freeze(func =>
      weaksetAdd(virtualizedNativeFunctions, func),
    );
  }
  return markVirtualizedNativeFunction;
};$h͏_once.tameFunctionToString(tameFunctionToString);
})()
,
// === 38. ses ./src/tame-domains.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let TypeError,globalThis,getOwnPropertyDescriptor,defineProperty;$h͏_imports([["./commons.js", [["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["globalThis",[$h͏_a => (globalThis = $h͏_a)]],["getOwnPropertyDescriptor",[$h͏_a => (getOwnPropertyDescriptor = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]]]]]);Object.defineProperty(tameDomains,'name',{value:"tameDomains"});$h͏_once.tameDomains(tameDomains);








       function tameDomains(domainTaming = 'safe') {
  if (domainTaming === 'unsafe') {
    return;
  }

  // Protect against the hazard presented by Node.js domains.
  const globalProcess = globalThis.process || undefined;
  if (typeof globalProcess === 'object') {
    // Check whether domains were initialized.
    const domainDescriptor = getOwnPropertyDescriptor(globalProcess, 'domain');
    if (domainDescriptor !== undefined && domainDescriptor.get !== undefined) {
      // The domain descriptor on Node.js initially has value: null, which
      // becomes a get, set pair after domains initialize.
      // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_NO_DOMAINS.md
      throw TypeError(
        `SES failed to lockdown, Node.js domains have been initialized (SES_NO_DOMAINS)`,
      );
    }
    // Prevent domains from initializing.
    // This is clunky because the exception thrown from the domains package does
    // not direct the user's gaze toward a knowledge base about the problem.
    // The domain module merely throws an exception when it attempts to define
    // the domain property of the process global during its initialization.
    // We have no better recourse because Node.js uses defineProperty too.
    defineProperty(globalProcess, 'domain', {
      value: null,
      configurable: false,
      writable: false,
      enumerable: false,
    });
  }
}
})()
,
// === 39. ses ./src/tame-module-source.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let functionPrototype,getPrototypeOf,globalThis,objectPrototype,setPrototypeOf;$h͏_imports([["./commons.js", [["functionPrototype",[$h͏_a => (functionPrototype = $h͏_a)]],["getPrototypeOf",[$h͏_a => (getPrototypeOf = $h͏_a)]],["globalThis",[$h͏_a => (globalThis = $h͏_a)]],["objectPrototype",[$h͏_a => (objectPrototype = $h͏_a)]],["setPrototypeOf",[$h͏_a => (setPrototypeOf = $h͏_a)]]]]]);







       const tameModuleSource = () => {
  const newIntrinsics = {};

  const ModuleSource = globalThis.ModuleSource;
  if (ModuleSource !== undefined) {
    newIntrinsics.ModuleSource = ModuleSource;

    // We introduce ModuleSource.[[Proto]] === AbstractModuleSource
    // and ModuleSource.prototype.[[Proto]] === AbstractModuleSource.prototype
    // if that layer is absent because the permitting system can more
    // gracefully tolerate the absence of an expected prototype than the
    // presence of an unexpected prototype,.
    function AbstractModuleSource() {
      // no-op safe to super()
    }

    const ModuleSourceProto = getPrototypeOf(ModuleSource);
    if (ModuleSourceProto === functionPrototype) {
      setPrototypeOf(ModuleSource, AbstractModuleSource);
      newIntrinsics['%AbstractModuleSource%'] = AbstractModuleSource;
      newIntrinsics['%AbstractModuleSourcePrototype%'] =
        AbstractModuleSource.prototype;
    } else {
      newIntrinsics['%AbstractModuleSource%'] = ModuleSourceProto;
      newIntrinsics['%AbstractModuleSourcePrototype%'] =
        ModuleSourceProto.prototype;
    }

    const ModuleSourcePrototype = ModuleSource.prototype;
    if (ModuleSourcePrototype !== undefined) {
      newIntrinsics['%ModuleSourcePrototype%'] = ModuleSourcePrototype;

      // ModuleSource.prototype.__proto__ should be the
      // AbstractModuleSource.prototype.
      const ModuleSourcePrototypeProto = getPrototypeOf(ModuleSourcePrototype);
      if (ModuleSourcePrototypeProto === objectPrototype) {
        setPrototypeOf(ModuleSource.prototype, AbstractModuleSource.prototype);
      }
    }
  }

  return newIntrinsics;
};$h͏_once.tameModuleSource(tameModuleSource);
})()
,
// === 40. ses ./src/error/console.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let WeakSet,arrayFilter,arrayFlatMap,arrayMap,arrayPop,arrayPush,defineProperty,freeze,fromEntries,isError,stringEndsWith,stringIncludes,stringSplit,weaksetAdd,weaksetHas;$h͏_imports([["../commons.js", [["WeakSet",[$h͏_a => (WeakSet = $h͏_a)]],["arrayFilter",[$h͏_a => (arrayFilter = $h͏_a)]],["arrayFlatMap",[$h͏_a => (arrayFlatMap = $h͏_a)]],["arrayMap",[$h͏_a => (arrayMap = $h͏_a)]],["arrayPop",[$h͏_a => (arrayPop = $h͏_a)]],["arrayPush",[$h͏_a => (arrayPush = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["fromEntries",[$h͏_a => (fromEntries = $h͏_a)]],["isError",[$h͏_a => (isError = $h͏_a)]],["stringEndsWith",[$h͏_a => (stringEndsWith = $h͏_a)]],["stringIncludes",[$h͏_a => (stringIncludes = $h͏_a)]],["stringSplit",[$h͏_a => (stringSplit = $h͏_a)]],["weaksetAdd",[$h͏_a => (weaksetAdd = $h͏_a)]],["weaksetHas",[$h͏_a => (weaksetHas = $h͏_a)]]]]]);
























/**
 * @import {FilterConsole, LogSeverity, VirtualConsole} from './types.js'
 * @import {ErrorInfo, ErrorInfoKind, LogRecord, NoteCallback, LoggedErrorHandler, MakeCausalConsole, MakeLoggingConsoleKit} from "./internal-types.js";
 */

/**
 * Explicitly set a function's name, supporting use of arrow functions for which
 * source text doesn't include a name and no initial name is set by
 * NamedEvaluation
 * https://tc39.es/ecma262/multipage/syntax-directed-operations.html#sec-runtime-semantics-namedevaluation
 * Instead, we hope that tooling uses only the explicit `name` property.
 *
 * @template {Function} F
 * @param {string} name
 * @param {F} fn
 * @returns {F}
 */
const defineName = (name, fn) => defineProperty(fn, 'name', { value: name });

// For our internal debugging purposes, uncomment
// const internalDebugConsole = console;

// The permitted console methods, from:
// Whatwg "living standard" https://console.spec.whatwg.org/
// Node https://nodejs.org/dist/latest-v14.x/docs/api/console.html
// MDN https://developer.mozilla.org/en-US/docs/Web/API/Console_API
// TypeScript https://openstapps.gitlab.io/projectmanagement/interfaces/_node_modules__types_node_globals_d_.console.html
// Chrome https://developers.google.com/web/tools/chrome-devtools/console/api

// All console level methods have parameters (fmt?, ...args)
// where the argument sequence `fmt?, ...args` formats args according to
// fmt if fmt is a format string. Otherwise, it just renders them all as values
// separated by spaces.
// https://console.spec.whatwg.org/#formatter
// https://nodejs.org/docs/latest/api/util.html#util_util_format_format_args

// For the causal console, all occurrences of `fmt, ...args` or `...args` by
// itself must check for the presence of an error to ask the
// `loggedErrorHandler` to handle.
// In theory we should do a deep inspection to detect for example an array
// containing an error. We currently do not detect these and may never.

/** @typedef {keyof VirtualConsole | 'profile' | 'profileEnd'} ConsoleProps */

/**
 * Those console methods whose actual parameters are `(fmt?, ...args)`
 * even if their TypeScript types claim otherwise.
 *
 * Each is paired with what we consider to be their log severity level.
 * This is the same as the log severity of these on other
 * platform console implementations when they all agree.
 *
 * @type {readonly [ConsoleProps, LogSeverity | undefined][]}
 */
       const consoleLevelMethods = freeze([
  ['debug', 'debug'], // (fmt?, ...args) verbose level on Chrome
  ['log', 'log'], // (fmt?, ...args) info level on Chrome
  ['info', 'info'], // (fmt?, ...args)
  ['warn', 'warn'], // (fmt?, ...args)
  ['error', 'error'], // (fmt?, ...args)

  ['trace', 'log'], // (fmt?, ...args)
  ['dirxml', 'log'], // (fmt?, ...args)          but TS typed (...data)
  ['group', 'log'], // (fmt?, ...args)           but TS typed (...label)
  ['groupCollapsed', 'log']  // (fmt?, ...args)  but TS typed (...label)
]);

/**
 * Those console methods other than those already enumerated by
 * `consoleLevelMethods`.
 *
 * Each is paired with what we consider to be their log severity level.
 * This is the same as the log severity of these on other
 * platform console implementations when they all agree.
 *
 * @type {readonly [ConsoleProps, LogSeverity | undefined][]}
 */$h͏_once.consoleLevelMethods(consoleLevelMethods);
       const consoleOtherMethods = freeze([
  ['assert', 'error'], // (value, fmt?, ...args)
  ['timeLog', 'log'], // (label?, ...args) no fmt string

  // Insensitive to whether any argument is an error. All arguments can pass
  // thru to baseConsole as is.
  ['clear', undefined], // ()
  ['count', 'info'], // (label?)
  ['countReset', undefined], // (label?)
  ['dir', 'log'], // (item, options?)
  ['groupEnd', 'log'], // ()
  // In theory tabular data may be or contain an error. However, we currently
  // do not detect these and may never.
  ['table', 'log'], // (tabularData, properties?)
  ['time', 'info'], // (label?)
  ['timeEnd', 'info'], // (label?)

  // Node Inspector only, MDN, and TypeScript, but not whatwg
  ['profile', undefined], // (label?)
  ['profileEnd', undefined], // (label?)
  ['timeStamp', undefined]  // (label?)
]);

/** @type {readonly [ConsoleProps, LogSeverity | undefined][]} */$h͏_once.consoleOtherMethods(consoleOtherMethods);
const consoleMethodPermits = freeze([
  ...consoleLevelMethods,
  ...consoleOtherMethods,
]);

/**
 * consoleOmittedProperties is currently unused. I record and maintain it here
 * with the intention that it be treated like the `false` entries in the main
 * SES permits: that seeing these on the original console is expected, but
 * seeing anything else that's outside the permits is surprising and should
 * provide a diagnostic.
 *
 * const consoleOmittedProperties = freeze([
 *   'memory', // Chrome
 *   'exception', // FF, MDN
 *   '_ignoreErrors', // Node
 *   '_stderr', // Node
 *   '_stderrErrorHandler', // Node
 *   '_stdout', // Node
 *   '_stdoutErrorHandler', // Node
 *   '_times', // Node
 *   'context', // Chrome, Node
 *   'record', // Safari
 *   'recordEnd', // Safari
 *
 *   'screenshot', // Safari
 *   // Symbols
 *   '@@toStringTag', // Chrome: "Object", Safari: "Console"
 *   // A variety of other symbols also seen on Node
 * ]);
 */

// //////////////////////////// Logging Console ////////////////////////////////

/** @type {MakeLoggingConsoleKit} */
       const makeLoggingConsoleKit = (
  loggedErrorHandler,
  { shouldResetForDebugging = false } = {},
) => {
  if (shouldResetForDebugging) {
    // eslint-disable-next-line @endo/no-polymorphic-call
    loggedErrorHandler.resetErrorTagNum();
  }

  // Not frozen!
  let logArray = [];

  const loggingConsole = fromEntries(
    arrayMap(consoleMethodPermits, ([name, _]) => {
      /**
       * @param {...any} args
       */
      const method = defineName(name, (...args) => {
        arrayPush(logArray, [name, ...args]);
      });
      return [name, freeze(method)];
    }),
  );
  freeze(loggingConsole);

  const takeLog = () => {
    const result = freeze(logArray);
    logArray = [];
    return result;
  };
  freeze(takeLog);

  const typedLoggingConsole = /** @type {VirtualConsole} */ (loggingConsole);

  return freeze({ loggingConsole: typedLoggingConsole, takeLog });
};$h͏_once.makeLoggingConsoleKit(makeLoggingConsoleKit);
freeze(makeLoggingConsoleKit);

/**
 * Makes the same calls on a `baseConsole` that were made on a
 * `loggingConsole` to produce this `log`. In this way, a logging console
 * can be used as a buffer to delay the application of these calls to a
 * `baseConsole`.
 *
 * @param {LogRecord[]} log
 * @param {VirtualConsole} baseConsole
 */
       const pumpLogToConsole = (log, baseConsole) => {
  for (const [name, ...args] of log) {
    // eslint-disable-next-line @endo/no-polymorphic-call
    baseConsole[name](...args);
  }
};
// //////////////////////////// Causal Console /////////////////////////////////

/** @type {ErrorInfo} */$h͏_once.pumpLogToConsole(pumpLogToConsole);
const ErrorInfo = {
  NOTE: 'ERROR_NOTE:',
  MESSAGE: 'ERROR_MESSAGE:',
  CAUSE: 'cause:',
  ERRORS: 'errors:',
};
freeze(ErrorInfo);

/** @type {MakeCausalConsole} */
       const makeCausalConsole = (baseConsole, loggedErrorHandler) => {
  if (!baseConsole) {
    return undefined;
  }

  const { getStackString, tagError, takeMessageLogArgs, takeNoteLogArgsArray } =
    loggedErrorHandler;

  /**
   * @param {ReadonlyArray<any>} logArgs
   * @param {Array<any>} subErrorsSink
   * @returns {any}
   */
  const extractErrorArgs = (logArgs, subErrorsSink) => {
    const argTags = arrayMap(logArgs, arg => {
      if (isError(arg)) {
        arrayPush(subErrorsSink, arg);
        return `(${tagError(arg)})`;
      }
      return arg;
    });
    return argTags;
  };

  /**
   * @param {LogSeverity} severity
   * @param {Error} error
   * @param {ErrorInfoKind} kind
   * @param {readonly any[]} logArgs
   * @param {Array<Error>} subErrorsSink
   */
  const logErrorInfo = (severity, error, kind, logArgs, subErrorsSink) => {
    const errorTag = tagError(error);
    const errorName =
      kind === ErrorInfo.MESSAGE ? `${errorTag}:` : `${errorTag} ${kind}`;
    const argTags = extractErrorArgs(logArgs, subErrorsSink);
    // eslint-disable-next-line @endo/no-polymorphic-call
    baseConsole[severity](errorName, ...argTags);
  };

  /**
   * Logs the `subErrors` within a group name mentioning `optTag`.
   *
   * @param {LogSeverity} severity
   * @param {Error[]} subErrors
   * @param {string | undefined} optTag
   * @returns {void}
   */
  const logSubErrors = (severity, subErrors, optTag = undefined) => {
    if (subErrors.length === 0) {
      return;
    }
    if (subErrors.length === 1 && optTag === undefined) {
      // eslint-disable-next-line no-use-before-define
      logError(severity, subErrors[0]);
      return;
    }
    let label;
    if (subErrors.length === 1) {
      label = `Nested error`;
    } else {
      label = `Nested ${subErrors.length} errors`;
    }
    if (optTag !== undefined) {
      label = `${label} under ${optTag}`;
    }
    // eslint-disable-next-line @endo/no-polymorphic-call
    baseConsole.group(label);
    try {
      for (const subError of subErrors) {
        // eslint-disable-next-line no-use-before-define
        logError(severity, subError);
      }
    } finally {
      if (baseConsole.groupEnd) {
        // eslint-disable-next-line @endo/no-polymorphic-call
        baseConsole.groupEnd();
      }
    }
  };

  const errorsLogged = new WeakSet();

  /** @type {(severity: LogSeverity) => NoteCallback} */
  const makeNoteCallback = severity => (error, noteLogArgs) => {
    const subErrors = [];
    // Annotation arrived after the error has already been logged,
    // so just log the annotation immediately, rather than remembering it.
    logErrorInfo(severity, error, ErrorInfo.NOTE, noteLogArgs, subErrors);
    logSubErrors(severity, subErrors, tagError(error));
  };

  /**
   * @param {LogSeverity} severity
   * @param {Error} error
   */
  const logError = (severity, error) => {
    if (weaksetHas(errorsLogged, error)) {
      return;
    }
    const errorTag = tagError(error);
    weaksetAdd(errorsLogged, error);
    const subErrors = [];
    const messageLogArgs = takeMessageLogArgs(error);
    const noteLogArgsArray = takeNoteLogArgsArray(
      error,
      makeNoteCallback(severity),
    );
    // Show the error's most informative error message
    if (messageLogArgs === undefined) {
      // If there is no message log args, then just show the message that
      // the error itself carries.
      // eslint-disable-next-line @endo/no-polymorphic-call
      baseConsole[severity](`${errorTag}:`, error.message);
    } else {
      // If there is one, we take it to be strictly more informative than the
      // message string carried by the error, so show it *instead*.
      logErrorInfo(
        severity,
        error,
        ErrorInfo.MESSAGE,
        messageLogArgs,
        subErrors,
      );
    }
    // After the message but before any other annotations, show the stack.
    let stackString = getStackString(error);
    if (
      typeof stackString === 'string' &&
      stackString.length >= 1 &&
      !stringEndsWith(stackString, '\n')
    ) {
      stackString += '\n';
    }
    // eslint-disable-next-line @endo/no-polymorphic-call
    baseConsole[severity](stackString);
    // Show the other annotations on error
    if (error.cause) {
      logErrorInfo(severity, error, ErrorInfo.CAUSE, [error.cause], subErrors);
    }
    // @ts-expect-error AggregateError has an `errors` property.
    if (error.errors) {
      // @ts-expect-error AggregateError has an `errors` property.
      logErrorInfo(severity, error, ErrorInfo.ERRORS, error.errors, subErrors);
    }
    for (const noteLogArgs of noteLogArgsArray) {
      logErrorInfo(severity, error, ErrorInfo.NOTE, noteLogArgs, subErrors);
    }
    // explain all the errors seen in the messages already emitted.
    logSubErrors(severity, subErrors, errorTag);
  };

  const levelMethods = arrayMap(consoleLevelMethods, ([level, _]) => {
    /**
     * @param {...any} logArgs
     */
    const levelMethod = defineName(level, (...logArgs) => {
      const subErrors = [];
      const argTags = extractErrorArgs(logArgs, subErrors);
      if (baseConsole[level]) {
        // eslint-disable-next-line @endo/no-polymorphic-call
        baseConsole[level](...argTags);
      }
      // @ts-expect-error ConsoleProp vs LogSeverity mismatch
      logSubErrors(level, subErrors);
    });
    return [level, freeze(levelMethod)];
  });
  const otherMethodNames = arrayFilter(
    consoleOtherMethods,
    ([name, _]) => name in baseConsole,
  );
  const otherMethods = arrayMap(otherMethodNames, ([name, _]) => {
    /**
     * @param {...any} args
     */
    const otherMethod = defineName(name, (...args) => {
      // @ts-ignore
      // eslint-disable-next-line @endo/no-polymorphic-call
      baseConsole[name](...args);
      return undefined;
    });
    return [name, freeze(otherMethod)];
  });

  const causalConsole = fromEntries([...levelMethods, ...otherMethods]);
  return /** @type {VirtualConsole} */ (freeze(causalConsole));
};$h͏_once.makeCausalConsole(makeCausalConsole);
freeze(makeCausalConsole);

/**
 * @typedef {(...args: unknown[]) => void} Logger
 */

/**
 * This is a rather horrible kludge to indent the output to a logger in
 * the case where some arguments are strings containing newlines. Part of
 * the problem is that console-like loggers, including the one in ava,
 * join the string arguments of the log message with a space.
 * Because of this, there's an extra space at the beginning of each of
 * the split lines. So this kludge compensated by putting an extra empty
 * string at the beginning, so that the logger will add the same extra
 * joiner.
 * TODO: Fix this horrible kludge, and indent in a sane manner.
 *
 * @param {string} str
 * @param {string} sep
 * @param {string[]} indents
 * @returns {string[]}
 */
const indentAfterAllSeps = (str, sep, indents) => {
  const [firstLine, ...restLines] = stringSplit(str, sep);
  const indentedRest = arrayFlatMap(restLines, line => [sep, ...indents, line]);
  return ['', firstLine, ...indentedRest];
};

/**
 * @param {LoggedErrorHandler} loggedErrorHandler
 */
       const defineCausalConsoleFromLogger = loggedErrorHandler => {
  /**
   * Implement the `VirtualConsole` API badly by turning all calls into
   * calls on `tlogger`. We need to do this to have `console` logging
   * turn into calls to Ava's `t.log`, so these console log messages
   * are output in the right place.
   *
   * @param {Logger} tlogger
   * @returns {VirtualConsole}
   */
  const makeCausalConsoleFromLogger = tlogger => {
    const indents = [];
    const logWithIndent = (...args) => {
      if (indents.length > 0) {
        args = arrayFlatMap(args, arg =>
          typeof arg === 'string' && stringIncludes(arg, '\n')
            ? indentAfterAllSeps(arg, '\n', indents)
            : [arg],
        );
        args = [...indents, ...args];
      }
      return tlogger(...args);
    };

    const baseConsole = fromEntries([
      ...arrayMap(consoleLevelMethods, ([name]) => [
        name,
        defineName(name, (...args) => logWithIndent(...args)),
      ]),
      ...arrayMap(consoleOtherMethods, ([name]) => [
        name,
        defineName(name, (...args) => logWithIndent(name, ...args)),
      ]),
    ]);
    // https://console.spec.whatwg.org/#grouping
    for (const name of ['group', 'groupCollapsed']) {
      if (baseConsole[name]) {
        baseConsole[name] = defineName(name, (...args) => {
          if (args.length >= 1) {
            // Prefix the logged data with "group" or "groupCollapsed".
            logWithIndent(...args);
          }
          // A single space is enough;
          // the host console will separate them with additional spaces.
          arrayPush(indents, ' ');
        });
      } else {
        baseConsole[name] = defineName(name, () => {});
      }
    }
    baseConsole.groupEnd = defineName(
      'groupEnd',
      baseConsole.groupEnd
        ? (...args) => {
            arrayPop(indents);
          }
        : () => {},
    );
    harden(baseConsole);
    const causalConsole = makeCausalConsole(
      /** @type {VirtualConsole} */ (baseConsole),
      loggedErrorHandler,
    );
    return /** @type {VirtualConsole} */ (causalConsole);
  };
  return freeze(makeCausalConsoleFromLogger);
};$h͏_once.defineCausalConsoleFromLogger(defineCausalConsoleFromLogger);
freeze(defineCausalConsoleFromLogger);

// ///////////////////////// Filter Console ////////////////////////////////////

/** @type {FilterConsole} */
       const filterConsole = (baseConsole, filter, _topic = undefined) => {
  // TODO do something with optional topic string
  const methodPermits = arrayFilter(
    consoleMethodPermits,
    ([name, _]) => name in baseConsole,
  );
  const methods = arrayMap(methodPermits, ([name, severity]) => {
    /**
     * @param {...any} args
     */
    const method = defineName(name, (...args) => {
      // eslint-disable-next-line @endo/no-polymorphic-call
      if (severity === undefined || filter.canLog(severity)) {
        // @ts-ignore
        // eslint-disable-next-line @endo/no-polymorphic-call
        baseConsole[name](...args);
      }
    });
    return [name, freeze(method)];
  });
  const filteringConsole = fromEntries(methods);
  return /** @type {VirtualConsole} */ (freeze(filteringConsole));
};$h͏_once.filterConsole(filterConsole);
freeze(filterConsole);
})()
,
// === 41. ses ./src/error/unhandled-rejection.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let FinalizationRegistry,Map,mapGet,mapDelete,WeakMap,mapSet,finalizationRegistryRegister,weakmapSet,weakmapGet,mapEntries,mapHas;$h͏_imports([["../commons.js", [["FinalizationRegistry",[$h͏_a => (FinalizationRegistry = $h͏_a)]],["Map",[$h͏_a => (Map = $h͏_a)]],["mapGet",[$h͏_a => (mapGet = $h͏_a)]],["mapDelete",[$h͏_a => (mapDelete = $h͏_a)]],["WeakMap",[$h͏_a => (WeakMap = $h͏_a)]],["mapSet",[$h͏_a => (mapSet = $h͏_a)]],["finalizationRegistryRegister",[$h͏_a => (finalizationRegistryRegister = $h͏_a)]],["weakmapSet",[$h͏_a => (weakmapSet = $h͏_a)]],["weakmapGet",[$h͏_a => (weakmapGet = $h͏_a)]],["mapEntries",[$h͏_a => (mapEntries = $h͏_a)]],["mapHas",[$h͏_a => (mapHas = $h͏_a)]]]]]);














/**
 * Create rejection-tracking machinery compatible with Node.js and browsers.
 *
 * Note that modern browsers *prevent* access to the 'unhandledrejection' and
 * 'rejectionhandled' events needed:
 * - in cross-origin mode, like when served from file://
 * - in the browser console (interactively typed-in code)
 * - in the debugger
 *
 * Then, they just look like: `Uncaught (in promise) Error: ...` and don't
 * implement the machinery.
 *
 * The solution is to serve your web page from an http:// or https:// web server
 * and execute actual code.
 *
 * @param {(reason: unknown) => void} reportReason report the reason for an
 * unhandled rejection.
 */
       const makeRejectionHandlers = reportReason => {
  if (FinalizationRegistry === undefined) {
    return undefined;
  }

  /** @typedef {number} ReasonId */
  let lastReasonId = 0;

  /** @type {Map<ReasonId, unknown>} */
  const idToReason = new Map();

  /** @type {(() => void) | undefined} */
  let cancelChecking;

  const removeReasonId = reasonId => {
    mapDelete(idToReason, reasonId);
    if (cancelChecking && idToReason.size === 0) {
      // No more unhandled rejections to check, just cancel the check.
      cancelChecking();
      cancelChecking = undefined;
    }
  };

  /** @type {WeakMap<Promise, ReasonId>} */
  const promiseToReasonId = new WeakMap();

  /**
   * Clean up and report the reason for a GCed unhandled rejection.
   *
   * @param {ReasonId} heldReasonId
   */
  const finalizeDroppedPromise = heldReasonId => {
    if (mapHas(idToReason, heldReasonId)) {
      const reason = mapGet(idToReason, heldReasonId);
      removeReasonId(heldReasonId);
      reportReason(reason);
    }
  };

  /** @type {FinalizationRegistry<ReasonId>} */
  const promiseToReason = new FinalizationRegistry(finalizeDroppedPromise);

  /**
   * Track a rejected promise and its corresponding reason if there is no
   * rejection handler synchronously attached.
   *
   * @param {unknown} reason
   * @param {Promise} pr
   */
  const unhandledRejectionHandler = (reason, pr) => {
    lastReasonId += 1;
    const reasonId = lastReasonId;

    // Update bookkeeping.
    mapSet(idToReason, reasonId, reason);
    weakmapSet(promiseToReasonId, pr, reasonId);
    finalizationRegistryRegister(promiseToReason, pr, reasonId, pr);
  };

  /**
   * Deal with the addition of a handler to a previously rejected promise.
   *
   * Just remove it from our list.  Let the FinalizationRegistry or
   * processTermination report any GCed unhandled rejected promises.
   *
   * @param {Promise} pr
   */
  const rejectionHandledHandler = pr => {
    const reasonId = weakmapGet(promiseToReasonId, pr);
    removeReasonId(reasonId);
  };

  /**
   * Report all the unhandled rejections, now that we are abruptly terminating
   * the agent cluster.
   */
  const processTerminationHandler = () => {
    for (const [reasonId, reason] of mapEntries(idToReason)) {
      removeReasonId(reasonId);
      reportReason(reason);
    }
  };

  return {
    rejectionHandledHandler,
    unhandledRejectionHandler,
    processTerminationHandler,
  };
};$h͏_once.makeRejectionHandlers(makeRejectionHandlers);
})()
,
// === 42. ses ./src/error/tame-console.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let TypeError,apply,defineProperty,freeze,globalThis,defaultHandler,makeCausalConsole,makeRejectionHandlers;$h͏_imports([["../commons.js", [["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["apply",[$h͏_a => (apply = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["globalThis",[$h͏_a => (globalThis = $h͏_a)]]]],["./assert.js", [["loggedErrorHandler",[$h͏_a => (defaultHandler = $h͏_a)]]]],["./console.js", [["makeCausalConsole",[$h͏_a => (makeCausalConsole = $h͏_a)]]]],["./unhandled-rejection.js", [["makeRejectionHandlers",[$h͏_a => (makeRejectionHandlers = $h͏_a)]]]]]);













/**
 * @import {VirtualConsole} from './types.js'
 * @import {GetStackString} from './internal-types.js';
 */

const failFast = message => {
  throw TypeError(message);
};

const wrapLogger = (logger, thisArg) =>
  freeze((...args) => apply(logger, thisArg, args));

/**
 * Wrap console unless suppressed.
 * At the moment, the console is considered a host power in the start
 * compartment, and not a primordial. Hence it is absent from the whilelist
 * and bypasses the intrinsicsCollector.
 *
 * @param {"safe" | "unsafe"} consoleTaming
 * @param {"platform" | "exit" | "abort" | "report" | "none"} [errorTrapping]
 * @param {"report" | "none"} [unhandledRejectionTrapping]
 * @param {GetStackString=} optGetStackString
 */
       const tameConsole = (
  consoleTaming = 'safe',
  errorTrapping = 'platform',
  unhandledRejectionTrapping = 'report',
  optGetStackString = undefined,
) => {
  let loggedErrorHandler;
  if (optGetStackString === undefined) {
    loggedErrorHandler = defaultHandler;
  } else {
    loggedErrorHandler = {
      ...defaultHandler,
      getStackString: optGetStackString,
    };
  }

  // eslint-disable-next-line no-restricted-globals
  const originalConsole = /** @type {VirtualConsole} */ (
    // eslint-disable-next-line no-nested-ternary
    typeof globalThis.console !== 'undefined'
      ? globalThis.console
      : typeof globalThis.print === 'function'
        ? // Make a good-enough console for eshost (including only functions that
          // log at a specific level with no special argument interpretation).
          // https://console.spec.whatwg.org/#logging
          (p => freeze({ debug: p, log: p, info: p, warn: p, error: p }))(
            // eslint-disable-next-line no-undef
            wrapLogger(globalThis.print),
          )
        : undefined
  );

  // Upgrade a log-only console (as in `eshost -h SpiderMonkey`).
  if (originalConsole && originalConsole.log) {
    for (const methodName of ['warn', 'error']) {
      if (!originalConsole[methodName]) {
        defineProperty(originalConsole, methodName, {
          value: wrapLogger(originalConsole.log, originalConsole),
        });
      }
    }
  }

  const ourConsole = /** @type {VirtualConsole} */ (
    consoleTaming === 'unsafe'
      ? originalConsole
      : makeCausalConsole(originalConsole, loggedErrorHandler)
  );

  // Attach platform-specific error traps such that any error that gets thrown
  // at top-of-turn (the bottom of stack) will get logged by our causal
  // console, revealing the diagnostic information associated with the error,
  // including the stack from when the error was created.

  // In the following Node.js and web browser cases, `process` and `window` are
  // spelled as `globalThis` properties to avoid the overweaning gaze of
  // Parcel, which dutifully installs an unnecessary `process` shim if we ever
  // utter that. That unnecessary shim forces the whole bundle into sloppy mode,
  // which in turn breaks SES's strict mode invariant.

  // Disable the polymorphic check for the rest of this file.  It's too noisy
  // when dealing with platform APIs.
  /* eslint-disable @endo/no-polymorphic-call */

  // Node.js
  const globalProcess = globalThis.process || undefined;
  if (
    errorTrapping !== 'none' &&
    typeof globalProcess === 'object' &&
    typeof globalProcess.on === 'function'
  ) {
    let terminate;
    if (errorTrapping === 'platform' || errorTrapping === 'exit') {
      const { exit } = globalProcess;
      // If there is a function-valued process.on but no function-valued process.exit,
      // fail early without caring whether errorTrapping is "platform" only by default.
      typeof exit === 'function' || failFast('missing process.exit');
      terminate = () => exit(globalProcess.exitCode || -1);
    } else if (errorTrapping === 'abort') {
      terminate = globalProcess.abort;
      typeof terminate === 'function' || failFast('missing process.abort');
    }

    globalProcess.on('uncaughtException', error => {
      // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNCAUGHT_EXCEPTION.md
      ourConsole.error('SES_UNCAUGHT_EXCEPTION:', error);
      if (terminate) {
        terminate();
      }
    });
  }
  if (
    unhandledRejectionTrapping !== 'none' &&
    typeof globalProcess === 'object' &&
    typeof globalProcess.on === 'function'
  ) {
    const handleRejection = reason => {
      // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNHANDLED_REJECTION.md
      ourConsole.error('SES_UNHANDLED_REJECTION:', reason);
      // 'platform' and 'report' just log the reason.
    };
    // Maybe track unhandled promise rejections.
    const h = makeRejectionHandlers(handleRejection);
    if (h) {
      // Rejection handlers are supported.
      globalProcess.on('unhandledRejection', h.unhandledRejectionHandler);
      globalProcess.on('rejectionHandled', h.rejectionHandledHandler);
      globalProcess.on('exit', h.processTerminationHandler);
    }
  }

  // Browser
  const globalWindow = globalThis.window || undefined;
  if (
    errorTrapping !== 'none' &&
    typeof globalWindow === 'object' &&
    typeof globalWindow.addEventListener === 'function'
  ) {
    globalWindow.addEventListener('error', event => {
      event.preventDefault();
      // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNCAUGHT_EXCEPTION.md
      ourConsole.error('SES_UNCAUGHT_EXCEPTION:', event.error);
      // 'platform' and 'report' just log the reason.
      if (errorTrapping === 'exit' || errorTrapping === 'abort') {
        globalWindow.location.href = `about:blank`;
      }
    });
  }
  if (
    unhandledRejectionTrapping !== 'none' &&
    typeof globalWindow === 'object' &&
    typeof globalWindow.addEventListener === 'function'
  ) {
    const handleRejection = reason => {
      // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNHANDLED_REJECTION.md
      ourConsole.error('SES_UNHANDLED_REJECTION:', reason);
    };

    const h = makeRejectionHandlers(handleRejection);
    if (h) {
      // Rejection handlers are supported.
      globalWindow.addEventListener('unhandledrejection', event => {
        event.preventDefault();
        h.unhandledRejectionHandler(event.reason, event.promise);
      });

      globalWindow.addEventListener('rejectionhandled', event => {
        event.preventDefault();
        h.rejectionHandledHandler(event.promise);
      });

      globalWindow.addEventListener('beforeunload', _event => {
        h.processTerminationHandler();
      });
    }
  }
  /* eslint-enable @endo/no-polymorphic-call */

  return { console: ourConsole };
};$h͏_once.tameConsole(tameConsole);
})()
,
// === 43. ses ./src/error/tame-v8-error-constructor.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let WeakMap,WeakSet,apply,arrayFilter,arrayJoin,arrayMap,arraySlice,create,defineProperties,fromEntries,reflectSet,regexpExec,weakmapGet,weakmapSet,weaksetAdd,weaksetHas,TypeError;$h͏_imports([["../commons.js", [["WeakMap",[$h͏_a => (WeakMap = $h͏_a)]],["WeakSet",[$h͏_a => (WeakSet = $h͏_a)]],["apply",[$h͏_a => (apply = $h͏_a)]],["arrayFilter",[$h͏_a => (arrayFilter = $h͏_a)]],["arrayJoin",[$h͏_a => (arrayJoin = $h͏_a)]],["arrayMap",[$h͏_a => (arrayMap = $h͏_a)]],["arraySlice",[$h͏_a => (arraySlice = $h͏_a)]],["create",[$h͏_a => (create = $h͏_a)]],["defineProperties",[$h͏_a => (defineProperties = $h͏_a)]],["fromEntries",[$h͏_a => (fromEntries = $h͏_a)]],["reflectSet",[$h͏_a => (reflectSet = $h͏_a)]],["regexpExec",[$h͏_a => (regexpExec = $h͏_a)]],["weakmapGet",[$h͏_a => (weakmapGet = $h͏_a)]],["weakmapSet",[$h͏_a => (weakmapSet = $h͏_a)]],["weaksetAdd",[$h͏_a => (weaksetAdd = $h͏_a)]],["weaksetHas",[$h͏_a => (weaksetHas = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]]]]]);



















// Permit names from https://v8.dev/docs/stack-trace-api
// Permiting only the names used by error-stack-shim/src/v8StackFrames
// callSiteToFrame to shim the error stack proposal.
const safeV8CallSiteMethodNames = [
  // suppress 'getThis' definitely
  'getTypeName',
  // suppress 'getFunction' definitely
  'getFunctionName',
  'getMethodName',
  'getFileName',
  'getLineNumber',
  'getColumnNumber',
  'getEvalOrigin',
  'isToplevel',
  'isEval',
  'isNative',
  'isConstructor',
  'isAsync',
  // suppress 'isPromiseAll' for now
  // suppress 'getPromiseIndex' for now

  // Additional names found by experiment, absent from
  // https://v8.dev/docs/stack-trace-api
  'getPosition',
  'getScriptNameOrSourceURL',

  'toString'  // TODO replace to use only permitted info
];

// TODO this is a ridiculously expensive way to attenuate callsites.
// Before that matters, we should switch to a reasonable representation.
const safeV8CallSiteFacet = callSite => {
  const methodEntry = name => {
    const method = callSite[name];
    return [name, () => apply(method, callSite, [])];
  };
  const o = fromEntries(arrayMap(safeV8CallSiteMethodNames, methodEntry));
  return create(o, {});
};

const safeV8SST = sst => arrayMap(sst, safeV8CallSiteFacet);

// If it has `/node_modules/` anywhere in it, on Node it is likely
// to be a dependent package of the current package, and so to
// be an infrastructure frame to be dropped from concise stack traces.
const FILENAME_NODE_DEPENDENTS_CENSOR = /\/node_modules\//;

// If it begins with `internal/` or `node:internal` then it is likely
// part of the node infrustructre itself, to be dropped from concise
// stack traces.
const FILENAME_NODE_INTERNALS_CENSOR = /^(?:node:)?internal\//;

// Frames within SES `assert.js` should be dropped from concise stack traces, as
// these are just steps towards creating the error object in question.
const FILENAME_ASSERT_CENSOR = /\/packages\/ses\/src\/error\/assert\.js$/;

// Frames within the `eventual-send` shim should be dropped so that concise
// deep stacks omit the internals of the eventual-sending mechanism causing
// asynchronous messages to be sent.
// Note that the eventual-send package will move from agoric-sdk to
// Endo, so this rule will be of general interest.
const FILENAME_EVENTUAL_SEND_CENSOR = /\/packages\/eventual-send\/src\//;

// Frames within the `ses-ava` package should be dropped from concise stack
// traces, as they just support exposing error details to AVA.
const FILENAME_SES_AVA_CENSOR = /\/packages\/ses-ava\/src\/ses-ava-test\.js$/;

// Any stack frame whose `fileName` matches any of these censor patterns
// will be omitted from concise stacks.
// TODO Enable users to configure FILENAME_CENSORS via `lockdown` options.
const FILENAME_CENSORS = [
  FILENAME_NODE_DEPENDENTS_CENSOR,
  FILENAME_NODE_INTERNALS_CENSOR,
  FILENAME_ASSERT_CENSOR,
  FILENAME_EVENTUAL_SEND_CENSOR,
  FILENAME_SES_AVA_CENSOR,
];

// Should a stack frame with this as its fileName be included in a concise
// stack trace?
// Exported only so it can be unit tested.
// TODO Move so that it applies not just to v8.
       const filterFileName = fileName => {
  if (fileName === null) {
    // Seems to suppress builtins like `Array.every (<anonymous>)`
    return false;
  }
  for (const filter of FILENAME_CENSORS) {
    if (regexpExec(filter, fileName)) {
      return false;
    }
  }
  return true;
};

// The ad-hoc rule of the current pattern is that any likely-file-path or
// likely url-path prefix, ending in a `/.../` should get dropped.
// Anything to the left of the likely path text is kept.
// Everything to the right of `/.../` is kept. Thus
// `'Object.bar (/vat-v1/.../errors/test/deep-send.test.js:13:21)'`
// simplifies to
// `'Object.bar (errors/test/deep-send.test.js:13:21)'`.
//
// See thread starting at
// https://github.com/Agoric/agoric-sdk/issues/2326#issuecomment-773020389
$h͏_once.filterFileName(filterFileName);const CALLSITE_ELLIPSIS_PATTERN1=/^((?:.*[( ])?)[:/\w_-]*\/\.\.\.\/(.+)$/;

// The ad-hoc rule of the current pattern is that any likely-file-path or
// likely url-path prefix consisting of `.../` should get dropped.
// Anything to the left of the likely path text is kept.
// Everything to the right of `.../` is kept. Thus
// `'Object.bar (.../errors/test/deep-send.test.js:13:21)'`
// simplifies to
// `'Object.bar (errors/test/deep-send.test.js:13:21)'`.
//
// See thread starting at
// https://github.com/Agoric/agoric-sdk/issues/2326#issuecomment-773020389
const CALLSITE_ELLIPSIS_PATTERN2 = /^((?:.*[( ])?)\.\.\.\/(.+)$/;

// The ad-hoc rule of the current pattern is that any likely-file-path or
// likely url-path prefix, ending in a `/` and prior to `package/` should get
// dropped.
// Anything to the left of the likely path prefix text is kept. `package/` and
// everything to its right is kept. Thus
// `'Object.bar (/Users/markmiller/src/ongithub/agoric/agoric-sdk/packages/errors/test/deep-send.test.js:13:21)'`
// simplifies to
// `'Object.bar (packages/errors/test/deep-send.test.js:13:21)'`.
// Note that `/packages/` is a convention for monorepos encouraged by
// lerna.
const CALLSITE_PACKAGES_PATTERN = /^((?:.*[( ])?)[:/\w_-]*\/(packages\/.+)$/;

// The ad-hoc rule of the current pattern is that any likely-file-path or
// likely url-path prefix of the form `file://` but not `file:///` gets
// dropped.
// Anything to the left of the likely path prefix text is kept. Everything to
// the right of `file://` is kept. Thus
// `'Object.bar (file:///Users/markmiller/src/ongithub/endojs/endo/packages/errors/test/deep-send.test.js:13:21)'` is unchanged but
// `'Object.bar (file://test/deep-send.test.js:13:21)'`

// simplifies to
// `'Object.bar (test/deep-send.test.js:13:21)'`.
// The reason is that `file:///` usually precedes an absolute path which is
// clickable without removing the `file:///`, whereas `file://` usually precedes
// a relative path which, for whatever vscode reason, is not clickable until the
// `file://` is removed.
const CALLSITE_FILE_2SLASH_PATTERN = /^((?:.*[( ])?)file:\/\/([^/].*)$/;

// The use of these callSite patterns below assumes that any match will bind
// capture groups containing the parts of the original string we want
// to keep. The parts outside those capture groups will be dropped from concise
// stacks.
// TODO Enable users to configure CALLSITE_PATTERNS via `lockdown` options.
const CALLSITE_PATTERNS = [
  CALLSITE_ELLIPSIS_PATTERN1,
  CALLSITE_ELLIPSIS_PATTERN2,
  CALLSITE_PACKAGES_PATTERN,
  CALLSITE_FILE_2SLASH_PATTERN,
];

// For a stack frame that should be included in a concise stack trace, if
// `callSiteString` is the original stringified stack frame, return the
// possibly-shorter stringified stack frame that should be shown instead.
// Exported only so it can be unit tested.
// TODO Move so that it applies not just to v8.
/**
 * @param {string} callSiteString
 */
       const shortenCallSiteString = callSiteString => {
  for (const filter of CALLSITE_PATTERNS) {
    const match = regexpExec(filter, callSiteString);
    if (match) {
      return arrayJoin(arraySlice(match, 1), '');
    }
  }
  return callSiteString;
};$h͏_once.shortenCallSiteString(shortenCallSiteString);

       const tameV8ErrorConstructor = (
  OriginalError,
  InitialError,
  errorTaming,
  stackFiltering,
) => {
  if (errorTaming === 'unsafe-debug') {
    throw TypeError(
      'internal: v8+unsafe-debug special case should already be done',
    );
  }
  // TODO: Proper CallSite types
  /** @typedef {{}} CallSite */

  const originalCaptureStackTrace = OriginalError.captureStackTrace;

  const omitFrames =
    stackFiltering === 'concise' || stackFiltering === 'omit-frames';

  const shortenPaths =
    stackFiltering === 'concise' || stackFiltering === 'shorten-paths';

  // const callSiteFilter = _callSite => true;
  const callSiteFilter = callSite => {
    if (omitFrames) {
      // eslint-disable-next-line @endo/no-polymorphic-call
      if (callSite.getFunctionName()?.startsWith('__HIDE_')) {
        return false;
      }
      // eslint-disable-next-line @endo/no-polymorphic-call
      return filterFileName(callSite.getFileName());
    }
    return true;
  };

  const callSiteStringifier = callSite => {
    let callSiteString = `${callSite}`;
    if (shortenPaths) {
      callSiteString = shortenCallSiteString(callSiteString);
    }
    return `\n  at ${callSiteString}`;
  };

  const stackStringFromSST = (_error, sst) =>
    arrayJoin(
      arrayMap(arrayFilter(sst, callSiteFilter), callSiteStringifier),
      '',
    );

  /**
   * @typedef {object} StructuredStackInfo
   * @property {CallSite[]} callSites
   * @property {undefined} [stackString]
   */

  /**
   * @typedef {object} ParsedStackInfo
   * @property {undefined} [callSites]
   * @property {string} stackString
   */

  // Mapping from error instance to the stack for that instance.
  // The stack info is either the structured stack trace
  // or the generated tamed stack string
  /** @type {WeakMap<Error, ParsedStackInfo | StructuredStackInfo>} */
  const stackInfos = new WeakMap();

  // Use concise methods to obtain named functions without constructors.
  const tamedMethods = {
    // The optional `optFn` argument is for cutting off the bottom of
    // the stack --- for capturing the stack only above the topmost
    // call to that function. Since this isn't the "real" captureStackTrace
    // but instead calls the real one, if no other cutoff is provided,
    // we cut this one off.
    captureStackTrace(error, optFn = tamedMethods.captureStackTrace) {
      if (typeof originalCaptureStackTrace === 'function') {
        // OriginalError.captureStackTrace is only on v8
        apply(originalCaptureStackTrace, OriginalError, [error, optFn]);
        return;
      }
      reflectSet(error, 'stack', '');
    },
    // Shim of proposed special power, to reside by default only
    // in the start compartment, for getting the stack traceback
    // string associated with an error.
    // See https://tc39.es/proposal-error-stacks/
    getStackString(error) {
      let stackInfo = weakmapGet(stackInfos, error);

      if (stackInfo === undefined) {
        // The following will call `prepareStackTrace()` synchronously
        // which will populate stackInfos
        // eslint-disable-next-line no-void
        void error.stack;
        stackInfo = weakmapGet(stackInfos, error);
        if (!stackInfo) {
          stackInfo = { stackString: '' };
          weakmapSet(stackInfos, error, stackInfo);
        }
      }

      // prepareStackTrace() may generate the stackString
      // if errorTaming === 'unsafe'

      if (stackInfo.stackString !== undefined) {
        return stackInfo.stackString;
      }

      const stackString = stackStringFromSST(error, stackInfo.callSites);
      weakmapSet(stackInfos, error, { stackString });

      return stackString;
    },
    prepareStackTrace(error, sst) {
      if (errorTaming === 'unsafe') {
        const stackString = stackStringFromSST(error, sst);
        weakmapSet(stackInfos, error, { stackString });
        return `${error}${stackString}`;
      } else {
        weakmapSet(stackInfos, error, { callSites: sst });
        return '';
      }
    },
  };

  // A prepareFn is a prepareStackTrace function.
  // An sst is a `structuredStackTrace`, which is an array of
  // callsites.
  // A user prepareFn is a prepareFn defined by a client of this API,
  // and provided by assigning to `Error.prepareStackTrace`.
  // A user prepareFn should only receive an attenuated sst, which
  // is an array of attenuated callsites.
  // A system prepareFn is the prepareFn created by this module to
  // be installed on the real `Error` constructor, to receive
  // an original sst, i.e., an array of unattenuated callsites.
  // An input prepareFn is a function the user assigns to
  // `Error.prepareStackTrace`, which might be a user prepareFn or
  // a system prepareFn previously obtained by reading
  // `Error.prepareStackTrace`.

  const defaultPrepareFn = tamedMethods.prepareStackTrace;

  OriginalError.prepareStackTrace = defaultPrepareFn;

  // A weakset branding some functions as system prepareFns, all of which
  // must be defined by this module, since they can receive an
  // unattenuated sst.
  const systemPrepareFnSet = new WeakSet([defaultPrepareFn]);

  const systemPrepareFnFor = inputPrepareFn => {
    if (weaksetHas(systemPrepareFnSet, inputPrepareFn)) {
      return inputPrepareFn;
    }
    // Use concise methods to obtain named functions without constructors.
    const systemMethods = {
      prepareStackTrace(error, sst) {
        weakmapSet(stackInfos, error, { callSites: sst });
        return inputPrepareFn(error, safeV8SST(sst));
      },
    };
    weaksetAdd(systemPrepareFnSet, systemMethods.prepareStackTrace);
    return systemMethods.prepareStackTrace;
  };

  // Note `stackTraceLimit` accessor already defined by
  // tame-error-constructor.js
  defineProperties(InitialError, {
    captureStackTrace: {
      value: tamedMethods.captureStackTrace,
      writable: true,
      enumerable: false,
      configurable: true,
    },
    prepareStackTrace: {
      get() {
        return OriginalError.prepareStackTrace;
      },
      set(inputPrepareStackTraceFn) {
        if (typeof inputPrepareStackTraceFn === 'function') {
          const systemPrepareFn = systemPrepareFnFor(inputPrepareStackTraceFn);
          OriginalError.prepareStackTrace = systemPrepareFn;
        } else {
          OriginalError.prepareStackTrace = defaultPrepareFn;
        }
      },
      enumerable: false,
      configurable: true,
    },
  });

  return tamedMethods.getStackString;
};$h͏_once.tameV8ErrorConstructor(tameV8ErrorConstructor);
})()
,
// === 44. ses ./src/error/tame-error-constructor.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let FERAL_ERROR,apply,construct,defineProperties,setPrototypeOf,getOwnPropertyDescriptor,defineProperty,getOwnPropertyDescriptors,NativeErrors,tameV8ErrorConstructor;$h͏_imports([["../commons.js", [["FERAL_ERROR",[$h͏_a => (FERAL_ERROR = $h͏_a)]],["apply",[$h͏_a => (apply = $h͏_a)]],["construct",[$h͏_a => (construct = $h͏_a)]],["defineProperties",[$h͏_a => (defineProperties = $h͏_a)]],["setPrototypeOf",[$h͏_a => (setPrototypeOf = $h͏_a)]],["getOwnPropertyDescriptor",[$h͏_a => (getOwnPropertyDescriptor = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["getOwnPropertyDescriptors",[$h͏_a => (getOwnPropertyDescriptors = $h͏_a)]]]],["../permits.js", [["NativeErrors",[$h͏_a => (NativeErrors = $h͏_a)]]]],["./tame-v8-error-constructor.js", [["tameV8ErrorConstructor",[$h͏_a => (tameV8ErrorConstructor = $h͏_a)]]]]]);












// Present on at least FF and XS. Proposed by Error-proposal. The original
// is dangerous, so tameErrorConstructor replaces it with a safe one.
// We grab the original here before it gets replaced.
const stackDesc = getOwnPropertyDescriptor(FERAL_ERROR.prototype, 'stack');
const stackGetter = stackDesc && stackDesc.get;

// Use concise methods to obtain named functions without constructors.
const tamedMethods = {
  getStackString(error) {
    if (typeof stackGetter === 'function') {
      return apply(stackGetter, error, []);
    } else if ('stack' in error) {
      // The fallback is to just use the de facto `error.stack` if present
      return `${error.stack}`;
    }
    return '';
  },
};
let initialGetStackString = tamedMethods.getStackString;

               function tameErrorConstructor(
  errorTaming = 'safe',
  stackFiltering = 'concise',
) {
  const ErrorPrototype = FERAL_ERROR.prototype;

  const { captureStackTrace: originalCaptureStackTrace } = FERAL_ERROR;
  const platform =
    typeof originalCaptureStackTrace === 'function' ? 'v8' : 'unknown';

  const makeErrorConstructor = (_ = {}) => {
    // eslint-disable-next-line no-shadow
    const ResultError = function Error(...rest) {
      let error;
      if (new.target === undefined) {
        error = apply(FERAL_ERROR, this, rest);
      } else {
        error = construct(FERAL_ERROR, rest, new.target);
      }
      if (platform === 'v8') {
        // TODO Likely expensive!
        apply(originalCaptureStackTrace, FERAL_ERROR, [error, ResultError]);
      }
      return error;
    };
    defineProperties(ResultError, {
      length: { value: 1 },
      prototype: {
        value: ErrorPrototype,
        writable: false,
        enumerable: false,
        configurable: false,
      },
    });
    return ResultError;
  };
  const InitialError = makeErrorConstructor({ powers: 'original' });
  const SharedError = makeErrorConstructor({ powers: 'none' });
  defineProperties(ErrorPrototype, {
    constructor: { value: SharedError },
  });

  for (const NativeError of NativeErrors) {
    setPrototypeOf(NativeError, SharedError);
  }

  // https://v8.dev/docs/stack-trace-api#compatibility advises that
  // programmers can "always" set `Error.stackTraceLimit`
  // even on non-v8 platforms. On non-v8
  // it will have no effect, but this advice only makes sense
  // if the assignment itself does not fail, which it would
  // if `Error` were naively frozen. Hence, we add setters that
  // accept but ignore the assignment on non-v8 platforms.
  defineProperties(InitialError, {
    stackTraceLimit: {
      get() {
        if (typeof FERAL_ERROR.stackTraceLimit === 'number') {
          // FERAL_ERROR.stackTraceLimit is only on v8
          return FERAL_ERROR.stackTraceLimit;
        }
        return undefined;
      },
      set(newLimit) {
        if (typeof newLimit !== 'number') {
          // silently do nothing. This behavior doesn't precisely
          // emulate v8 edge-case behavior. But given the purpose
          // of this emulation, having edge cases err towards
          // harmless seems the safer option.
          return;
        }
        if (typeof FERAL_ERROR.stackTraceLimit === 'number') {
          // FERAL_ERROR.stackTraceLimit is only on v8
          FERAL_ERROR.stackTraceLimit = newLimit;
          // We place the useless return on the next line to ensure
          // that anything we place after the if in the future only
          // happens if the then-case does not.
          // eslint-disable-next-line no-useless-return
          return;
        }
      },
      // WTF on v8 stackTraceLimit is enumerable
      enumerable: false,
      configurable: true,
    },
  });

  if (errorTaming === 'unsafe-debug' && platform === 'v8') {
    // This case is a kludge to work around
    // https://github.com/endojs/endo/issues/1798
    // https://github.com/endojs/endo/issues/2348
    // https://github.com/Agoric/agoric-sdk/issues/8662

    defineProperties(InitialError, {
      prepareStackTrace: {
        get() {
          return FERAL_ERROR.prepareStackTrace;
        },
        set(newPrepareStackTrace) {
          FERAL_ERROR.prepareStackTrace = newPrepareStackTrace;
        },
        enumerable: false,
        configurable: true,
      },
      captureStackTrace: {
        value: FERAL_ERROR.captureStackTrace,
        writable: true,
        enumerable: false,
        configurable: true,
      },
    });

    const descs = getOwnPropertyDescriptors(InitialError);
    defineProperties(SharedError, {
      stackTraceLimit: descs.stackTraceLimit,
      prepareStackTrace: descs.prepareStackTrace,
      captureStackTrace: descs.captureStackTrace,
    });

    return {
      '%InitialGetStackString%': initialGetStackString,
      '%InitialError%': InitialError,
      '%SharedError%': SharedError,
    };
  }

  // The default SharedError much be completely powerless even on v8,
  // so the lenient `stackTraceLimit` accessor does nothing on all
  // platforms.
  defineProperties(SharedError, {
    stackTraceLimit: {
      get() {
        return undefined;
      },
      set(_newLimit) {
        // do nothing
      },
      enumerable: false,
      configurable: true,
    },
  });

  if (platform === 'v8') {
    // `SharedError.prepareStackTrace`, if it exists, must also be
    // powerless. However, from what we've heard, depd expects to be able to
    // assign to it without the assignment throwing. It is normally a function
    // that returns a stack string to be magically added to error objects.
    // However, as long as we're adding a lenient standin, we may as well
    // accommodate any who expect to get a function they can call and get
    // a string back. This prepareStackTrace is a do-nothing function that
    // always returns the empty string.
    defineProperties(SharedError, {
      prepareStackTrace: {
        get() {
          return () => '';
        },
        set(_prepareFn) {
          // do nothing
        },
        enumerable: false,
        configurable: true,
      },
      captureStackTrace: {
        value: (errorish, _constructorOpt) => {
          defineProperty(errorish, 'stack', {
            value: '',
          });
        },
        writable: false,
        enumerable: false,
        configurable: true,
      },
    });
  }

  if (platform === 'v8') {
    initialGetStackString = tameV8ErrorConstructor(
      FERAL_ERROR,
      InitialError,
      errorTaming,
      stackFiltering,
    );
  } else if (errorTaming === 'unsafe' || errorTaming === 'unsafe-debug') {
    // v8 has too much magic around their 'stack' own property for it to
    // coexist cleanly with this accessor. So only install it on non-v8

    // Error.prototype.stack property as proposed at
    // https://tc39.es/proposal-error-stacks/
    // with the fix proposed at
    // https://github.com/tc39/proposal-error-stacks/issues/46
    // On others, this still protects from the override mistake,
    // essentially like enable-property-overrides.js would
    // once this accessor property itself is frozen, as will happen
    // later during lockdown.
    //
    // However, there is here a change from the intent in the current
    // state of the proposal. If experience tells us whether this change
    // is a good idea, we should modify the proposal accordingly. There is
    // much code in the world that assumes `error.stack` is a string. So
    // where the proposal accommodates secure operation by making the
    // property optional, we instead accommodate secure operation by
    // having the secure form always return only the stable part, the
    // stringified error instance, and omitting all the frame information
    // rather than omitting the property.
    defineProperties(ErrorPrototype, {
      stack: {
        get() {
          return initialGetStackString(this);
        },
        set(newValue) {
          defineProperties(this, {
            stack: {
              value: newValue,
              writable: true,
              enumerable: true,
              configurable: true,
            },
          });
        },
      },
    });
  } else {
    // v8 has too much magic around their 'stack' own property for it to
    // coexist cleanly with this accessor. So only install it on non-v8
    defineProperties(ErrorPrototype, {
      stack: {
        get() {
          // https://github.com/tc39/proposal-error-stacks/issues/46
          // allows this to not add an unpleasant newline. Otherwise
          // we should fix this.
          return `${this}`;
        },
        set(newValue) {
          defineProperties(this, {
            stack: {
              value: newValue,
              writable: true,
              enumerable: true,
              configurable: true,
            },
          });
        },
      },
    });
  }

  return {
    '%InitialGetStackString%': initialGetStackString,
    '%InitialError%': InitialError,
    '%SharedError%': SharedError,
  };
}$h͏_once.default(      tameErrorConstructor);
})()
,
// === 45. ses ./src/module-load.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let getenv,Map,Set,TypeError,arrayJoin,arrayMap,arrayPush,arraySome,create,freeze,generatorNext,generatorThrow,getOwnPropertyNames,isArray,isPrimitive,mapGet,mapHas,mapSet,promiseThen,setAdd,values,weakmapGet,weakmapHas,makeError,annotateError,q,b,X;$h͏_imports([["@endo/env-options", [["getEnvironmentOption",[$h͏_a => (getenv = $h͏_a)]]]],["./commons.js", [["Map",[$h͏_a => (Map = $h͏_a)]],["Set",[$h͏_a => (Set = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["arrayJoin",[$h͏_a => (arrayJoin = $h͏_a)]],["arrayMap",[$h͏_a => (arrayMap = $h͏_a)]],["arrayPush",[$h͏_a => (arrayPush = $h͏_a)]],["arraySome",[$h͏_a => (arraySome = $h͏_a)]],["create",[$h͏_a => (create = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["generatorNext",[$h͏_a => (generatorNext = $h͏_a)]],["generatorThrow",[$h͏_a => (generatorThrow = $h͏_a)]],["getOwnPropertyNames",[$h͏_a => (getOwnPropertyNames = $h͏_a)]],["isArray",[$h͏_a => (isArray = $h͏_a)]],["isPrimitive",[$h͏_a => (isPrimitive = $h͏_a)]],["mapGet",[$h͏_a => (mapGet = $h͏_a)]],["mapHas",[$h͏_a => (mapHas = $h͏_a)]],["mapSet",[$h͏_a => (mapSet = $h͏_a)]],["promiseThen",[$h͏_a => (promiseThen = $h͏_a)]],["setAdd",[$h͏_a => (setAdd = $h͏_a)]],["values",[$h͏_a => (values = $h͏_a)]],["weakmapGet",[$h͏_a => (weakmapGet = $h͏_a)]],["weakmapHas",[$h͏_a => (weakmapHas = $h͏_a)]]]],["./error/assert.js", [["makeError",[$h͏_a => (makeError = $h͏_a)]],["annotateError",[$h͏_a => (annotateError = $h͏_a)]],["q",[$h͏_a => (q = $h͏_a)]],["b",[$h͏_a => (b = $h͏_a)]],["X",[$h͏_a => (X = $h͏_a)]]]]]);


























const noop = () => {};

const asyncTrampoline = async (generatorFunc, args, errorWrapper) => {
  await null;
  const iterator = generatorFunc(...args);
  let result = generatorNext(iterator);
  while (!result.done) {
    try {
      // eslint-disable-next-line no-await-in-loop
      const val = await result.value;
      result = generatorNext(iterator, val);
    } catch (error) {
      result = generatorThrow(iterator, errorWrapper(error));
    }
  }
  return result.value;
};

const syncTrampoline = (generatorFunc, args) => {
  const iterator = generatorFunc(...args);
  let result = generatorNext(iterator);
  while (!result.done) {
    try {
      result = generatorNext(iterator, result.value);
    } catch (error) {
      result = generatorThrow(iterator, error);
    }
  }
  return result.value;
};

// `makeAlias` constructs compartment specifier tuples for the `aliases`
// private field of compartments.
// These aliases allow a compartment to alias an internal module specifier to a
// module specifier in an external compartment, and also to create internal
// aliases.
// Both are facilitated by the moduleMap Compartment constructor option.
       const makeAlias = (compartment, specifier) =>
  freeze({ compartment, specifier });

// `resolveAll` pre-computes resolutions of all imports within the compartment
// in which a module was loaded.
$h͏_once.makeAlias(makeAlias);const resolveAll=(imports,resolveHook,fullReferrerSpecifier)=>{
  const resolvedImports = create(null);
  for (const importSpecifier of imports) {
    const fullSpecifier = resolveHook(importSpecifier, fullReferrerSpecifier);
    resolvedImports[importSpecifier] = fullSpecifier;
  }
  return freeze(resolvedImports);
};

const loadModuleSource = (
  compartmentPrivateFields,
  moduleAliases,
  compartment,
  moduleSpecifier,
  moduleSource,
  enqueueJob,
  selectImplementation,
  moduleLoads,
  importMeta,
) => {
  const { resolveHook, name: compartmentName } = weakmapGet(
    compartmentPrivateFields,
    compartment,
  );

  const { imports } = moduleSource;
  if (
    !isArray(imports) ||
    arraySome(imports, specifier => typeof specifier !== 'string')
  ) {
    throw makeError(
      X`Invalid module source: 'imports' must be an array of strings, got ${imports} for module ${q(moduleSpecifier)} of compartment ${q(compartmentName)}`,
    );
  }

  // resolve all imports relative to this referrer module.
  const resolvedImports = resolveAll(imports, resolveHook, moduleSpecifier);
  const moduleRecord = freeze({
    compartment,
    moduleSource,
    moduleSpecifier,
    resolvedImports,
    importMeta,
  });

  // Enqueue jobs to load this module's shallow dependencies.
  for (const fullSpecifier of values(resolvedImports)) {
    // Behold: recursion.
    // eslint-disable-next-line no-use-before-define
    enqueueJob(memoizedLoadWithErrorAnnotation, [
      compartmentPrivateFields,
      moduleAliases,
      compartment,
      fullSpecifier,
      enqueueJob,
      selectImplementation,
      moduleLoads,
    ]);
  }

  return moduleRecord;
};

function* loadWithoutErrorAnnotation(
  compartmentPrivateFields,
  moduleAliases,
  compartment,
  moduleSpecifier,
  enqueueJob,
  selectImplementation,
  moduleLoads,
) {
  const {
    importHook,
    importNowHook,
    moduleMap,
    moduleMapHook,
    moduleRecords,
    parentCompartment,
  } = weakmapGet(compartmentPrivateFields, compartment);

  if (mapHas(moduleRecords, moduleSpecifier)) {
    return mapGet(moduleRecords, moduleSpecifier);
  }

  // Follow moduleMap, or moduleMapHook if present.
  let moduleDescriptor = moduleMap[moduleSpecifier];
  if (moduleDescriptor === undefined && moduleMapHook !== undefined) {
    moduleDescriptor = moduleMapHook(moduleSpecifier);
  }
  if (moduleDescriptor === undefined) {
    const moduleHook = selectImplementation(importHook, importNowHook);
    if (moduleHook === undefined) {
      const moduleHookName = selectImplementation(
        'importHook',
        'importNowHook',
      );
      throw makeError(
        X`${b(moduleHookName)} needed to load module ${q(
          moduleSpecifier,
        )} in compartment ${q(compartment.name)}`,
      );
    }
    moduleDescriptor = moduleHook(moduleSpecifier);
    // Uninitialized module namespaces throw if we attempt to coerce them into
    // promises.
    if (!weakmapHas(moduleAliases, moduleDescriptor)) {
      moduleDescriptor = yield moduleDescriptor;
    }
  }

  if (typeof moduleDescriptor === 'string') {
    // eslint-disable-next-line @endo/no-polymorphic-call
    throw makeError(
      X`Cannot map module ${q(moduleSpecifier)} to ${q(
        moduleDescriptor,
      )} in parent compartment, use {source} module descriptor`,
      TypeError,
    );
  } else if (!isPrimitive(moduleDescriptor)) {
    // In this shim (and not in XS, and not in the standard we imagine), we
    // allow a module namespace object to stand in for a module descriptor that
    // describes its original {compartment, specifier} so that it can be used
    // to create a link.
    let aliasDescriptor = weakmapGet(moduleAliases, moduleDescriptor);
    if (aliasDescriptor !== undefined) {
      moduleDescriptor = aliasDescriptor;
    }

    if (moduleDescriptor.namespace !== undefined) {
      // { namespace: string, compartment?: Compartment }
      // Namespace module descriptors link to a module instance.

      if (typeof moduleDescriptor.namespace === 'string') {
        // The default compartment is the *parent*, not this child compartment.
        // This is a difference from the legacy {specifier, compartment} module
        // descriptor.
        const {
          compartment: aliasCompartment = parentCompartment,
          namespace: aliasSpecifier,
        } = moduleDescriptor;
        if (
          isPrimitive(aliasCompartment) ||
          !weakmapHas(compartmentPrivateFields, aliasCompartment)
        ) {
          throw makeError(
            X`Invalid compartment in module descriptor for specifier ${q(moduleSpecifier)} in compartment ${q(compartment.name)}`,
          );
        }
        // Behold: recursion.
        // eslint-disable-next-line no-use-before-define
        const aliasRecord = yield memoizedLoadWithErrorAnnotation(
          compartmentPrivateFields,
          moduleAliases,
          aliasCompartment,
          aliasSpecifier,
          enqueueJob,
          selectImplementation,
          moduleLoads,
        );
        mapSet(moduleRecords, moduleSpecifier, aliasRecord);
        return aliasRecord;
      }

      // All remaining objects must either be a module namespace, or be
      // promoted into a module namespace with a virtual module source.
      if (!isPrimitive(moduleDescriptor.namespace)) {
        const { namespace } = moduleDescriptor;
        // Brand-check SES shim module exports namespaces:
        aliasDescriptor = weakmapGet(moduleAliases, namespace);
        if (aliasDescriptor !== undefined) {
          moduleDescriptor = aliasDescriptor;
          // Fall through to processing the resulting {compartment, specifier}
          // alias.
        } else {
          // Promote an arbitrary object to a module namespace with a virtual
          // module source.
          // { namespace: Object }
          const exports = getOwnPropertyNames(namespace);
          /** @type {import('../types.js').VirtualModuleSource} */
          const moduleSource = {
            imports: [],
            exports,
            execute(env) {
              for (const name of exports) {
                env[name] = namespace[name];
              }
            },
          };
          const importMeta = undefined;
          const moduleRecord = loadModuleSource(
            compartmentPrivateFields,
            moduleAliases,
            compartment,
            moduleSpecifier,
            moduleSource,
            enqueueJob,
            selectImplementation,
            moduleLoads,
            importMeta,
          );
          mapSet(moduleRecords, moduleSpecifier, moduleRecord);
          return moduleRecord;
        }
      } else {
        throw makeError(
          X`Invalid compartment in module descriptor for specifier ${q(moduleSpecifier)} in compartment ${q(compartment.name)}`,
        );
      }
    }

    if (moduleDescriptor.source !== undefined) {
      // Module source descriptors create an instance from a module source.
      // The descriptor may contain the module source, or refer to a source
      // loaded in a particular compartment.

      if (typeof moduleDescriptor.source === 'string') {
        // { source: string, importMeta?, specifier?: string, compartment? }
        // A string source is the specifier for a different module source.
        // That source may come from this compartment's parent (default), or
        // from a specified compartment, and the specified compartment may be
        // this compartment to make a duplicate.

        const {
          source: loaderSpecifier,
          specifier: instanceSpecifier = moduleSpecifier,
          compartment: loaderCompartment = parentCompartment,
          importMeta = undefined,
        } = moduleDescriptor;

        // Induce the compartment, possibly a different compartment
        // to load a module source.

        // Behold: recursion.
        // eslint-disable-next-line no-use-before-define
        const loaderRecord = yield memoizedLoadWithErrorAnnotation(
          compartmentPrivateFields,
          moduleAliases,
          loaderCompartment,
          loaderSpecifier,
          enqueueJob,
          selectImplementation,
          moduleLoads,
        );

        // Extract the source of the module from the loader compartment's
        // record.
        const { moduleSource } = loaderRecord;

        // Instantiate that source in our own compartment, possibly with a
        // different specifier for resolving its own imports.
        const moduleRecord = loadModuleSource(
          compartmentPrivateFields,
          moduleAliases,
          compartment,
          instanceSpecifier,
          moduleSource,
          enqueueJob,
          selectImplementation,
          moduleLoads,
          importMeta,
        );
        mapSet(moduleRecords, moduleSpecifier, moduleRecord);
        return moduleRecord;
      } else {
        // { source: ModuleSource, importMeta?, specifier?: string }
        // We assume all non-string module sources are any of the supported
        // kinds of module source: PrecompiledModuleSource,
        // VirtualModuleSource, or a native ModuleSource.

        const {
          source: moduleSource,
          specifier: aliasSpecifier = moduleSpecifier,
          importMeta,
        } = moduleDescriptor;

        const aliasRecord = loadModuleSource(
          compartmentPrivateFields,
          moduleAliases,
          compartment,
          aliasSpecifier,
          moduleSource,
          enqueueJob,
          selectImplementation,
          moduleLoads,
          importMeta,
        );
        mapSet(moduleRecords, moduleSpecifier, aliasRecord);
        return aliasRecord;
      }
    }

    if (moduleDescriptor.archive !== undefined) {
      // { archive: Archive, path: string }
      // We do not support this XS-native module descriptor.
      throw makeError(
        X`Unsupported archive module descriptor for specifier ${q(moduleSpecifier)} in compartment ${q(compartment.name)}`,
      );
    }

    // { record, specifier?, compartment?, importMeta? }
    // A (legacy) module descriptor for when we find the module source (record)
    // but at a different specifier than requested.
    // Providing this {specifier, record} descriptor serves as an ergonomic
    // short-hand for stashing the record, returning a {compartment, specifier}
    // reference, bouncing the module hook, then producing the source (record)
    // when module hook receives the response specifier.
    if (moduleDescriptor.record !== undefined) {
      const {
        compartment: aliasCompartment = compartment,
        specifier: aliasSpecifier = moduleSpecifier,
        record: moduleSource,
        importMeta,
      } = moduleDescriptor;

      const aliasRecord = loadModuleSource(
        compartmentPrivateFields,
        moduleAliases,
        aliasCompartment,
        aliasSpecifier,
        moduleSource,
        enqueueJob,
        selectImplementation,
        moduleLoads,
        importMeta,
      );
      mapSet(moduleRecords, moduleSpecifier, aliasRecord);
      mapSet(moduleRecords, aliasSpecifier, aliasRecord);
      return aliasRecord;
    }

    // { specifier: string, compartment: Compartment }
    // A (legacy) module descriptor that describes a link to a module instance
    // in a specified compartment.
    if (
      moduleDescriptor.compartment !== undefined &&
      moduleDescriptor.specifier !== undefined
    ) {
      if (
        isPrimitive(moduleDescriptor.compartment) ||
        !weakmapHas(compartmentPrivateFields, moduleDescriptor.compartment) ||
        typeof moduleDescriptor.specifier !== 'string'
      ) {
        throw makeError(
          X`Invalid compartment in module descriptor for specifier ${q(moduleSpecifier)} in compartment ${q(compartment.name)}`,
        );
      }
      // Behold: recursion.
      // eslint-disable-next-line no-use-before-define
      const aliasRecord = yield memoizedLoadWithErrorAnnotation(
        compartmentPrivateFields,
        moduleAliases,
        moduleDescriptor.compartment,
        moduleDescriptor.specifier,
        enqueueJob,
        selectImplementation,
        moduleLoads,
      );
      mapSet(moduleRecords, moduleSpecifier, aliasRecord);
      return aliasRecord;
    }

    // A (legacy) behavior: If we do not recognize the module descriptor as a
    // module descriptor, we assume that it is a module source (record):
    const moduleSource = moduleDescriptor;
    const moduleRecord = loadModuleSource(
      compartmentPrivateFields,
      moduleAliases,
      compartment,
      moduleSpecifier,
      moduleSource,
      enqueueJob,
      selectImplementation,
      moduleLoads,
    );
    // Memoize.
    mapSet(moduleRecords, moduleSpecifier, moduleRecord);
    return moduleRecord;
  } else {
    throw makeError(
      X`module descriptor must be a string or object for specifier ${q(
        moduleSpecifier,
      )} in compartment ${q(compartment.name)}`,
    );
  }
}

const memoizedLoadWithErrorAnnotation = (
  compartmentPrivateFields,
  moduleAliases,
  compartment,
  moduleSpecifier,
  enqueueJob,
  selectImplementation,
  moduleLoads,
) => {
  const { name: compartmentName } = weakmapGet(
    compartmentPrivateFields,
    compartment,
  );

  // Prevent data-lock from recursion into branches visited in dependent loads.
  let compartmentLoading = mapGet(moduleLoads, compartment);
  if (compartmentLoading === undefined) {
    compartmentLoading = new Map();
    mapSet(moduleLoads, compartment, compartmentLoading);
  }
  let moduleLoading = mapGet(compartmentLoading, moduleSpecifier);
  if (moduleLoading !== undefined) {
    return moduleLoading;
  }

  moduleLoading = selectImplementation(asyncTrampoline, syncTrampoline)(
    loadWithoutErrorAnnotation,
    [
      compartmentPrivateFields,
      moduleAliases,
      compartment,
      moduleSpecifier,
      enqueueJob,
      selectImplementation,
      moduleLoads,
    ],
    error => {
      // eslint-disable-next-line @endo/no-polymorphic-call
      annotateError(
        error,
        X`${error.message}, loading ${q(moduleSpecifier)} in compartment ${q(
          compartmentName,
        )}`,
      );
      throw error;
    },
  );

  mapSet(compartmentLoading, moduleSpecifier, moduleLoading);

  return moduleLoading;
};

/**
 * If `aggregateErrors` is `false`, the `errors` property of the fulfilled object
 * will always be empty.
 * @param {{errors?: Error[], noAggregateErrors?: boolean}} [options]
 */
const asyncJobQueue = ({ errors = [], noAggregateErrors = false } = {}) => {
  /** @type {Set<Promise<undefined>>} */
  const pendingJobs = new Set();

  /**
   * Enqueues a job that starts immediately but won't be awaited until drainQueue is called.
   *
   * @template {(...args: any[]) => Promise<void>} F
   * @param {F} func - An async function to execute
   * @param {Parameters<F>} args - Arguments to pass to the function
   * @returns {void}
   */
  const enqueueJob = (func, args) => {
    setAdd(
      pendingJobs,
      promiseThen(func(...args), noop, error => {
        if (noAggregateErrors) {
          throw error;
        } else {
          arrayPush(errors, error);
        }
      }),
    );
  };
  /**
   * Sequentially awaits pending jobs and returns an array of errors
   */
  const drainQueue = async () => {
    await null;
    for (const job of pendingJobs) {
      // eslint-disable-next-line no-await-in-loop
      await job;
    }
  };
  return { enqueueJob, drainQueue, errors };
};

/**
 * If `aggregateErrors` is `false`, the `errors` property of the returned object
 * will always be empty.
 * @param {{errors?: Error[], noAggregateErrors?: boolean}} [options]
 */
const syncJobQueue = ({ errors = [], noAggregateErrors = false } = {}) => {
  let current = [];
  let next = [];

  /**
   * Enqueues a job
   *
   * @template {(...args: any[]) => void} F
   * @param {F} func - An async function to execute
   * @param {Parameters<F>} args - Arguments to pass to the function
   * @returns {void}
   */
  const enqueueJob = (func, args) => {
    arrayPush(next, [func, args]);
  };
  const drainQueue = () => {
    // Attention: load bearing flow order. Calling another enqueued function in the
    // synchronous usecase must happen after the one that enqueued it has finished.
    // Jobs enqueued in one pass do not interleave with jobs resulting from them.
    // It's necessary for efficient memoization and to break cycles.
    for (const [func, args] of current) {
      try {
        func(...args);
      } catch (error) {
        if (noAggregateErrors) {
          throw error;
        } else {
          arrayPush(errors, error);
        }
      }
    }
    current = next;
    next = [];
    if (current.length > 0) drainQueue();
  };
  return { enqueueJob, drainQueue, errors };
};

/**
 * @param {object} options
 * @param {Array<Error>} options.errors
 * @param {string} options.errorPrefix
 */
const throwAggregateError = ({ errors, errorPrefix }) => {
  // Throw an aggregate error if there were any errors.
  if (errors.length > 0) {
    const verbose =
      /** @type {'' | 'verbose'} */
      (getenv('COMPARTMENT_LOAD_ERRORS', '', ['verbose'])) === 'verbose';
    throw TypeError(
      `${errorPrefix} (${errors.length} underlying failures: ${arrayJoin(
        arrayMap(errors, error => error.message + (verbose ? error.stack : '')),
        ', ',
      )}`,
    );
  }
};

const preferSync = (_asyncImpl, syncImpl) => syncImpl;
const preferAsync = (asyncImpl, _syncImpl) => asyncImpl;

/**
 * `load` asynchronously gathers the module records for a module and its
 * transitive dependencies.
 * The module records refer to each other by a reference to the dependency's
 * compartment and the specifier of the module within its own compartment.
 * This graph is then ready to be synchronously linked and executed.
 * @param {WeakMap<Compartment, any>} compartmentPrivateFields
 * @param {WeakMap<object, object>} moduleAliases
 * @param {Compartment} compartment
 * @param {string} moduleSpecifier - The module specifier to load.
 * @param {{ noAggregateErrors?: boolean}} options
 */
       const load = async (
  compartmentPrivateFields,
  moduleAliases,
  compartment,
  moduleSpecifier,
  { noAggregateErrors = false } = {},
) => {
  const { name: compartmentName } = weakmapGet(
    compartmentPrivateFields,
    compartment,
  );

  /** @type {Map<object, Map<string, Promise<Record<any, any>>>>} */
  const moduleLoads = new Map();

  const { enqueueJob, drainQueue, errors } = asyncJobQueue({
    noAggregateErrors,
  });

  enqueueJob(memoizedLoadWithErrorAnnotation, [
    compartmentPrivateFields,
    moduleAliases,
    compartment,
    moduleSpecifier,
    enqueueJob,
    preferAsync,
    moduleLoads,
  ]);

  await drainQueue();

  throwAggregateError({
    errors,
    errorPrefix: `Failed to load module ${q(moduleSpecifier)} in package ${q(
      compartmentName,
    )}`,
  });
};

/**
 * `loadNow` synchronously gathers the module records for a specified module
 * and its transitive dependencies.
 * The module records refer to each other by a reference to the dependency's
 * compartment and the specifier of the module within its own compartment.
 * This graph is then ready to be synchronously linked and executed.
 * @param {WeakMap<Compartment, any>} compartmentPrivateFields
 * @param {WeakMap<object, object>} moduleAliases
 * @param {Compartment} compartment
 * @param {string} moduleSpecifier - The module specifier to load.
 * @param {{ noAggregateErrors?: boolean}} options
 */$h͏_once.load(load);

       const loadNow = (
  compartmentPrivateFields,
  moduleAliases,
  compartment,
  moduleSpecifier,
  { noAggregateErrors = false } = {},
) => {
  const { name: compartmentName } = weakmapGet(
    compartmentPrivateFields,
    compartment,
  );

  /** @type {Map<object, Map<string, Promise<Record<any, any>>>>} */
  const moduleLoads = new Map();

  const { enqueueJob, drainQueue, errors } = syncJobQueue({
    noAggregateErrors,
  });

  enqueueJob(memoizedLoadWithErrorAnnotation, [
    compartmentPrivateFields,
    moduleAliases,
    compartment,
    moduleSpecifier,
    enqueueJob,
    preferSync,
    moduleLoads,
  ]);

  drainQueue();

  throwAggregateError({
    errors,
    errorPrefix: `Failed to load module ${q(moduleSpecifier)} in package ${q(
      compartmentName,
    )}`,
  });
};$h͏_once.loadNow(loadNow);
})()
,
// === 46. ses ./src/module-proxy.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let makeAlias,Proxy,TypeError,create,freeze,mapGet,mapHas,mapSet,ownKeys,reflectGet,reflectGetOwnPropertyDescriptor,reflectHas,reflectIsExtensible,reflectPreventExtensions,toStringTagSymbol,weakmapSet,assert;$h͏_imports([["./module-load.js", [["makeAlias",[$h͏_a => (makeAlias = $h͏_a)]]]],["./commons.js", [["Proxy",[$h͏_a => (Proxy = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["create",[$h͏_a => (create = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["mapGet",[$h͏_a => (mapGet = $h͏_a)]],["mapHas",[$h͏_a => (mapHas = $h͏_a)]],["mapSet",[$h͏_a => (mapSet = $h͏_a)]],["ownKeys",[$h͏_a => (ownKeys = $h͏_a)]],["reflectGet",[$h͏_a => (reflectGet = $h͏_a)]],["reflectGetOwnPropertyDescriptor",[$h͏_a => (reflectGetOwnPropertyDescriptor = $h͏_a)]],["reflectHas",[$h͏_a => (reflectHas = $h͏_a)]],["reflectIsExtensible",[$h͏_a => (reflectIsExtensible = $h͏_a)]],["reflectPreventExtensions",[$h͏_a => (reflectPreventExtensions = $h͏_a)]],["toStringTagSymbol",[$h͏_a => (toStringTagSymbol = $h͏_a)]],["weakmapSet",[$h͏_a => (weakmapSet = $h͏_a)]]]],["./error/assert.js", [["assert",[$h͏_a => (assert = $h͏_a)]]]]]);































const { quote: q } = assert;

// `deferExports` creates a module's exports proxy, proxied exports, and
// activator.
// A `Compartment` can create a module for any module specifier, regardless of
// whether it is loadable or executable, and use that object as a token that
// can be fed into another compartment's module map.
// Only after the specified module has been analyzed is it possible for the
// module namespace proxy to behave properly, so it throws exceptions until
// after the compartment has begun executing the module.
// The module instance must freeze the proxied exports and activate the exports
// proxy before executing the module.
//
// The module exports proxy's behavior differs from the ECMAScript 262
// specification for "module namespace exotic objects" only in that according
// to the specification value property descriptors have a non-writable "value"
// and this implementation models all properties with accessors.
//
// https://tc39.es/ecma262/#sec-module-namespace-exotic-objects
//
       const deferExports = () => {
  let active = false;
  const exportsTarget = create(null, {
    // Make this appear like an ESM module namespace object.
    [toStringTagSymbol]: {
      value: 'Module',
      writable: false,
      enumerable: false,
      configurable: false,
    },
  });
  return freeze({
    activate() {
      active = true;
    },
    exportsTarget,
    exportsProxy: new Proxy(exportsTarget, {
      get(_target, name, receiver) {
        if (!active) {
          throw TypeError(
            `Cannot get property ${q(
              name,
            )} of module exports namespace, the module has not yet begun to execute`,
          );
        }
        return reflectGet(exportsTarget, name, receiver);
      },
      set(_target, name, _value) {
        throw TypeError(
          `Cannot set property ${q(name)} of module exports namespace`,
        );
      },
      has(_target, name) {
        if (!active) {
          throw TypeError(
            `Cannot check property ${q(
              name,
            )}, the module has not yet begun to execute`,
          );
        }
        return reflectHas(exportsTarget, name);
      },
      deleteProperty(_target, name) {
        throw TypeError(
          `Cannot delete property ${q(name)}s of module exports namespace`,
        );
      },
      ownKeys(_target) {
        if (!active) {
          throw TypeError(
            'Cannot enumerate keys, the module has not yet begun to execute',
          );
        }
        return ownKeys(exportsTarget);
      },
      getOwnPropertyDescriptor(_target, name) {
        if (!active) {
          throw TypeError(
            `Cannot get own property descriptor ${q(
              name,
            )}, the module has not yet begun to execute`,
          );
        }
        return reflectGetOwnPropertyDescriptor(exportsTarget, name);
      },
      preventExtensions(_target) {
        if (!active) {
          throw TypeError(
            'Cannot prevent extensions of module exports namespace, the module has not yet begun to execute',
          );
        }
        return reflectPreventExtensions(exportsTarget);
      },
      isExtensible() {
        if (!active) {
          throw TypeError(
            'Cannot check extensibility of module exports namespace, the module has not yet begun to execute',
          );
        }
        return reflectIsExtensible(exportsTarget);
      },
      getPrototypeOf(_target) {
        return null;
      },
      setPrototypeOf(_target, _proto) {
        throw TypeError('Cannot set prototype of module exports namespace');
      },
      defineProperty(_target, name, _descriptor) {
        throw TypeError(
          `Cannot define property ${q(name)} of module exports namespace`,
        );
      },
      apply(_target, _thisArg, _args) {
        throw TypeError(
          'Cannot call module exports namespace, it is not a function',
        );
      },
      construct(_target, _args) {
        throw TypeError(
          'Cannot construct module exports namespace, it is not a constructor',
        );
      },
    }),
  });
};

/**
 * @typedef {object} DeferredExports
 * @property {Record<string, any>} exportsTarget - The object to which a
 * module's exports will be added.
 * @property {Record<string, any>} exportsProxy - A proxy over the `exportsTarget`,
 * used to expose its "exports" to other compartments.
 * @property {() => void} activate - Activate the `exportsProxy` such that it can
 * be used as a module namespace object.
 */

/**
 * Memoizes the creation of a deferred module exports namespace proxy for any
 * arbitrary full specifier in a compartment. It also records the compartment
 * and specifier affiliated with that module exports namespace proxy so it
 * can be used as an alias into another compartment when threaded through
 * a compartment's `moduleMap` argument.
 *
 * @param {*} compartment - The compartment to retrieve deferred exports from.
 * @param {*} compartmentPrivateFields - The private fields of the compartment.
 * @param {*} moduleAliases - The module aliases of the compartment.
 * @param {string} specifier - The module specifier to retrieve deferred exports for.
 * @returns {DeferredExports} - The deferred exports for the module specifier of
 * the compartment.
 */$h͏_once.deferExports(deferExports);
       const getDeferredExports = (
  compartment,
  compartmentPrivateFields,
  moduleAliases,
  specifier,
) => {
  const { deferredExports } = compartmentPrivateFields;
  if (!mapHas(deferredExports, specifier)) {
    const deferred = deferExports();
    weakmapSet(
      moduleAliases,
      deferred.exportsProxy,
      makeAlias(compartment, specifier),
    );
    mapSet(deferredExports, specifier, deferred);
  }
  return mapGet(deferredExports, specifier);
};$h͏_once.getDeferredExports(getDeferredExports);
})()
,
// === 47. ses ./src/compartment-evaluate.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let TypeError,arrayPush,create,getOwnPropertyDescriptors,evadeHtmlCommentTest,evadeImportExpressionTest,rejectSomeDirectEvalExpressions,makeSafeEvaluator;$h͏_imports([["./commons.js", [["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["arrayPush",[$h͏_a => (arrayPush = $h͏_a)]],["create",[$h͏_a => (create = $h͏_a)]],["getOwnPropertyDescriptors",[$h͏_a => (getOwnPropertyDescriptors = $h͏_a)]]]],["./transforms.js", [["evadeHtmlCommentTest",[$h͏_a => (evadeHtmlCommentTest = $h͏_a)]],["evadeImportExpressionTest",[$h͏_a => (evadeImportExpressionTest = $h͏_a)]],["rejectSomeDirectEvalExpressions",[$h͏_a => (rejectSomeDirectEvalExpressions = $h͏_a)]]]],["./make-safe-evaluator.js", [["makeSafeEvaluator",[$h͏_a => (makeSafeEvaluator = $h͏_a)]]]]]);













       const provideCompartmentEvaluator = (compartmentFields, options) => {
  const { sloppyGlobalsMode = false, __moduleShimLexicals__ = undefined } =
    options;

  let safeEvaluate;

  if (__moduleShimLexicals__ === undefined && !sloppyGlobalsMode) {
    ({ safeEvaluate } = compartmentFields);
  } else {
    // The scope proxy or global lexicals are different from the
    // shared evaluator so we need to build a new one

    let { globalTransforms } = compartmentFields;
    const { globalObject } = compartmentFields;

    let moduleLexicals;
    if (__moduleShimLexicals__ !== undefined) {
      // When using `evaluate` for ESM modules, as should only occur from the
      // module-shim's module-instance.js, we do not reveal the SES-shim's
      // module-to-program translation, as this is not standardizable behavior.
      // However, the `localTransforms` will come from the `__shimTransforms__`
      // Compartment option in this case, which is a non-standardizable escape
      // hatch so programs designed specifically for the SES-shim
      // implementation may opt-in to use the same transforms for `evaluate`
      // and `import`, at the expense of being tightly coupled to SES-shim.
      globalTransforms = undefined;

      moduleLexicals = create(
        null,
        getOwnPropertyDescriptors(__moduleShimLexicals__),
      );
    }

    ({ safeEvaluate } = makeSafeEvaluator({
      globalObject,
      moduleLexicals,
      globalTransforms,
      sloppyGlobalsMode,
    }));
  }

  return { safeEvaluate };
};$h͏_once.provideCompartmentEvaluator(provideCompartmentEvaluator);

       const compartmentEvaluate = (compartmentFields, source, options) => {
  // Perform this check first to avoid unnecessary sanitizing.
  // TODO Maybe relax string check and coerce instead:
  // https://github.com/tc39/proposal-dynamic-code-brand-checks
  if (typeof source !== 'string') {
    throw TypeError('first argument of evaluate() must be a string');
  }

  // Extract options, and shallow-clone transforms.
  const {
    transforms = [],
    __evadeHtmlCommentTest__ = false,
    __evadeImportExpressionTest__ = false,
    __rejectSomeDirectEvalExpressions__ = true  // Note default on
  } = options;
  const localTransforms = [...transforms];
  if (__evadeHtmlCommentTest__ === true) {
    arrayPush(localTransforms, evadeHtmlCommentTest);
  }
  if (__evadeImportExpressionTest__ === true) {
    arrayPush(localTransforms, evadeImportExpressionTest);
  }
  if (__rejectSomeDirectEvalExpressions__ === true) {
    arrayPush(localTransforms, rejectSomeDirectEvalExpressions);
  }

  const { safeEvaluate } = provideCompartmentEvaluator(
    compartmentFields,
    options,
  );

  return safeEvaluate(source, {
    localTransforms,
  });
};$h͏_once.compartmentEvaluate(compartmentEvaluate);
})()
,
// === 48. ses ./src/module-instance.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let assert,getDeferredExports,ReferenceError,SyntaxError,TypeError,arrayForEach,arrayIncludes,arrayPush,arraySome,arraySort,create,defineProperty,entries,freeze,isArray,keys,mapGet,weakmapGet,reflectHas,assign,compartmentEvaluate;$h͏_imports([["./error/assert.js", [["assert",[$h͏_a => (assert = $h͏_a)]]]],["./module-proxy.js", [["getDeferredExports",[$h͏_a => (getDeferredExports = $h͏_a)]]]],["./commons.js", [["ReferenceError",[$h͏_a => (ReferenceError = $h͏_a)]],["SyntaxError",[$h͏_a => (SyntaxError = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["arrayForEach",[$h͏_a => (arrayForEach = $h͏_a)]],["arrayIncludes",[$h͏_a => (arrayIncludes = $h͏_a)]],["arrayPush",[$h͏_a => (arrayPush = $h͏_a)]],["arraySome",[$h͏_a => (arraySome = $h͏_a)]],["arraySort",[$h͏_a => (arraySort = $h͏_a)]],["create",[$h͏_a => (create = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["entries",[$h͏_a => (entries = $h͏_a)]],["freeze",[$h͏_a => (freeze = $h͏_a)]],["isArray",[$h͏_a => (isArray = $h͏_a)]],["keys",[$h͏_a => (keys = $h͏_a)]],["mapGet",[$h͏_a => (mapGet = $h͏_a)]],["weakmapGet",[$h͏_a => (weakmapGet = $h͏_a)]],["reflectHas",[$h͏_a => (reflectHas = $h͏_a)]],["assign",[$h͏_a => (assign = $h͏_a)]]]],["./compartment-evaluate.js", [["compartmentEvaluate",[$h͏_a => (compartmentEvaluate = $h͏_a)]]]]]);

























const { quote: q } = assert;

       const makeVirtualModuleInstance = (
  compartmentPrivateFields,
  moduleSource,
  compartment,
  moduleAliases,
  moduleSpecifier,
  resolvedImports,
) => {
  const { exportsProxy, exportsTarget, activate } = getDeferredExports(
    compartment,
    weakmapGet(compartmentPrivateFields, compartment),
    moduleAliases,
    moduleSpecifier,
  );

  const notifiers = create(null);

  if (moduleSource.exports) {
    if (
      !isArray(moduleSource.exports) ||
      arraySome(moduleSource.exports, name => typeof name !== 'string')
    ) {
      throw TypeError(
        `SES virtual module source "exports" property must be an array of strings for module ${moduleSpecifier}`,
      );
    }
    arrayForEach(moduleSource.exports, name => {
      let value = exportsTarget[name];
      const updaters = [];

      const get = () => value;

      const set = newValue => {
        value = newValue;
        for (const updater of updaters) {
          updater(newValue);
        }
      };

      defineProperty(exportsTarget, name, {
        get,
        set,
        enumerable: true,
        configurable: false,
      });

      notifiers[name] = update => {
        arrayPush(updaters, update);
        update(value);
      };
    });
    // This is enough to support import * from cjs - the '*' field doesn't need to be in exports nor exportsTarget because import will only ever access it via notifiers
    notifiers['*'] = update => {
      update(exportsTarget);
    };
  }

  const localState = {
    activated: false,
  };
  return freeze({
    notifiers,
    exportsProxy,
    execute() {
      if (reflectHas(localState, 'errorFromExecute')) {
        throw localState.errorFromExecute;
      }
      if (!localState.activated) {
        activate();
        localState.activated = true;
        try {
          // eslint-disable-next-line @endo/no-polymorphic-call
          moduleSource.execute(exportsTarget, compartment, resolvedImports);
        } catch (err) {
          localState.errorFromExecute = err;
          throw err;
        }
      }
    },
  });
};

// `makeModuleInstance` takes a module's compartment record, the live import
// namespace, and a global object; and produces a module instance.
// The module instance carries the proxied module exports namespace (the
// "exports"), notifiers to update the module's internal import namespace, and
// an idempotent execute function.
// The module exports namespace is a proxy to the proxied exports namespace
// that the execution of the module instance populates.
$h͏_once.makeVirtualModuleInstance(makeVirtualModuleInstance);const makeModuleInstance=(
  privateFields,
  moduleAliases,
  moduleRecord,
  importedInstances,
) => {
  const {
    compartment,
    moduleSpecifier,
    moduleSource,
    importMeta: moduleRecordMeta,
  } = moduleRecord;
  const {
    reexports: exportAlls = [],
    __syncModuleProgram__: functorSource,
    __fixedExportMap__: fixedExportMap = {},
    __liveExportMap__: liveExportMap = {},
    __reexportMap__: reexportMap = {},
    __needsImport__: needsImport = false,
    __needsImportMeta__: needsImportMeta = false,
    __syncModuleFunctor__,
  } = moduleSource;

  const compartmentFields = weakmapGet(privateFields, compartment);

  const { __shimTransforms__, resolveHook, importMetaHook, compartmentImport } =
    compartmentFields;

  const { exportsProxy, exportsTarget, activate } = getDeferredExports(
    compartment,
    compartmentFields,
    moduleAliases,
    moduleSpecifier,
  );

  // {_exportName_: getter} module exports namespace
  // object (eventually proxied).
  const exportsProps = create(null);

  // {_localName_: accessor} proxy traps for moduleLexicals and live bindings.
  // The moduleLexicals object is frozen and the corresponding properties of
  // moduleLexicals must be immutable, so we copy the descriptors.
  const moduleLexicals = create(null);

  // {_localName_: init(initValue) -> initValue} used by the
  // rewritten code to initialize exported fixed bindings.
  const onceVar = create(null);

  // {_localName_: update(newValue)} used by the rewritten code to
  // both initialize and update live bindings.
  const liveVar = create(null);

  const importMeta = create(null);
  if (moduleRecordMeta) {
    assign(importMeta, moduleRecordMeta);
  }
  if (needsImportMeta && importMetaHook) {
    importMetaHook(moduleSpecifier, importMeta);
  }

  /** @type {(fullSpecifier: string) => Promise<ModuleExportsNamespace>} */
  let dynamicImport;
  if (needsImport) {
    /** @param {string} importSpecifier */
    dynamicImport = async importSpecifier =>
      compartmentImport(resolveHook(importSpecifier, moduleSpecifier));
  }

  // {_localName_: [{get, set, notify}]} used to merge all the export updaters.
  const localGetNotify = create(null);

  // {[importName: string]: notify(update(newValue))} Used by code that imports
  // one of this module's exports, so that their update function will
  // be notified when this binding is initialized or updated.
  const notifiers = create(null);

  arrayForEach(entries(fixedExportMap), ([fixedExportName, [localName]]) => {
    let fixedGetNotify = localGetNotify[localName];
    if (!fixedGetNotify) {
      // fixed binding state
      let value;
      let tdz = true;
      /** @type {null | Array<(value: any) => void>} */
      let optUpdaters = [];

      // tdz sensitive getter
      const get = () => {
        if (tdz) {
          throw ReferenceError(`binding ${q(localName)} not yet initialized`);
        }
        return value;
      };

      // leave tdz once
      const init = freeze(initValue => {
        // init with initValue of a declared const binding, and return
        // it.
        if (!tdz) {
          throw TypeError(
            `Internal: binding ${q(localName)} already initialized`,
          );
        }
        value = initValue;
        const updaters = optUpdaters;
        optUpdaters = null;
        tdz = false;
        for (const updater of updaters || []) {
          updater(initValue);
        }
        return initValue;
      });

      // If still tdz, register update for notification later.
      // Otherwise, update now.
      const notify = updater => {
        if (updater === init) {
          // Prevent recursion.
          return;
        }
        if (tdz) {
          arrayPush(optUpdaters || [], updater);
        } else {
          updater(value);
        }
      };

      // Need these for additional exports of the local variable.
      fixedGetNotify = {
        get,
        notify,
      };
      localGetNotify[localName] = fixedGetNotify;
      onceVar[localName] = init;
    }

    exportsProps[fixedExportName] = {
      get: fixedGetNotify.get,
      set: undefined,
      enumerable: true,
      configurable: false,
    };

    notifiers[fixedExportName] = fixedGetNotify.notify;
  });

  arrayForEach(
    entries(liveExportMap),
    ([liveExportName, [localName, setProxyTrap]]) => {
      let liveGetNotify = localGetNotify[localName];
      if (!liveGetNotify) {
        // live binding state
        let value;
        let tdz = true;
        const updaters = [];

        // tdz sensitive getter
        const get = () => {
          if (tdz) {
            throw ReferenceError(
              `binding ${q(liveExportName)} not yet initialized`,
            );
          }
          return value;
        };

        // This must be usable locally for the translation of initializing
        // a declared local live binding variable.
        //
        // For reexported variable, this is also an update function to
        // register for notification with the downstream import, which we
        // must assume to be live. Thus, it can be called independent of
        // tdz but always leaves tdz. Such reexporting creates a tree of
        // bindings. This lets the tree be hooked up even if the imported
        // module instance isn't initialized yet, as may happen in cycles.
        const update = freeze(newValue => {
          value = newValue;
          tdz = false;
          for (const updater of updaters) {
            updater(newValue);
          }
        });

        // tdz sensitive setter
        const set = newValue => {
          if (tdz) {
            throw ReferenceError(`binding ${q(localName)} not yet initialized`);
          }
          value = newValue;
          for (const updater of updaters) {
            updater(newValue);
          }
        };

        // Always register the updater function.
        // If not in tdz, also update now.
        const notify = updater => {
          if (updater === update) {
            // Prevent recursion.
            return;
          }
          arrayPush(updaters, updater);
          if (!tdz) {
            updater(value);
          }
        };

        liveGetNotify = {
          get,
          notify,
        };

        localGetNotify[localName] = liveGetNotify;
        if (setProxyTrap) {
          defineProperty(moduleLexicals, localName, {
            get,
            set,
            enumerable: true,
            configurable: false,
          });
        }
        liveVar[localName] = update;
      }

      exportsProps[liveExportName] = {
        get: liveGetNotify.get,
        set: undefined,
        enumerable: true,
        configurable: false,
      };

      notifiers[liveExportName] = liveGetNotify.notify;
    },
  );

  const notifyStar = update => {
    update(exportsTarget);
  };
  notifiers['*'] = notifyStar;

  const wireUpExportNotifier = (exportName, notify) => {
    if (!notifiers[exportName] && notify !== false) {
      notifiers[exportName] = notify;

      // exported live binding state
      let value;
      const update = newValue => (value = newValue);
      notify(update);
      exportsProps[exportName] = {
        get() {
          return value;
        },
        set: undefined,
        enumerable: true,
        configurable: false,
      };
    }
  };

  // Per the calling convention for the moduleFunctor generated from
  // an ESM, the `imports` function gets called once up front
  // to populate or arrange the population of imports and reexports.
  // The generated code produces an `updateRecord`: the means for
  // the linker to update the imports and exports of the module.
  // The updateRecord must conform to moduleAnalysis.imports
  // updateRecord = Map<specifier, importUpdaters>
  // importUpdaters = Map<importName, [update(newValue)*]>
  function imports(updateRecord) {
    // By the time imports is called, the importedInstances should already be
    // initialized with module instances that satisfy
    // imports.
    // importedInstances = Map[_specifier_, { notifiers, module, execute }]
    // notifiers = { [importName: string]: notify(update(newValue))}

    // export * cannot export default.
    const candidateAll = create(null);
    candidateAll.default = false;
    for (const [specifier, importUpdaters] of updateRecord) {
      const instance = mapGet(importedInstances, specifier);
      // The module instance object is an internal literal, does not bind this,
      // and never revealed outside the SES shim.
      // There are two instantiation sites for instances and they are both in
      // this module.
      // eslint-disable-next-line @endo/no-polymorphic-call
      instance.execute(); // bottom up cycle tolerant
      const { notifiers: importNotifiers } = instance;
      for (const [importName, updaters] of importUpdaters) {
        const importNotify = importNotifiers[importName];
        if (!importNotify) {
          throw SyntaxError(
            `The requested module '${specifier}' does not provide an export named '${importName}'`,
          );
        }
        for (const updater of updaters) {
          importNotify(updater);
        }
      }
      if (arrayIncludes(exportAlls, specifier)) {
        // Make all these imports candidates.
        // Note names don't change in reexporting all
        for (const [importAndExportName, importNotify] of entries(
          importNotifiers,
        )) {
          if (candidateAll[importAndExportName] === undefined) {
            candidateAll[importAndExportName] = importNotify;
          } else {
            // Already a candidate: remove ambiguity.
            candidateAll[importAndExportName] = false;
          }
        }
      }
      if (reexportMap[specifier]) {
        // Set up reexport notifiers instantly so they are available in cycles.
        for (const [localName, exportedName] of reexportMap[specifier]) {
          wireUpExportNotifier(exportedName, importNotifiers[localName]);
        }
      }
    }

    for (const [exportName, notify] of entries(candidateAll)) {
      wireUpExportNotifier(exportName, notify);
    }

    // Sort the module exports namespace as per spec.
    // The module exports namespace will be wrapped in a module namespace
    // exports proxy which will serve as a "module exports namespace exotic
    // object".
    // Sorting properties is not generally reliable because some properties may
    // be symbols, and symbols do not have an inherent relative order, but
    // since all properties of the exports namespace must be keyed by a string
    // and the string must correspond to a valid identifier, sorting these
    // properties works for this specific case.
    arrayForEach(arraySort(keys(exportsProps)), k =>
      defineProperty(exportsTarget, k, exportsProps[k]),
    );

    freeze(exportsTarget);
    activate();
  }

  let optFunctor;
  if (__syncModuleFunctor__ !== undefined) {
    optFunctor = __syncModuleFunctor__;
  } else {
    optFunctor = compartmentEvaluate(compartmentFields, functorSource, {
      globalObject: compartment.globalThis,
      transforms: __shimTransforms__,
      __moduleShimLexicals__: moduleLexicals,
    });
  }
  let didThrow = false;
  let thrownError;
  function execute() {
    if (optFunctor) {
      // uninitialized
      const functor = optFunctor;
      optFunctor = null;
      // initializing - call with `this` of `undefined`.
      try {
        functor(
          freeze({
            imports: freeze(imports),
            onceVar: freeze(onceVar),
            liveVar: freeze(liveVar),
            import: dynamicImport,
            importMeta,
          }),
        );
      } catch (e) {
        didThrow = true;
        thrownError = e;
      }
      // initialized
    }
    if (didThrow) {
      throw thrownError;
    }
  }

  return freeze({
    notifiers,
    exportsProxy,
    execute,
  });
};$h͏_once.makeModuleInstance(makeModuleInstance);
})()
,
// === 49. ses ./src/module-link.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let assert,makeModuleInstance,makeVirtualModuleInstance,Map,ReferenceError,TypeError,entries,isArray,isPrimitive,mapGet,mapHas,mapSet,weakmapGet;$h͏_imports([["./error/assert.js", [["assert",[$h͏_a => (assert = $h͏_a)]]]],["./module-instance.js", [["makeModuleInstance",[$h͏_a => (makeModuleInstance = $h͏_a)]],["makeVirtualModuleInstance",[$h͏_a => (makeVirtualModuleInstance = $h͏_a)]]]],["./commons.js", [["Map",[$h͏_a => (Map = $h͏_a)]],["ReferenceError",[$h͏_a => (ReferenceError = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["entries",[$h͏_a => (entries = $h͏_a)]],["isArray",[$h͏_a => (isArray = $h͏_a)]],["isPrimitive",[$h͏_a => (isPrimitive = $h͏_a)]],["mapGet",[$h͏_a => (mapGet = $h͏_a)]],["mapHas",[$h͏_a => (mapHas = $h͏_a)]],["mapSet",[$h͏_a => (mapSet = $h͏_a)]],["weakmapGet",[$h͏_a => (weakmapGet = $h͏_a)]]]]]);



















const { Fail, quote: q } = assert;

// `link` creates `ModuleInstances` and `ModuleNamespaces` for a module and its
// transitive dependencies and connects their imports and exports.
// After linking, the resulting working set is ready to be executed.
// The linker only concerns itself with module namespaces that are objects with
// property descriptors for their exports, which the Compartment proxies with
// the actual `ModuleNamespace`.
       const link = (
  compartmentPrivateFields,
  moduleAliases,
  compartment,
  moduleSpecifier,
) => {
  const { name: compartmentName, moduleRecords } = weakmapGet(
    compartmentPrivateFields,
    compartment,
  );

  const moduleRecord = mapGet(moduleRecords, moduleSpecifier);
  if (moduleRecord === undefined) {
    throw ReferenceError(
      `Missing link to module ${q(moduleSpecifier)} from compartment ${q(
        compartmentName,
      )}`,
    );
  }

  // Mutual recursion so there's no confusion about which
  // compartment is in context: the module record may be in another
  // compartment, denoted by moduleRecord.compartment.
  // eslint-disable-next-line no-use-before-define
  return instantiate(compartmentPrivateFields, moduleAliases, moduleRecord);
};$h͏_once.link(link);

function mayBePrecompiledModuleSource(moduleSource) {
  return typeof moduleSource.__syncModuleProgram__ === 'string';
}

function validatePrecompiledModuleSource(moduleSource, moduleSpecifier) {
  const { __fixedExportMap__, __liveExportMap__ } = moduleSource;
  !isPrimitive(__fixedExportMap__) ||
    Fail`Property '__fixedExportMap__' of a precompiled module source must be an object, got ${q(
      __fixedExportMap__,
    )}, for module ${q(moduleSpecifier)}`;
  !isPrimitive(__liveExportMap__) ||
    Fail`Property '__liveExportMap__' of a precompiled module source must be an object, got ${q(
      __liveExportMap__,
    )}, for module ${q(moduleSpecifier)}`;
}

function mayBeVirtualModuleSource(moduleSource) {
  return typeof moduleSource.execute === 'function';
}

function validateVirtualModuleSource(moduleSource, moduleSpecifier) {
  const { exports } = moduleSource;
  isArray(exports) ||
    Fail`Invalid module source: 'exports' of a virtual module source must be an array, got ${q(
      exports,
    )}, for module ${q(moduleSpecifier)}`;
}

function validateModuleSource(moduleSource, moduleSpecifier) {
  !isPrimitive(moduleSource) ||
    Fail`Invalid module source: must be of type object, got ${q(
      moduleSource,
    )}, for module ${q(moduleSpecifier)}`;
  const { imports, exports, reexports = [] } = moduleSource;
  isArray(imports) ||
    Fail`Invalid module source: 'imports' must be an array, got ${q(
      imports,
    )}, for module ${q(moduleSpecifier)}`;
  isArray(exports) ||
    Fail`Invalid module source: 'exports' must be an array, got ${q(
      exports,
    )}, for module ${q(moduleSpecifier)}`;
  isArray(reexports) ||
    Fail`Invalid module source: 'reexports' must be an array if present, got ${q(
      reexports,
    )}, for module ${q(moduleSpecifier)}`;
}

       const instantiate = (
  compartmentPrivateFields,
  moduleAliases,
  moduleRecord,
) => {
  const { compartment, moduleSpecifier, resolvedImports, moduleSource } =
    moduleRecord;
  const { instances } = weakmapGet(compartmentPrivateFields, compartment);

  // Memoize.
  if (mapHas(instances, moduleSpecifier)) {
    return mapGet(instances, moduleSpecifier);
  }

  validateModuleSource(moduleSource, moduleSpecifier);

  const importedInstances = new Map();
  let moduleInstance;
  if (mayBePrecompiledModuleSource(moduleSource)) {
    validatePrecompiledModuleSource(moduleSource, moduleSpecifier);
    moduleInstance = makeModuleInstance(
      compartmentPrivateFields,
      moduleAliases,
      moduleRecord,
      importedInstances,
    );
  } else if (mayBeVirtualModuleSource(moduleSource)) {
    validateVirtualModuleSource(moduleSource, moduleSpecifier);
    moduleInstance = makeVirtualModuleInstance(
      compartmentPrivateFields,
      moduleSource,
      compartment,
      moduleAliases,
      moduleSpecifier,
      resolvedImports,
    );
  } else {
    throw TypeError(`Invalid module source, got ${q(moduleSource)}`);
  }

  // Memoize.
  mapSet(instances, moduleSpecifier, moduleInstance);

  // Link dependency modules.
  for (const [importSpecifier, resolvedSpecifier] of entries(resolvedImports)) {
    const importedInstance = link(
      compartmentPrivateFields,
      moduleAliases,
      compartment,
      resolvedSpecifier,
    );
    mapSet(importedInstances, importSpecifier, importedInstance);
  }

  return moduleInstance;
};$h͏_once.instantiate(instantiate);
})()
,
// === 50. ses ./src/compartment.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let Map,TypeError,WeakMap,arrayFlatMap,assign,defineProperties,identity,promiseThen,toStringTagSymbol,weakmapGet,weakmapSet,setGlobalObjectSymbolUnscopables,setGlobalObjectConstantProperties,setGlobalObjectMutableProperties,setGlobalObjectEvaluators,assert,assertEqual,q,sharedGlobalPropertyNames,load,loadNow,link,getDeferredExports,compartmentEvaluate,makeSafeEvaluator;$h͏_imports([["./commons.js", [["Map",[$h͏_a => (Map = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["WeakMap",[$h͏_a => (WeakMap = $h͏_a)]],["arrayFlatMap",[$h͏_a => (arrayFlatMap = $h͏_a)]],["assign",[$h͏_a => (assign = $h͏_a)]],["defineProperties",[$h͏_a => (defineProperties = $h͏_a)]],["identity",[$h͏_a => (identity = $h͏_a)]],["promiseThen",[$h͏_a => (promiseThen = $h͏_a)]],["toStringTagSymbol",[$h͏_a => (toStringTagSymbol = $h͏_a)]],["weakmapGet",[$h͏_a => (weakmapGet = $h͏_a)]],["weakmapSet",[$h͏_a => (weakmapSet = $h͏_a)]]]],["./global-object.js", [["setGlobalObjectSymbolUnscopables",[$h͏_a => (setGlobalObjectSymbolUnscopables = $h͏_a)]],["setGlobalObjectConstantProperties",[$h͏_a => (setGlobalObjectConstantProperties = $h͏_a)]],["setGlobalObjectMutableProperties",[$h͏_a => (setGlobalObjectMutableProperties = $h͏_a)]],["setGlobalObjectEvaluators",[$h͏_a => (setGlobalObjectEvaluators = $h͏_a)]]]],["./error/assert.js", [["assert",[$h͏_a => (assert = $h͏_a)]],["assertEqual",[$h͏_a => (assertEqual = $h͏_a)]],["q",[$h͏_a => (q = $h͏_a)]]]],["./permits.js", [["sharedGlobalPropertyNames",[$h͏_a => (sharedGlobalPropertyNames = $h͏_a)]]]],["./module-load.js", [["load",[$h͏_a => (load = $h͏_a)]],["loadNow",[$h͏_a => (loadNow = $h͏_a)]]]],["./module-link.js", [["link",[$h͏_a => (link = $h͏_a)]]]],["./module-proxy.js", [["getDeferredExports",[$h͏_a => (getDeferredExports = $h͏_a)]]]],["./compartment-evaluate.js", [["compartmentEvaluate",[$h͏_a => (compartmentEvaluate = $h͏_a)]]]],["./make-safe-evaluator.js", [["makeSafeEvaluator",[$h͏_a => (makeSafeEvaluator = $h͏_a)]]]]]);




































































/**
 * @import {ImportHook, ImportMetaHook, ImportNowHook, ModuleDescriptor, ModuleExportsNamespace, ModuleMap, ModuleMapHook, ResolveHook, ModuleSource, CompartmentOptions} from '../types.js'
 * @import {Transform} from './lockdown.js'
 * @import {DeferredExports} from './module-proxy.js'
 */

/**
 * Associates every public module exports namespace with its corresponding
 * compartment and specifier so they can be used to link modules across
 * compartments. The mechanism to thread an alias is to use the
 * {@link Compartment.module} function to obtain the exports namespace of a foreign
 * module and pass it into another compartment's `moduleMap` constructor option
 * @type {WeakMap<ModuleExportsNamespace, Compartment>}
 *
 */
const moduleAliases = new WeakMap();

/**
 * Private fields for `Compartment` instances
 * @typedef {object} CompartmentFields
 * @property {string} name
 * @property {object} globalObject
 * @property {Array<Transform>} globalTransforms
 * @property {(source: string, options?: {localTransforms?: Array<Transform>}) => void} safeEvaluate
 * @property {ResolveHook} resolveHook
 * @property {ImportHook} importHook
 * @property {ImportNowHook} importNowHook
 * @property {ModuleMap} moduleMap
 * @property {ModuleMapHook} moduleMapHook
 * @property {ImportMetaHook} importMetaHook
 * @property {Map<string, ModuleSource>} moduleRecords
 * @property {Array<Transform>} __shimTransforms__
 * @property {DeferredExports} deferredExports
 * @property {Map<string, ModuleDescriptor>} instances
 * @property {Compartment} [parentCompartment]
 * @property {boolean} noNamespaceBox
 * @property {(fullSpecifier: string) => Promise<ModuleExportsNamespace>} compartmentImport
 * @property {boolean} [noAggregateLoadErrors]
 */

/**
 * Captures the private state for each {@link Compartment}
 * @type {WeakMap<Compartment, CompartmentFields>}
 */
const privateFields = new WeakMap();

       const InertCompartment = function Compartment(
  _endowments = {},
  _modules = {},
  _options = {},
) {
  throw TypeError(
    'Compartment.prototype.constructor is not a valid constructor.',
  );
};

/**
 * @param {Compartment} compartment
 * @param {string} specifier
 * @returns {{namespace: ModuleExportsNamespace}}
 */$h͏_once.InertCompartment(InertCompartment);
const compartmentImportNow = (compartment, specifier) => {
  const { execute, exportsProxy } = link(
    privateFields,
    moduleAliases,
    compartment,
    specifier,
  );
  execute();
  return exportsProxy;
};

/** @type {Compartment & {constructor: typeof InertCompartment}} */
       const CompartmentPrototype = {
  constructor: InertCompartment,

  get globalThis() {
    return /** @type {CompartmentFields} */ (weakmapGet(privateFields, this))
      .globalObject;
  },

  get name() {
    return /** @type {CompartmentFields} */ (weakmapGet(privateFields, this))
      .name;
  },

  evaluate(source, options = {}) {
    const compartmentFields = weakmapGet(privateFields, this);
    return compartmentEvaluate(compartmentFields, source, options);
  },

  module(specifier) {
    if (typeof specifier !== 'string') {
      throw TypeError('first argument of module() must be a string');
    }

    const { exportsProxy } = getDeferredExports(
      this,
      weakmapGet(privateFields, this),
      moduleAliases,
      specifier,
    );

    return exportsProxy;
  },

  async import(specifier) {
    const { noNamespaceBox, noAggregateLoadErrors } =
      /** @type {CompartmentFields} */ (weakmapGet(privateFields, this));

    if (typeof specifier !== 'string') {
      throw TypeError('first argument of import() must be a string');
    }

    return promiseThen(
      load(privateFields, moduleAliases, this, specifier, {
        noAggregateErrors: noAggregateLoadErrors,
      }),
      () => {
        // The namespace box is a contentious design and likely to be a breaking
        // change in an appropriately numbered future version.
        const namespace = compartmentImportNow(
          /** @type {Compartment} */ (this),
          specifier,
        );
        if (noNamespaceBox) {
          return namespace;
        }
        // Legacy behavior: box the namespace object so that thenable modules
        // do not get coerced into a promise accidentally.
        return { namespace };
      },
    );
  },

  async load(specifier) {
    if (typeof specifier !== 'string') {
      throw TypeError('first argument of load() must be a string');
    }

    const { noAggregateLoadErrors } = /** @type {CompartmentFields} */ (
      weakmapGet(privateFields, this)
    );

    return load(privateFields, moduleAliases, this, specifier, {
      noAggregateErrors: noAggregateLoadErrors,
    });
  },

  importNow(specifier) {
    if (typeof specifier !== 'string') {
      throw TypeError('first argument of importNow() must be a string');
    }
    const { noAggregateLoadErrors } = /** @type {CompartmentFields} */ (
      weakmapGet(privateFields, this)
    );

    loadNow(privateFields, moduleAliases, this, specifier, {
      noAggregateErrors: noAggregateLoadErrors,
    });
    return compartmentImportNow(/** @type {Compartment} */ (this), specifier);
  },
};

// This causes `String(new Compartment())` to evaluate to `[object Compartment]`.
// The descriptor follows the conventions of other globals with @@toStringTag
// properties, e.g. Math.
$h͏_once.CompartmentPrototype(CompartmentPrototype);defineProperties(CompartmentPrototype,{
  [toStringTagSymbol]: {
    value: 'Compartment',
    writable: false,
    enumerable: false,
    configurable: true,
  },
});

defineProperties(InertCompartment, {
  prototype: { value: CompartmentPrototype },
});

/**
 * @callback MakeCompartmentConstructor
 * @param {MakeCompartmentConstructor} targetMakeCompartmentConstructor
 * @param {Record<string, any>} intrinsics
 * @param {(object: object) => void} markVirtualizedNativeFunction
 * @param {object} [options]
 * @param {Compartment} [options.parentCompartment]
 * @param {boolean} [options.enforceNew]
 * @returns {Compartment['constructor']}
 */

/**
 * "Options bag"-style `Compartment` constructor arguments.
 * @typedef {[options?: CompartmentOptions & { __options__: true }]} CompartmentOptionsArgs
 */

/**
 * Legacy `Compartment` constructor arguments.
 *
 * @deprecated
 * @typedef {[globals?: Map<string, any>, modules?: Map<string, ModuleDescriptor>, options?: CompartmentOptions]} LegacyCompartmentOptionsArgs
 */

/**
 * In order to facilitate migration from the deprecated signature of the
 * compartment constructor,
 *
 * `new Compartent(globals?, modules?, options?)`
 *
 * to the new signature:
 *
 * `new Compartment(options?)`
 *
 * ...where globals and modules are expressed in the options bag instead of
 * positional arguments, this function detects the temporary sigil __options__
 * on the first argument and coerces compartments arguments into a single
 * compartments object.
 * @param {CompartmentOptionsArgs|LegacyCompartmentOptionsArgs} args
 * @returns {CompartmentOptions}
 */
       const compartmentOptions = (...args) => {
  if (args.length === 0) {
    return {};
  }
  if (
    args.length === 1 &&
    typeof args[0] === 'object' &&
    args[0] !== null &&
    '__options__' in args[0]
  ) {
    const { __options__, ...options } = args[0];
    assert(
      __options__ === true,
      `Compartment constructor only supports true __options__ sigil, got ${__options__}`,
    );
    return options;
  } else {
    const [
      globals = /** @type {Map<string, any>} */ ({}),
      modules = /** @type {Map<string, ModuleDescriptor>} */ ({}),
      options = {},
    ] = /** @type {LegacyCompartmentOptionsArgs} */ (args);
    assertEqual(
      options.modules,
      undefined,
      `Compartment constructor must receive either a module map argument or modules option, not both`,
    );
    assertEqual(
      options.globals,
      undefined,
      `Compartment constructor must receive either globals argument or option, not both`,
    );
    return {
      ...options,
      globals,
      modules,
    };
  }
};

/** @type {MakeCompartmentConstructor} */$h͏_once.compartmentOptions(compartmentOptions);
       const makeCompartmentConstructor = (
  targetMakeCompartmentConstructor,
  intrinsics,
  markVirtualizedNativeFunction,
  { parentCompartment = undefined, enforceNew = false } = {},
) => {
  /**
   *
   * @param {CompartmentOptionsArgs|LegacyCompartmentOptionsArgs} args
   */
  function Compartment(...args) {
    if (enforceNew && new.target === undefined) {
      throw TypeError(
        "Class constructor Compartment cannot be invoked without 'new'",
      );
    }

    // Extract options, and shallow-clone transforms.
    const {
      name = '<unknown>',
      transforms = [],
      __shimTransforms__ = [],
      globals: endowmentsOption = {},
      modules: moduleMapOption = {},
      resolveHook,
      importHook,
      importNowHook,
      moduleMapHook,
      importMetaHook,
      __noNamespaceBox__: noNamespaceBox = false,
      noAggregateLoadErrors = false,
    } = compartmentOptions(...args);
    const globalTransforms = arrayFlatMap(
      [transforms, __shimTransforms__],
      identity,
    );
    const endowments = { __proto__: null, ...endowmentsOption };
    const moduleMap = { __proto__: null, ...moduleMapOption };

    // Map<FullSpecifier, ModuleCompartmentRecord>
    const moduleRecords = new Map();
    // Map<FullSpecifier, ModuleInstance>
    const instances = new Map();
    // Map<FullSpecifier, {ExportsProxy, ProxiedExports, activate()}>
    const deferredExports = new Map();

    const globalObject = {};

    const compartment = this;

    setGlobalObjectSymbolUnscopables(globalObject);

    // We must initialize all constant properties first because
    // `makeSafeEvaluator` may use them to create optimized bindings
    // in the evaluator.
    // TODO: consider merging into a single initialization if internal
    // evaluator is no longer eagerly created
    setGlobalObjectConstantProperties(globalObject);

    const { safeEvaluate } = makeSafeEvaluator({
      globalObject,
      globalTransforms,
      sloppyGlobalsMode: false,
    });

    setGlobalObjectMutableProperties(globalObject, {
      intrinsics,
      newGlobalPropertyNames: sharedGlobalPropertyNames,
      makeCompartmentConstructor: targetMakeCompartmentConstructor,
      parentCompartment: this,
      markVirtualizedNativeFunction,
    });

    // TODO: maybe add evalTaming to the Compartment constructor 3rd options?
    setGlobalObjectEvaluators(
      globalObject,
      safeEvaluate,
      markVirtualizedNativeFunction,
    );

    assign(globalObject, endowments);

    /**
     * In support dynamic import in a module source loaded by this compartment,
     * like `await import(importSpecifier)`, induces this compartment to import
     * a module, returning a promise for the resulting module exports
     * namespace.
     * Unlike `compartment.import`, never creates a box object for the
     * namespace as that behavior is deprecated and inconsistent with the
     * standard behavior of dynamic import.
     * Obliges the caller to resolve import specifiers to their corresponding
     * full specifier.
     * That is, every module must have its own dynamic import function that
     * closes over the surrounding module's full module specifier and calls
     * through to this function.
     * @param {string} fullSpecifier - A full specifier is a key in the
     * compartment's module memo.
     * The method `compartment.import` accepts a full specifier, but dynamic
     * import accepts an import specifier and resolves it to a full specifier
     * relative to the calling module's full specifier.
     * @returns {Promise<ModuleExportsNamespace>}
     */
    const compartmentImport = async fullSpecifier => {
      if (typeof resolveHook !== 'function') {
        throw TypeError(
          `Compartment does not support dynamic import: no configured resolveHook for compartment ${q(name)}`,
        );
      }
      await load(privateFields, moduleAliases, compartment, fullSpecifier, {
        noAggregateErrors: noAggregateLoadErrors,
      });
      const { execute, exportsProxy } = link(
        privateFields,
        moduleAliases,
        compartment,
        fullSpecifier,
      );
      execute();
      return exportsProxy;
    };

    weakmapSet(privateFields, this, {
      name: `${name}`,
      globalTransforms,
      globalObject,
      safeEvaluate,
      resolveHook,
      importHook,
      importNowHook,
      moduleMap,
      moduleMapHook,
      importMetaHook,
      moduleRecords,
      __shimTransforms__,
      deferredExports,
      instances,
      parentCompartment,
      noNamespaceBox,
      compartmentImport,
      noAggregateLoadErrors,
    });
  }

  Compartment.prototype = CompartmentPrototype;

  return Compartment;
};$h͏_once.makeCompartmentConstructor(makeCompartmentConstructor);
})()
,
// === 51. ses ./src/get-anonymous-intrinsics.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let FERAL_FUNCTION,Float32Array,Map,Set,String,getOwnPropertyDescriptor,getPrototypeOf,iterateArray,iterateMap,iterateSet,iterateString,matchAllRegExp,matchAllSymbol,regexpPrototype,globalThis,assign,AsyncGeneratorFunctionInstance,ArrayBuffer,InertCompartment;$h͏_imports([["./commons.js", [["FERAL_FUNCTION",[$h͏_a => (FERAL_FUNCTION = $h͏_a)]],["Float32Array",[$h͏_a => (Float32Array = $h͏_a)]],["Map",[$h͏_a => (Map = $h͏_a)]],["Set",[$h͏_a => (Set = $h͏_a)]],["String",[$h͏_a => (String = $h͏_a)]],["getOwnPropertyDescriptor",[$h͏_a => (getOwnPropertyDescriptor = $h͏_a)]],["getPrototypeOf",[$h͏_a => (getPrototypeOf = $h͏_a)]],["iterateArray",[$h͏_a => (iterateArray = $h͏_a)]],["iterateMap",[$h͏_a => (iterateMap = $h͏_a)]],["iterateSet",[$h͏_a => (iterateSet = $h͏_a)]],["iterateString",[$h͏_a => (iterateString = $h͏_a)]],["matchAllRegExp",[$h͏_a => (matchAllRegExp = $h͏_a)]],["matchAllSymbol",[$h͏_a => (matchAllSymbol = $h͏_a)]],["regexpPrototype",[$h͏_a => (regexpPrototype = $h͏_a)]],["globalThis",[$h͏_a => (globalThis = $h͏_a)]],["assign",[$h͏_a => (assign = $h͏_a)]],["AsyncGeneratorFunctionInstance",[$h͏_a => (AsyncGeneratorFunctionInstance = $h͏_a)]],["ArrayBuffer",[$h͏_a => (ArrayBuffer = $h͏_a)]]]],["./compartment.js", [["InertCompartment",[$h͏_a => (InertCompartment = $h͏_a)]]]]]);





















/**
 * Object.getConstructorOf()
 * Helper function to improve readability, similar to Object.getPrototypeOf().
 *
 * @param {object} obj
 */
function getConstructorOf(obj) {
  return getPrototypeOf(obj).constructor;
}

// getAnonymousIntrinsics uses a utility function to construct an arguments
// object, since it cannot have one of its own and also be a const export.
function makeArguments() {
  // eslint-disable-next-line prefer-rest-params
  return arguments;
}

/**
 * getAnonymousIntrinsics()
 * Get the intrinsics not otherwise reachable by named own property
 * traversal from the global object.
 *
 * @returns {object}
 */
       const getAnonymousIntrinsics = () => {
  const InertFunction = FERAL_FUNCTION.prototype.constructor;

  // 9.2.4.1 %ThrowTypeError%

  const argsCalleeDesc = getOwnPropertyDescriptor(makeArguments(), 'callee');
  const ThrowTypeError = argsCalleeDesc && argsCalleeDesc.get;

  // 21.1.5.2 The %StringIteratorPrototype% Object

  // eslint-disable-next-line no-new-wrappers
  const StringIteratorObject = iterateString(new String());
  const StringIteratorPrototype = getPrototypeOf(StringIteratorObject);

  // 21.2.7.1 The %RegExpStringIteratorPrototype% Object
  const RegExpStringIterator =
    regexpPrototype[matchAllSymbol] && matchAllRegExp(/./);
  const RegExpStringIteratorPrototype =
    RegExpStringIterator && getPrototypeOf(RegExpStringIterator);

  // 22.1.5.2 The %ArrayIteratorPrototype% Object

  // eslint-disable-next-line no-array-constructor
  const ArrayIteratorObject = iterateArray([]);
  const ArrayIteratorPrototype = getPrototypeOf(ArrayIteratorObject);

  // 22.2.1 The %TypedArray% Intrinsic Object

  const TypedArray = getPrototypeOf(Float32Array);

  // 23.1.5.2 The %MapIteratorPrototype% Object

  const MapIteratorObject = iterateMap(new Map());
  const MapIteratorPrototype = getPrototypeOf(MapIteratorObject);

  // 23.2.5.2 The %SetIteratorPrototype% Object

  const SetIteratorObject = iterateSet(new Set());
  const SetIteratorPrototype = getPrototypeOf(SetIteratorObject);

  // 25.1.2 The %IteratorPrototype% Object

  const IteratorPrototype = getPrototypeOf(ArrayIteratorPrototype);

  // 25.2.1 The GeneratorFunction Constructor

  // eslint-disable-next-line no-empty-function
  function* GeneratorFunctionInstance() {}
  const GeneratorFunction = getConstructorOf(GeneratorFunctionInstance);

  // 25.2.3 Properties of the GeneratorFunction Prototype Object

  const Generator = GeneratorFunction.prototype;

  // 25.7.1 The AsyncFunction Constructor

  // eslint-disable-next-line no-empty-function
  async function AsyncFunctionInstance() {}
  const AsyncFunction = getConstructorOf(AsyncFunctionInstance);

  const intrinsics = {
    '%InertFunction%': InertFunction,
    '%ArrayIteratorPrototype%': ArrayIteratorPrototype,
    '%InertAsyncFunction%': AsyncFunction,
    '%Generator%': Generator,
    '%InertGeneratorFunction%': GeneratorFunction,
    '%IteratorPrototype%': IteratorPrototype,
    '%MapIteratorPrototype%': MapIteratorPrototype,
    '%RegExpStringIteratorPrototype%': RegExpStringIteratorPrototype,
    '%SetIteratorPrototype%': SetIteratorPrototype,
    '%StringIteratorPrototype%': StringIteratorPrototype,
    '%ThrowTypeError%': ThrowTypeError,
    '%TypedArray%': TypedArray,
    '%InertCompartment%': InertCompartment,
  };

  if (AsyncGeneratorFunctionInstance !== undefined) {
    // 25.3.1 The AsyncGeneratorFunction Constructor

    const AsyncGeneratorFunction = getConstructorOf(
      AsyncGeneratorFunctionInstance,
    );

    // 25.3.2.2 AsyncGeneratorFunction.prototype
    const AsyncGenerator = AsyncGeneratorFunction.prototype;
    // 25.5.1 Properties of the AsyncGenerator Prototype Object
    const AsyncGeneratorPrototype = AsyncGenerator.prototype;
    const AsyncIteratorPrototype = getPrototypeOf(AsyncGeneratorPrototype);

    assign(intrinsics, {
      '%AsyncGenerator%': AsyncGenerator,
      '%InertAsyncGeneratorFunction%': AsyncGeneratorFunction,
      '%AsyncGeneratorPrototype%': AsyncGeneratorPrototype,
      '%AsyncIteratorPrototype%': AsyncIteratorPrototype,
    });
  }

  if (globalThis.Iterator) {
    intrinsics['%IteratorHelperPrototype%'] = getPrototypeOf(
      // eslint-disable-next-line @endo/no-polymorphic-call
      globalThis.Iterator.from([]).take(0),
    );
    intrinsics['%WrapForValidIteratorPrototype%'] = getPrototypeOf(
      // eslint-disable-next-line @endo/no-polymorphic-call
      globalThis.Iterator.from({
        next() {
          return { value: undefined };
        },
      }),
    );
  }

  if (globalThis.AsyncIterator) {
    intrinsics['%AsyncIteratorHelperPrototype%'] = getPrototypeOf(
      // eslint-disable-next-line @endo/no-polymorphic-call
      globalThis.AsyncIterator.from([]).take(0),
    );
    intrinsics['%WrapForValidAsyncIteratorPrototype%'] = getPrototypeOf(
      // eslint-disable-next-line @endo/no-polymorphic-call
      globalThis.AsyncIterator.from({ next() {} }),
    );
  }

  const ab = new ArrayBuffer(0);
  // eslint-disable-next-line @endo/no-polymorphic-call
  const iab = ab.sliceToImmutable();
  const iabProto = getPrototypeOf(iab);
  if (iabProto !== ArrayBuffer.prototype) {
    // In a native implementation, these will be the same prototype
    intrinsics['%ImmutableArrayBufferPrototype%'] = iabProto;
  }

  return intrinsics;
};$h͏_once.getAnonymousIntrinsics(getAnonymousIntrinsics);
})()
,
// === 52. ses ./src/tame-harden.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let freeze;$h͏_imports([["./commons.js", [["freeze",[$h͏_a => (freeze = $h͏_a)]]]]]);


/** @import {Harden} from '../types.js'; */

/** @type {(safeHarden: Harden, hardenTaming: 'safe' | 'unsafe') => Harden} */
       const tameHarden = (safeHarden, hardenTaming) => {
  if (hardenTaming === 'safe') {
    return safeHarden;
  }

  // In on the joke
  Object.isExtensible = () => false;
  Object.isFrozen = () => true;
  Object.isSealed = () => true;
  Reflect.isExtensible = () => false;

  // @ts-expect-error secret property
  if (safeHarden.isFake) {
    // The "safe" hardener is already a fake hardener.
    // Just use it.
    return safeHarden;
  }

  const fakeHarden = arg => arg;
  fakeHarden.isFake = true;
  return freeze(fakeHarden);
};$h͏_once.tameHarden(tameHarden);
freeze(tameHarden);
})()
,
// === 53. ses ./src/tame-symbol-constructor.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let Symbol,entries,fromEntries,getOwnPropertyDescriptors,defineProperties,arrayMap,functionBind;$h͏_imports([["./commons.js", [["Symbol",[$h͏_a => (Symbol = $h͏_a)]],["entries",[$h͏_a => (entries = $h͏_a)]],["fromEntries",[$h͏_a => (fromEntries = $h͏_a)]],["getOwnPropertyDescriptors",[$h͏_a => (getOwnPropertyDescriptors = $h͏_a)]],["defineProperties",[$h͏_a => (defineProperties = $h͏_a)]],["arrayMap",[$h͏_a => (arrayMap = $h͏_a)]],["functionBind",[$h͏_a => (functionBind = $h͏_a)]]]]]);









/**
 * This taming provides a tamed alternative to the original `Symbol` constructor
 * that starts off identical, except that all its properties are "temporarily"
 * configurable. The original `Symbol` constructor remains unmodified on
 * the start compartment's global. The tamed alternative is used as the shared
 * `Symbol` constructor on constructed compartments.
 *
 * Starting these properties as configurable assumes two succeeding phases of
 * processing: A permit enforcement phase, that
 * removes all properties not on the permits (which requires them to be
 * configurable) and a global hardening step that freezes all primordials,
 * returning these properties to their expected non-configurable status.
 *
 * The ses shim is constructed to eventually enable vetted shims to run between
 * repair and global hardening. However, such vetted shims would normally
 * run in the start compartment, which continues to use the original unmodified
 * `Symbol`, so they should not normally be affected by the temporary
 * configurability of these properties.
 *
 * Note that the spec refers to the global `Symbol` function as the
 * ["Symbol Constructor"](https://tc39.es/ecma262/multipage/fundamental-objects.html#sec-symbol-constructor)
 * even though it has a call behavior (can be called as a function) and does not
 * not have a construct behavior (cannot be called with `new`). Accordingly,
 * to tame it, we must replace it with a function without a construct
 * behavior.
 */
       const tameSymbolConstructor = () => {
  const OriginalSymbol = Symbol;
  const SymbolPrototype = OriginalSymbol.prototype;

  // Bypass Hermes bug, fixed in: https://github.com/facebook/hermes/commit/00f18c89c720e1c34592bb85a1a8d311e6e99599
  // Make a "copy" of the primordial [Symbol "constructor"](https://tc39.es/ecma262/#sec-symbol-description) which maintains all observable behavior. The primordial explicitly throws on `[[Construct]]` and has a `[[Call]]` which ignores the receiver. Binding also maintains the `toString` source as a native function. The `name` is restored below when copying own properties.
  const SharedSymbol = functionBind(Symbol, undefined);

  defineProperties(SymbolPrototype, {
    constructor: {
      value: SharedSymbol
      // leave other `constructor` attributes as is
    },
  });

  const originalDescsEntries = entries(
    getOwnPropertyDescriptors(OriginalSymbol),
  );
  const descs = fromEntries(
    arrayMap(originalDescsEntries, ([name, desc]) => [
      name,
      { ...desc, configurable: true },
    ]),
  );
  defineProperties(SharedSymbol, descs);

  return { '%SharedSymbol%': SharedSymbol };
};$h͏_once.tameSymbolConstructor(tameSymbolConstructor);
})()
,
// === 54. ses ./src/tame-faux-data-properties.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let getOwnPropertyDescriptor,apply,defineProperty,toStringTagSymbol;$h͏_imports([["./commons.js", [["getOwnPropertyDescriptor",[$h͏_a => (getOwnPropertyDescriptor = $h͏_a)]],["apply",[$h͏_a => (apply = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["toStringTagSymbol",[$h͏_a => (toStringTagSymbol = $h͏_a)]]]]]);






const throws = thunk => {
  try {
    thunk();
    return false;
  } catch (er) {
    return true;
  }
};

/**
 * Exported for convenience of unit testing. Harmless, but not expected
 * to be useful by itself.
 *
 * @param {any} obj
 * @param {string|symbol} prop
 * @param {any} expectedValue
 * @returns {boolean}
 * Returns whether `tameFauxDataProperty` turned the property in question
 * from an apparent faux data property into the actual data property it
 * seemed to emulate.
 * If this function returns `false`, then we hope no effects happened.
 * However, sniffing out if an accessor property seems to be a faux data
 * property requires invoking the getter and setter functions that might
 * possibly have side effects.
 * `tameFauxDataProperty` is not in a position to tell.
 */
       const tameFauxDataProperty = (obj, prop, expectedValue) => {
  if (obj === undefined) {
    // The object does not exist in this version of the platform
    return false;
  }
  const desc = getOwnPropertyDescriptor(obj, prop);
  if (!desc || 'value' in desc) {
    // The property either doesn't exist, or is already an actual data property.
    return false;
  }
  const { get, set } = desc;
  if (typeof get !== 'function' || typeof set !== 'function') {
    // A faux data property has both a getter and a setter
    return false;
  }
  if (get() !== expectedValue) {
    // The getter called by itself should produce the expectedValue
    return false;
  }
  if (apply(get, obj, []) !== expectedValue) {
    // The getter called with `this === obj` should also return the
    // expectedValue.
    return false;
  }
  const testValue = 'Seems to be a setter';
  const subject1 = { __proto__: null };
  apply(set, subject1, [testValue]);
  if (subject1[prop] !== testValue) {
    // The setter called with an unrelated object as `this` should
    // set the property on the object.
    return false;
  }
  const subject2 = { __proto__: obj };
  apply(set, subject2, [testValue]);
  if (subject2[prop] !== testValue) {
    // The setter called on an object that inherits from `obj` should
    // override the property from `obj` as if by assignment.
    return false;
  }
  if (!throws(() => apply(set, obj, [expectedValue]))) {
    // The setter called with `this === obj` should throw without having
    // caused any effect.
    // This is the test that has the greatest danger of leaving behind some
    // persistent side effect. The most obvious one is to emulate a
    // successful assignment to the property. That's why this test
    // uses `expectedValue`, so that case is likely not to actually
    // change anything.
    return false;
  }
  if ('originalValue' in get) {
    // The ses-shim uniquely, as far as we know, puts an `originalValue`
    // property on the getter, so that reflect property tranversal algorithms,
    // like `harden`, will traverse into the enulated value without
    // calling the getter. That does not happen until `permits-intrinsics.js`
    // which is much later. So if we see one this early, we should
    // not assume we understand what's going on.
    return false;
  }

  // We assume that this code runs before any untrusted code runs, so
  // we do not need to worry about the above conditions passing because of
  // malicious intent. In fact, it runs even before vetted shims are supposed
  // to run, between repair and hardening. Given that, after all these tests
  // pass, we have adequately validated that the property in question is
  // an accessor function whose purpose is suppressing the override mistake,
  // i.e., enabling a non-writable property to be overridden by assignment.
  // In that case, here we *temporarily* turn it into the data property
  // it seems to emulate, but writable so that it does not trigger the
  // override mistake while in this temporary state.

  // For those properties that are also listed in `enablements.js`,
  // that phase will re-enable override for these properties, but
  // via accessor functions that SES controls, so we know what they are
  // doing. In addition, the getter functions installed by
  // `enable-property-overrides.js` have an `originalValue` field
  // enabling meta-traversal code like harden to visit the original value
  // without calling the getter.

  if (desc.configurable === false) {
    // Even though it seems to be a faux data property, we're unable to fix it.
    return false;
  }

  // Many of the `return false;` cases above plausibly should be turned into
  // errors, or an least generate warnings. However, for those, the checks
  // following this phase are likely to signal an error anyway.

  // At this point, we have passed all our sniff checks for validating that
  // it seems to be a faux data property with the expected value. Turn
  // it into the actual data property it emulates, but writable so there is
  // not yet an override mistake problem.

  defineProperty(obj, prop, {
    value: expectedValue,
    writable: true,
    enumerable: desc.enumerable,
    configurable: true,
  });

  return true;
};

/**
 * In JavaScript, the so-called "override mistake" is the inability to
 * override an inherited non-writable data property by assignment. A common
 * workaround is to instead define an accessor property that acts like
 * a non-writable data property, except that it allows an object that
 * inherits this property to override it by assignment. Let's call
 * an access property that acts this way a "faux data property". In this
 * ses-shim, `enable-property-overrides.js` makes the properties listed in
 * `enablements.js` into faux data properties.
 *
 * But the ses-shim is not alone in use of this trick. Starting with the
 * [Iterator Helpers proposal](https://github.com/tc39/proposal-iterator-helpers),
 * some properties are defined as (what we call) faux data properties.
 * Some of these are new properties (`Interator.prototype.constructor`) and
 * some are old data properties converted to accessor properties
 * (`Iterator.prototype[String.toStringTag]`). So the ses-shim needs to be
 * prepared for some enumerated set of properties to already be faux data
 * properties in the platform prior to our initialization.
 *
 * For these possible faux data properties, it is important that
 * `permits.js` describe each as a data property, so that it can further
 * constrain the apparent value (that allegedly would be returned by the
 * getter) according to its own permits.
 *
 * However, at the time of this writing, the precise behavior specified
 * by the iterator-helpers proposal for these faux data properties is
 * novel. We should not be too confident that all further such platform
 * additions do what we would now expect. So, for each of these possible
 * faux data properties, we do some sniffing to see if it behaves as we
 * currently expect a faux data property to act. If not, then
 * `tameFauxDataProperties` tries not to modify it, leaving it to later
 * checks, especially `permits-intrinsics.js`, to error when it sees an
 * unexpected accessor.
 *
 * If one of these enumerated accessor properties does seem to be
 * a faithful faux data property, then `tameFauxDataProperties` itself
 * *tempoarily* turns it into the actual data property that it seems to emulate.
 * This data property starts as writable, so that in this state it will
 * not trigger the override mistake, i.e., assignment to an object inheriting
 * this property is allowed to succeed at overriding this property.
 *
 * For those properties that should be a faux data property rather than an
 * actual one, such as those from the iterator-helpers proposal,
 * they should be listed as such in `enablements.js`, so
 * `enable-property-overrides.js` will turn it back into a faux data property.
 * But one controlled by the ses-shim, whose behavior we understand.
 *
 * `tameFauxDataProperties`, which turns these into actual data properties,
 * happens during the `repairIntrinsics` phase
 * of `lockdown`, before even vetted shim are supposed to run.
 * `enable-property-overrides.js` runs after vetted shims, turning the
 * appropriate ones back into faux data properties. Thus vetted shims
 * can observe the possibly non-conforming state where these are temporarily
 * actual data properties, rather than faux data properties.
 *
 * Coordinate the property enumeration here
 * with `enablements.js`, so the appropriate properties are
 * turned back to faux data properties.
 *
 * @param {Record<any,any>} intrinsics
 */$h͏_once.tameFauxDataProperty(tameFauxDataProperty);
       const tameFauxDataProperties = intrinsics => {
  // https://github.com/tc39/proposal-iterator-helpers
  tameFauxDataProperty(
    intrinsics['%IteratorPrototype%'],
    'constructor',
    intrinsics.Iterator,
  );
  // https://github.com/tc39/proposal-iterator-helpers
  tameFauxDataProperty(
    intrinsics['%IteratorPrototype%'],
    toStringTagSymbol,
    'Iterator',
  );
};$h͏_once.tameFauxDataProperties(tameFauxDataProperties);
})()
,
// === 55. ses ./src/tame-regenerator-runtime.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let defineProperty,iteratorPrototype,iteratorSymbol,hasOwn;$h͏_imports([["./commons.js", [["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]],["iteratorPrototype",[$h͏_a => (iteratorPrototype = $h͏_a)]],["iteratorSymbol",[$h͏_a => (iteratorSymbol = $h͏_a)]],["hasOwn",[$h͏_a => (hasOwn = $h͏_a)]]]]]);






       const tameRegeneratorRuntime = () => {
  const iter = iteratorPrototype[iteratorSymbol];
  defineProperty(iteratorPrototype, iteratorSymbol, {
    configurable: true,
    get() {
      return iter;
    },
    set(value) {
      // ignore the assignment on IteratorPrototype
      if (this === iteratorPrototype) return;
      if (hasOwn(this, iteratorSymbol)) {
        this[iteratorSymbol] = value;
      }
      defineProperty(this, iteratorSymbol, {
        value,
        writable: true,
        enumerable: true,
        configurable: true,
      });
    },
  });
};$h͏_once.tameRegeneratorRuntime(tameRegeneratorRuntime);
})()
,
// === 56. ses ./src/shim-arraybuffer-transfer.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let ArrayBuffer,arrayBufferPrototype,arrayBufferSlice,arrayBufferGetByteLength,Uint8Array,typedArraySet,globalThis,TypeError,defineProperty;$h͏_imports([["./commons.js", [["ArrayBuffer",[$h͏_a => (ArrayBuffer = $h͏_a)]],["arrayBufferPrototype",[$h͏_a => (arrayBufferPrototype = $h͏_a)]],["arrayBufferSlice",[$h͏_a => (arrayBufferSlice = $h͏_a)]],["arrayBufferGetByteLength",[$h͏_a => (arrayBufferGetByteLength = $h͏_a)]],["Uint8Array",[$h͏_a => (Uint8Array = $h͏_a)]],["typedArraySet",[$h͏_a => (typedArraySet = $h͏_a)]],["globalThis",[$h͏_a => (globalThis = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["defineProperty",[$h͏_a => (defineProperty = $h͏_a)]]]]]);











       const shimArrayBufferTransfer = () => {
  if (typeof arrayBufferPrototype.transfer === 'function') {
    // Assume already exists so does not need to be shimmed.
    // Such conditional shimming is ok in this case since ArrayBuffer.p.transfer
    // is already officially part of JS.
    //
    // Empty object because this shim has nothing for `addIntrinsics` to add.
    return {};
  }
  const clone = globalThis.structuredClone;
  if (typeof clone !== 'function') {
    // On a platform with neither `Array.prototype.transfer`
    // nor `structuredClone`, this shim does nothing.
    // For example, Node <= 16 has neither.
    //
    // Empty object because this shim has nothing for `addIntrinsics` to add.
    return {};
    // TODO Rather than doing nothing, should the endo ses-shim throw
    // in this case?
    // throw TypeError(
    //   `Can only shim missing ArrayBuffer.prototype.transfer on a platform with "structuredClone"`,
    // );
    // For example, endo no longer supports Node <= 16. All browsers have
    // `structuredClone`. XS has `Array.prototype.transfer`. Are there still
    // any platforms without both that Endo should still support?
    // What about Hermes?
  }

  /**
   * @type {ThisType<ArrayBuffer>}
   */
  const methods = {
    /**
     * @param {number} [newLength]
     */
    transfer(newLength = undefined) {
      // Using this builtin getter also ensures that `this` is a genuine
      // ArrayBuffer.
      const oldLength = arrayBufferGetByteLength(this);
      if (newLength === undefined || newLength === oldLength) {
        return clone(this, { transfer: [this] });
      }
      if (typeof newLength !== 'number') {
        throw TypeError(`transfer newLength if provided must be a number`);
      }
      if (newLength > oldLength) {
        const result = new ArrayBuffer(newLength);
        const taOld = new Uint8Array(this);
        const taNew = new Uint8Array(result);
        typedArraySet(taNew, taOld);
        // Using clone only to detach, and only after the copy succeeds
        clone(this, { transfer: [this] });
        return result;
      } else {
        const result = arrayBufferSlice(this, 0, newLength);
        // Using clone only to detach, and only after the slice succeeds
        clone(this, { transfer: [this] });
        return result;
      }
    },
  };

  defineProperty(arrayBufferPrototype, 'transfer', {
    // @ts-expect-error
    value: methods.transfer,
    writable: true,
    enumerable: false,
    configurable: true,
  });

  // Empty object because this shim has nothing for `addIntrinsics` to add.
  return {};
};$h͏_once.shimArrayBufferTransfer(shimArrayBufferTransfer);
})()
,
// === 57. ses ./src/reporting.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let globalThis,assert;$h͏_imports([["./commons.js", [["globalThis",[$h͏_a => (globalThis = $h͏_a)]]]],["./error/assert.js", [["assert",[$h͏_a => (assert = $h͏_a)]]]]]);


/**
 * @import {Reporter, GroupReporter} from './reporting-types.js'
 */

/* eslint-disable @endo/no-polymorphic-call */
/**
 * To address https://github.com/endojs/endo/issues/2908,
 * the `consoleReporter` uses the current `console` rather
 * than the original one.
 *
 * @type {GroupReporter}
 */
const consoleReporter = {
  warn(...args) {
    globalThis.console.warn(...args);
  },
  error(...args) {
    globalThis.console.error(...args);
  },
  ...(globalThis.console?.groupCollapsed
    ? {
        groupCollapsed(...args) {
          globalThis.console.groupCollapsed(...args);
        },
      }
    : undefined),
  ...(globalThis.console?.groupEnd
    ? {
        groupEnd() {
          globalThis.console.groupEnd();
        },
      }
    : undefined),
};
/* eslint-enable @endo/no-polymorphic-call */

/**
 * Creates a suitable reporter for internal errors and warnings out of the
 * Node.js console.error to ensure all messages go to stderr, including the
 * group label.
 * Accounts for the extra space introduced by console.error as a delimiter
 * between the indent and subsequent arguments.
 *
 * @param {(...message: Array<any>) => void} print
 */
const makeReportPrinter = print => {
  let indent = false;
  /** @param {Array<any>} args */
  const printIndent = (...args) => {
    if (indent) {
      print(' ', ...args);
    } else {
      print(...args);
    }
  };
  return /** @type {GroupReporter} */ ({
    warn(...args) {
      printIndent(...args);
    },
    error(...args) {
      printIndent(...args);
    },
    groupCollapsed(...args) {
      assert(!indent);
      print(...args);
      indent = true;
    },
    groupEnd() {
      indent = false;
    },
  });
};

const mute = () => {};

/**
 * @param {"platform" | "console" | "none"} reporting
 */
       const chooseReporter = reporting => {
  if (reporting === 'none') {
    return makeReportPrinter(mute);
  }
  if (globalThis.console !== undefined) {
    if (
      reporting === 'console' || // asks for console explicitly
      globalThis.window === globalThis || // likely on browser
      globalThis.importScripts !== undefined // likely on worker
    ) {
      // reporter just delegates directly to the current console
      return consoleReporter;
    }
    assert(reporting === 'platform');
    // On Node.js, we send all feedback to stderr, regardless of purported level.
    // This uses `consoleReporter.error` instead of `console.error` because we
    // want the constructed reporter to use the `console.error` of the current
    // `console`, not the `console` that was installed when the reporter
    // was created.
    return makeReportPrinter(consoleReporter.error);
  }
  if (globalThis.print !== undefined) {
    return makeReportPrinter(globalThis.print);
  }
  return makeReportPrinter(mute);
};

/**
 * @param {string} groupLabel
 * @param {GroupReporter} console
 * @param {(internalConsole: Reporter) => void} callback
 */$h͏_once.chooseReporter(chooseReporter);
       const reportInGroup = (groupLabel, console, callback) => {
  const { warn, error, groupCollapsed, groupEnd } = console;
  const grouping = groupCollapsed && groupEnd;
  let groupStarted = false;
  try {
    return callback({
      warn(...args) {
        if (grouping && !groupStarted) {
          groupCollapsed(groupLabel);
          groupStarted = true;
        }
        warn(...args);
      },
      error(...args) {
        if (grouping && !groupStarted) {
          groupCollapsed(groupLabel);
          groupStarted = true;
        }
        error(...args);
      },
    });
  } finally {
    if (grouping && groupStarted) {
      groupEnd();
      groupStarted = false;
    }
  }
};$h͏_once.reportInGroup(reportInGroup);
})()
,
// === 58. ses ./src/lockdown.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let getenv,FERAL_FUNCTION,FERAL_EVAL,TypeError,arrayFilter,globalThis,is,ownKeys,stringSplit,symbolFor,noEvalEvaluate,getOwnPropertyNames,getPrototypeOf,makeHardener,makeIntrinsicsCollector,removeUnpermittedIntrinsics,tameFunctionConstructors,tameDateConstructor,tameMathObject,tameRegExpConstructor,enablePropertyOverrides,tameLocaleMethods,setGlobalObjectConstantProperties,setGlobalObjectMutableProperties,setGlobalObjectEvaluators,makeSafeEvaluator,initialGlobalPropertyNames,tameFunctionToString,tameDomains,tameModuleSource,tameConsole,tameErrorConstructor,assert,makeAssert,getAnonymousIntrinsics,makeCompartmentConstructor,tameHarden,tameSymbolConstructor,tameFauxDataProperties,tameRegeneratorRuntime,shimArrayBufferTransfer,reportInGroup,chooseReporter;$h͏_imports([["@endo/env-options", [["getEnvironmentOption",[$h͏_a => (getenv = $h͏_a)]]]],["@endo/immutable-arraybuffer/shim.js", []],["./commons.js", [["FERAL_FUNCTION",[$h͏_a => (FERAL_FUNCTION = $h͏_a)]],["FERAL_EVAL",[$h͏_a => (FERAL_EVAL = $h͏_a)]],["TypeError",[$h͏_a => (TypeError = $h͏_a)]],["arrayFilter",[$h͏_a => (arrayFilter = $h͏_a)]],["globalThis",[$h͏_a => (globalThis = $h͏_a)]],["is",[$h͏_a => (is = $h͏_a)]],["ownKeys",[$h͏_a => (ownKeys = $h͏_a)]],["stringSplit",[$h͏_a => (stringSplit = $h͏_a)]],["symbolFor",[$h͏_a => (symbolFor = $h͏_a)]],["noEvalEvaluate",[$h͏_a => (noEvalEvaluate = $h͏_a)]],["getOwnPropertyNames",[$h͏_a => (getOwnPropertyNames = $h͏_a)]],["getPrototypeOf",[$h͏_a => (getPrototypeOf = $h͏_a)]]]],["./make-hardener.js", [["makeHardener",[$h͏_a => (makeHardener = $h͏_a)]]]],["./intrinsics.js", [["makeIntrinsicsCollector",[$h͏_a => (makeIntrinsicsCollector = $h͏_a)]]]],["./permits-intrinsics.js", [["default",[$h͏_a => (removeUnpermittedIntrinsics = $h͏_a)]]]],["./tame-function-constructors.js", [["default",[$h͏_a => (tameFunctionConstructors = $h͏_a)]]]],["./tame-date-constructor.js", [["default",[$h͏_a => (tameDateConstructor = $h͏_a)]]]],["./tame-math-object.js", [["default",[$h͏_a => (tameMathObject = $h͏_a)]]]],["./tame-regexp-constructor.js", [["default",[$h͏_a => (tameRegExpConstructor = $h͏_a)]]]],["./enable-property-overrides.js", [["default",[$h͏_a => (enablePropertyOverrides = $h͏_a)]]]],["./tame-locale-methods.js", [["default",[$h͏_a => (tameLocaleMethods = $h͏_a)]]]],["./global-object.js", [["setGlobalObjectConstantProperties",[$h͏_a => (setGlobalObjectConstantProperties = $h͏_a)]],["setGlobalObjectMutableProperties",[$h͏_a => (setGlobalObjectMutableProperties = $h͏_a)]],["setGlobalObjectEvaluators",[$h͏_a => (setGlobalObjectEvaluators = $h͏_a)]]]],["./make-safe-evaluator.js", [["makeSafeEvaluator",[$h͏_a => (makeSafeEvaluator = $h͏_a)]]]],["./permits.js", [["initialGlobalPropertyNames",[$h͏_a => (initialGlobalPropertyNames = $h͏_a)]]]],["./tame-function-tostring.js", [["tameFunctionToString",[$h͏_a => (tameFunctionToString = $h͏_a)]]]],["./tame-domains.js", [["tameDomains",[$h͏_a => (tameDomains = $h͏_a)]]]],["./tame-module-source.js", [["tameModuleSource",[$h͏_a => (tameModuleSource = $h͏_a)]]]],["./error/tame-console.js", [["tameConsole",[$h͏_a => (tameConsole = $h͏_a)]]]],["./error/tame-error-constructor.js", [["default",[$h͏_a => (tameErrorConstructor = $h͏_a)]]]],["./error/assert.js", [["assert",[$h͏_a => (assert = $h͏_a)]],["makeAssert",[$h͏_a => (makeAssert = $h͏_a)]]]],["./get-anonymous-intrinsics.js", [["getAnonymousIntrinsics",[$h͏_a => (getAnonymousIntrinsics = $h͏_a)]]]],["./compartment.js", [["makeCompartmentConstructor",[$h͏_a => (makeCompartmentConstructor = $h͏_a)]]]],["./tame-harden.js", [["tameHarden",[$h͏_a => (tameHarden = $h͏_a)]]]],["./tame-symbol-constructor.js", [["tameSymbolConstructor",[$h͏_a => (tameSymbolConstructor = $h͏_a)]]]],["./tame-faux-data-properties.js", [["tameFauxDataProperties",[$h͏_a => (tameFauxDataProperties = $h͏_a)]]]],["./tame-regenerator-runtime.js", [["tameRegeneratorRuntime",[$h͏_a => (tameRegeneratorRuntime = $h͏_a)]]]],["./shim-arraybuffer-transfer.js", [["shimArrayBufferTransfer",[$h͏_a => (shimArrayBufferTransfer = $h͏_a)]]]],["./reporting.js", [["reportInGroup",[$h͏_a => (reportInGroup = $h͏_a)]],["chooseReporter",[$h͏_a => (chooseReporter = $h͏_a)]]]]]);































































/** @import {LockdownOptions} from '../types.js' */

const { Fail, details: X, quote: q } = assert;

/** @type {Error=} */
let priorRepairIntrinsics;

/** @type {Error=} */
let priorHardenIntrinsics;

// Build a harden() with an empty fringe.
// Gate it on lockdown.
/**
 * @template T
 * @param {T} ref
 * @returns {T}
 */
const safeHarden = makeHardener();

/**
 * @callback Transform
 * @param {string} source
 * @returns {string}
 */

/**
 * @callback CompartmentConstructor
 * @param {object} endowments
 * @param {object} moduleMap
 * @param {object} [options]
 * @param {Array<Transform>} [options.transforms]
 * @param {Array<Transform>} [options.__shimTransforms__]
 */

// TODO https://github.com/endojs/endo/issues/814
// Lockdown currently allows multiple calls provided that the specified options
// of every call agree.  With experience, we have observed that lockdown should
// only ever need to be called once and that simplifying lockdown will improve
// the quality of audits.

const probeHostEvaluators = () => {
  let functionAllowed;
  try {
    functionAllowed = FERAL_FUNCTION('return true')();
  } catch (_error) {
    // We reach here if the Function() constructor is outright forbidden by a
    // strict Content Security Policy (containing either a `default-src` or a
    // `script-src` directive), not been implemented in the host, or the host
    // is configured to throw an exception instead of `new Function`.
    functionAllowed = false;
  }

  let evalAllowed;
  try {
    evalAllowed = FERAL_EVAL('true');
  } catch (_error) {
    // We reach here if `eval` is outright forbidden by a strict Content Security Policy,
    // not implemented in the host, or the host is configured to throw an exception.
    // We allow this for SES usage that delegates the responsibility to isolate
    // guest code to production code generation.
    evalAllowed = false;
  }

  let directEvalAllowed;
  if (functionAllowed && evalAllowed) {
    directEvalAllowed = FERAL_FUNCTION(
      'eval',
      'SES_changed',
      `\
        eval("SES_changed = true");
        return SES_changed;
      `,
    )(FERAL_EVAL, false);
    // If we get here and SES_changed stayed false, that means the eval was sloppy
    // and indirect, which generally creates a new global.
    // We are going to throw an exception for failing to initialize SES, but
    // good neighbors clean up.
    if (!directEvalAllowed) {
      delete globalThis.SES_changed;
    }
  }

  return { functionAllowed, evalAllowed, directEvalAllowed };
};

/**
 * @param {LockdownOptions} [options]
 */
       const repairIntrinsics = (options = {}) => {
  // First time, absent options default to 'safe'.
  // Subsequent times, absent options default to first options.
  // Thus, all present options must agree with first options.
  // Reconstructing `option` here also ensures that it is a well
  // behaved record, with only own data properties.
  //
  // The `overrideTaming` is not a safety issue. Rather it is a tradeoff
  // between code compatibility, which is better with the `'moderate'`
  // setting, and tool compatibility, which is better with the `'min'`
  // setting. See
  // https://github.com/Agoric/SES-shim/blob/master/packages/ses/README.md#enabling-override-by-assignment)
  // for an explanation of when to use which.
  //
  // The `stackFiltering` is not a safety issue. Rather it is a tradeoff
  // between relevance and completeness of the stack frames shown on the
  // console. Setting`stackFiltering` to `'verbose'` applies no filters, providing
  // the raw stack frames that can be quite verbose. Setting
  // `stackFrameFiltering` to`'concise'` limits the display to the stack frame
  // information most likely to be relevant, eliminating distracting frames
  // such as those from the infrastructure. However, the bug you're trying to
  // track down might be in the infrastructure, in which case the `'verbose'` setting
  // is useful. See
  // [`stackFiltering` options](https://github.com/Agoric/SES-shim/blob/master/packages/ses/docs/lockdown.md#stackfiltering-options)
  // for an explanation.

  const {
    errorTaming = /** @type {'safe' | 'unsafe' | 'unsafe-debug'} */ (
      getenv('LOCKDOWN_ERROR_TAMING', 'safe', ['unsafe', 'unsafe-debug'])
    ),
    errorTrapping = /** @type {'platform' | 'none' | 'report' | 'abort' | 'exit'} */ (
      getenv('LOCKDOWN_ERROR_TRAPPING', 'platform', [
        'none',
        'report',
        'abort',
        'exit',
      ])
    ),
    reporting = /** @type {'platform' | 'console' | 'none'} */ (
      getenv('LOCKDOWN_REPORTING', 'platform', ['console', 'none'])
    ),
    unhandledRejectionTrapping = /** @type {'none' | 'report'} */ (
      getenv('LOCKDOWN_UNHANDLED_REJECTION_TRAPPING', 'report', ['none'])
    ),
    regExpTaming = /** @type {'safe' | 'unsafe'} */ (
      getenv('LOCKDOWN_REGEXP_TAMING', 'safe', ['unsafe'])
    ),
    localeTaming = /** @type {'safe' | 'unsafe'} */ (
      getenv('LOCKDOWN_LOCALE_TAMING', 'safe', ['unsafe'])
    ),
    consoleTaming = /** @type {'unsafe' | 'safe'} */ (
      getenv('LOCKDOWN_CONSOLE_TAMING', 'safe', ['unsafe'])
    ),
    overrideTaming = /** @type {'moderate' | 'min' | 'severe'} */ (
      getenv('LOCKDOWN_OVERRIDE_TAMING', 'moderate', ['min', 'severe'])
    ),
    stackFiltering = /** @type {'concise' | 'omit-frames' | 'shorten-paths' | 'verbose'} */ (
      getenv('LOCKDOWN_STACK_FILTERING', 'concise', [
        'omit-frames',
        'shorten-paths',
        'verbose',
      ])
    ),
    domainTaming = /** @type {'safe' | 'unsafe'} */ (
      getenv('LOCKDOWN_DOMAIN_TAMING', 'safe', ['unsafe'])
    ),
    evalTaming = /** @type {'safe-eval' | 'unsafe-eval' | 'no-eval'} */ (
      getenv('LOCKDOWN_EVAL_TAMING', 'safe-eval', [
        'unsafe-eval',
        'no-eval',
        // deprecated
        'safeEval',
        'unsafeEval',
        'noEval',
      ])
    ),
    overrideDebug = /** @type {string[]} */ (
      arrayFilter(
        stringSplit(getenv('LOCKDOWN_OVERRIDE_DEBUG', ''), ','),
        /** @param {string} debugName */
        debugName => debugName !== '',
      )
    ),
    legacyRegeneratorRuntimeTaming = /** @type {'safe' | 'unsafe-ignore'} */ (
      getenv('LOCKDOWN_LEGACY_REGENERATOR_RUNTIME_TAMING', 'safe', [
        'unsafe-ignore',
      ])
    ),
    __hardenTaming__ = /** @type {'safe' | 'unsafe'} */ (
      getenv('LOCKDOWN_HARDEN_TAMING', 'safe', ['unsafe'])
    ),
    dateTaming, // deprecated
    mathTaming, // deprecated
    ...extraOptions
  } = options;

  // Assert that only supported options were passed.
  // Use Reflect.ownKeys to reject symbol-named properties as well.
  const extraOptionsNames = ownKeys(extraOptions);
  extraOptionsNames.length === 0 ||
    Fail`lockdown(): non supported option ${q(extraOptionsNames)}`;

  const reporter = chooseReporter(reporting);
  const { warn } = reporter;

  if (dateTaming !== undefined) {
    warn(
      `SES The 'dateTaming' option is deprecated and does nothing. In the future specifying it will be an error.`,
    );
  }
  if (mathTaming !== undefined) {
    warn(
      `SES The 'mathTaming' option is deprecated and does nothing. In the future specifying it will be an error.`,
    );
  }

  priorRepairIntrinsics === undefined ||
    // eslint-disable-next-line @endo/no-polymorphic-call
    assert.fail(
      X`Already locked down at ${priorRepairIntrinsics} (SES_ALREADY_LOCKED_DOWN)`,
      TypeError,
    );
  // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_ALREADY_LOCKED_DOWN.md
  priorRepairIntrinsics = TypeError('Prior lockdown (SES_ALREADY_LOCKED_DOWN)');
  // Tease V8 to generate the stack string and release the closures the stack
  // trace retained:
  priorRepairIntrinsics.stack;

  const { functionAllowed, evalAllowed, directEvalAllowed } =
    probeHostEvaluators();

  if (
    directEvalAllowed === false &&
    evalTaming === 'safe-eval' &&
    (functionAllowed || evalAllowed)
  ) {
    // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_DIRECT_EVAL.md
    throw TypeError(
      "SES cannot initialize unless 'eval' is the original intrinsic 'eval', suitable for direct eval (dynamically scoped eval) (SES_DIRECT_EVAL)",
    );
  }

  /**
   * Because of packagers and bundlers, etc, multiple invocations of lockdown
   * might happen in separate instantiations of the source of this module.
   * In that case, each one sees its own `firstOptions` variable, so the test
   * above will not detect that lockdown has already happened. We
   * unreliably test some telltale signs that lockdown has run, to avoid
   * trying to lock down a locked down environment. Although the test is
   * unreliable, this is consistent with the SES threat model. SES provides
   * security only if it runs first in a given realm, or if everything that
   * runs before it is SES-aware and cooperative. Neither SES nor anything
   * can protect itself from corrupting code that runs first. For these
   * purposes, code that turns a realm into something that passes these
   * tests without actually locking down counts as corrupting code.
   *
   * The specifics of what this tests for may change over time, but it
   * should be consistent with any setting of the lockdown options.
   */
  const seemsToBeLockedDown = () => {
    return (
      globalThis.Function.prototype.constructor !== globalThis.Function &&
      // @ts-ignore harden is absent on globalThis type def.
      typeof globalThis.harden === 'function' &&
      // @ts-ignore lockdown is absent on globalThis type def.
      typeof globalThis.lockdown === 'function' &&
      globalThis.Date.prototype.constructor !== globalThis.Date &&
      typeof globalThis.Date.now === 'function' &&
      // @ts-ignore does not recognize that Date constructor is a special
      // Function.
      // eslint-disable-next-line @endo/no-polymorphic-call
      is(globalThis.Date.prototype.constructor.now(), NaN)
    );
  };

  if (seemsToBeLockedDown()) {
    // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_MULTIPLE_INSTANCES.md
    throw TypeError(
      `Already locked down but not by this SES instance (SES_MULTIPLE_INSTANCES)`,
    );
  }

  /**
   * 1. TAME powers & gather intrinsics first.
   */

  tameDomains(domainTaming);

  // Replace Function.prototype.toString with one that recognizes
  // shimmed functions as honorary native functions.
  const markVirtualizedNativeFunction = tameFunctionToString();

  const { addIntrinsics, completePrototypes, finalIntrinsics } =
    makeIntrinsicsCollector(reporter);

  const tamedHarden = tameHarden(safeHarden, __hardenTaming__);
  addIntrinsics({ harden: tamedHarden });

  addIntrinsics(tameFunctionConstructors());

  addIntrinsics(tameDateConstructor());
  addIntrinsics(tameErrorConstructor(errorTaming, stackFiltering));
  addIntrinsics(tameMathObject());
  addIntrinsics(tameRegExpConstructor(regExpTaming));
  addIntrinsics(tameSymbolConstructor());
  addIntrinsics(shimArrayBufferTransfer());
  addIntrinsics(tameModuleSource());

  addIntrinsics(getAnonymousIntrinsics());

  completePrototypes();

  const intrinsics = finalIntrinsics();

  // Install Object[@harden] or abort.
  const symbolForHarden = symbolFor('harden');
  const priorHarden = intrinsics.Object[symbolForHarden];
  if (priorHarden) {
    // By convention, if a module like @endo/harden gets used before lockdown,
    // it will install itself as a non-configurable, non-writable property over
    // Object[@harden] so that versions of SES predating the introduction of
    // Object[@harden] will fail to lockdown because they cannot remove an
    // unknown intrinsic.
    // All newer versions explicitly check for Object[@harden] (here).
    // The @endo/harden implementation additionally captures a stack trace
    // where harden was first used to assist developers in tracking down the
    // hardened module that was initialized before lockdown.
    if (priorHarden.lockdownError) {
      throw priorHarden.lockdownError;
    }
    // And in the event a library installs Object[@harden] without leaving a
    // hint, we fall back to a generic lockdown error.
    throw new TypeError(
      'Cannot lockdown (repairIntrinsics) if a prior harden implementation has been used and installed. Check for libraries using @endo/harden before lockdown.',
    );
  }
  intrinsics.Object[symbolForHarden] = tamedHarden;

  const hostIntrinsics = { __proto__: null };

  // The Node.js Buffer is a derived class of Uint8Array, and as such is often
  // passed around where a Uint8Array is expected.
  if (typeof globalThis.Buffer === 'function') {
    hostIntrinsics.Buffer = globalThis.Buffer;
  }

  /**
   * Wrap console unless suppressed.
   * At the moment, the console is considered a host power in the start
   * compartment, and not a primordial. Hence it is absent from the whilelist
   * and bypasses the intrinsicsCollector.
   *
   * @type {((error: any) => string | undefined) | undefined}
   */
  let optGetStackString;
  if (errorTaming === 'safe') {
    optGetStackString = intrinsics['%InitialGetStackString%'];
  }
  const consoleRecord = tameConsole(
    consoleTaming,
    errorTrapping,
    unhandledRejectionTrapping,
    optGetStackString,
  );
  globalThis.console = /** @type {Console} */ (consoleRecord.console);

  // The untamed Node.js console cannot itself be hardened as it has mutable
  // internal properties, but some of these properties expose internal versions
  // of classes from node's "primordials" concept.
  // eslint-disable-next-line no-underscore-dangle
  if (typeof (/** @type {any} */ (consoleRecord.console)._times) === 'object') {
    // SafeMap is a derived Map class used internally by Node
    // There doesn't seem to be a cleaner way to reach it.
    hostIntrinsics.SafeMap = getPrototypeOf(
      // eslint-disable-next-line no-underscore-dangle
      /** @type {any} */ (consoleRecord.console)._times,
    );
  }

  // The default `assert` installed by `assert-shim.js` does not redact errors,
  // leaving `lockdown` or `repairIntrinsics` with the obligation to replace it
  // with a redacting version, unless the caller opts-out with errorTaming set
  // to `unsafe` or `unsafe-debug`.
  // The inverse was true through version 1.13.0, except the configuration
  // was disregarded and the redacting `assert` left in place if lexical
  // `assert` differed from `globalThis.assert`.
  // @ts-ignore assert is absent on globalThis type def.
  if (errorTaming !== 'unsafe' && errorTaming !== 'unsafe-debug') {
    globalThis.assert = makeAssert();
  }

  // Replace *Locale* methods with their non-locale equivalents
  tameLocaleMethods(intrinsics, localeTaming);

  tameFauxDataProperties(intrinsics);

  /**
   * 2. Enforce PERMITS on shared intrinsics
   */

  // Remove non-standard properties.
  // All remaining functions encountered during whitelisting are
  // branded as honorary native functions.
  reportInGroup(
    'SES Removing unpermitted intrinsics',
    reporter,
    groupReporter =>
      removeUnpermittedIntrinsics(
        intrinsics,
        markVirtualizedNativeFunction,
        groupReporter,
      ),
  );

  // Initialize the powerful initial global, i.e., the global of the
  // start compartment, from the intrinsics.

  setGlobalObjectConstantProperties(globalThis);

  setGlobalObjectMutableProperties(globalThis, {
    intrinsics,
    newGlobalPropertyNames: initialGlobalPropertyNames,
    makeCompartmentConstructor,
    markVirtualizedNativeFunction,
  });

  if (
    evalTaming === 'no-eval' ||
    // deprecated
    evalTaming === 'noEval'
  ) {
    setGlobalObjectEvaluators(
      globalThis,
      noEvalEvaluate,
      markVirtualizedNativeFunction,
    );
  } else if (
    evalTaming === 'safe-eval' ||
    // deprecated
    evalTaming === 'safeEval'
  ) {
    const { safeEvaluate } = makeSafeEvaluator({ globalObject: globalThis });
    setGlobalObjectEvaluators(
      globalThis,
      safeEvaluate,
      markVirtualizedNativeFunction,
    );
  } else if (
    evalTaming === 'unsafe-eval' ||
    // deprecated
    evalTaming === 'unsafeEval'
  ) {
    // Leave eval function and Function constructor of the initial
    // compartment intact.
    // Other compartments will not have access to these evaluators unless a
    // guest program escapes containment.
  }

  /**
   * 3. HARDEN to share the intrinsics.
   *
   * We define hardenIntrinsics here so that options are in scope, but return
   * it to the caller because we intend to eventually allow vetted shims to run
   * between repairs and the hardening of intrinsics and so we can benchmark
   * repair separately from hardening.
   */

  const hardenIntrinsics = () => {
    priorHardenIntrinsics === undefined ||
      // eslint-disable-next-line @endo/no-polymorphic-call
      assert.fail(
        X`Already locked down at ${priorHardenIntrinsics} (SES_ALREADY_LOCKED_DOWN)`,
        TypeError,
      );
    // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_ALREADY_LOCKED_DOWN.md
    priorHardenIntrinsics = TypeError(
      'Prior lockdown (SES_ALREADY_LOCKED_DOWN)',
    );
    // Tease V8 to generate the stack string and release the closures the stack
    // trace retained:
    priorHardenIntrinsics.stack;

    // Circumvent the override mistake.
    // TODO consider moving this to the end of the repair phase, and
    // therefore before vetted shims rather than afterwards. It is not
    // clear yet which is better.
    // @ts-ignore enablePropertyOverrides does its own input validation
    reportInGroup('SES Enabling property overrides', reporter, groupReporter =>
      enablePropertyOverrides(
        intrinsics,
        overrideTaming,
        groupReporter,
        overrideDebug,
      ),
    );
    if (legacyRegeneratorRuntimeTaming === 'unsafe-ignore') {
      tameRegeneratorRuntime();
    }

    // Finally register and optionally freeze all the intrinsics. This
    // must be the operation that modifies the intrinsics.
    const toHarden = {
      intrinsics,
      hostIntrinsics,
      globals: {
        // Harden evaluators
        Function: globalThis.Function,
        eval: globalThis.eval,
        // @ts-ignore Compartment does exist on globalThis
        Compartment: globalThis.Compartment,

        // Harden Symbol
        Symbol: globalThis.Symbol,
      },
    };

    // Harden Symbol and properties for initialGlobalPropertyNames in the host realm
    for (const prop of getOwnPropertyNames(initialGlobalPropertyNames)) {
      toHarden.globals[prop] = globalThis[prop];
    }

    tamedHarden(toHarden);

    return tamedHarden;
  };

  return hardenIntrinsics;
};$h͏_once.repairIntrinsics(repairIntrinsics);
})()
,
// === 59. ses ./src/lockdown-shim.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let globalThis,repairIntrinsics;$h͏_imports([["./assert-sloppy-mode.js", []],["./commons.js", [["globalThis",[$h͏_a => (globalThis = $h͏_a)]]]],["./lockdown.js", [["repairIntrinsics",[$h͏_a => (repairIntrinsics = $h͏_a)]]]]]);








/** @import {LockdownOptions} from '../types.js' */

/**
 * @param {LockdownOptions} [options]
 */
globalThis.lockdown = options => {
  const hardenIntrinsics = repairIntrinsics(options);
  globalThis.harden = hardenIntrinsics();
};

/**
 * @param {LockdownOptions} [options]
 */
globalThis.repairIntrinsics = options => {
  const hardenIntrinsics = repairIntrinsics(options);
  // Reveal hardenIntrinsics after repairs.
  globalThis.hardenIntrinsics = () => {
    // Reveal harden after hardenIntrinsics.
    // Harden is dangerous before hardenIntrinsics because hardening just
    // about anything will inadvertently render intrinsics irreparable.
    // Also, for modules that must work both before or after lockdown (code
    // that is portable between JS and SES), the existence of harden in global
    // scope signals whether such code should attempt to use harden in the
    // defense of its own API.
    // @ts-ignore harden not yet recognized on globalThis.
    globalThis.harden = hardenIntrinsics();
  };
};
})()
,
// === 60. ses ./src/compartment-shim.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let globalThis,makeCompartmentConstructor,tameFunctionToString,getGlobalIntrinsics,chooseReporter;$h͏_imports([["./commons.js", [["globalThis",[$h͏_a => (globalThis = $h͏_a)]]]],["./compartment.js", [["makeCompartmentConstructor",[$h͏_a => (makeCompartmentConstructor = $h͏_a)]]]],["./tame-function-tostring.js", [["tameFunctionToString",[$h͏_a => (tameFunctionToString = $h͏_a)]]]],["./intrinsics.js", [["getGlobalIntrinsics",[$h͏_a => (getGlobalIntrinsics = $h͏_a)]]]],["./reporting.js", [["chooseReporter",[$h͏_a => (chooseReporter = $h͏_a)]]]]]);





const markVirtualizedNativeFunction = tameFunctionToString();

const muteReporter = chooseReporter('none');

// @ts-ignore Compartment is definitely on globalThis.
globalThis.Compartment = makeCompartmentConstructor(
  makeCompartmentConstructor,
  // Any reporting that would need to be done should have already been done
  // during `lockdown()`.
  // See https://github.com/endojs/endo/pull/2624#discussion_r1840979770
  getGlobalIntrinsics(globalThis, muteReporter),
  markVirtualizedNativeFunction,
  {
    enforceNew: true,
  },
);
})()
,
// === 61. ses ./src/assert-shim.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let globalThis,makeAssert;$h͏_imports([["./commons.js", [["globalThis",[$h͏_a => (globalThis = $h͏_a)]]]],["./error/assert.js", [["makeAssert",[$h͏_a => (makeAssert = $h͏_a)]]]]]);


globalThis.assert = makeAssert(undefined, true);
})()
,
// === 62. ses ./src/console-shim.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';let symbolFor,globalThis,defineCausalConsoleFromLogger,loggedErrorHandler;$h͏_imports([["./commons.js", [["symbolFor",[$h͏_a => (symbolFor = $h͏_a)]],["globalThis",[$h͏_a => (globalThis = $h͏_a)]]]],["./error/console.js", [["defineCausalConsoleFromLogger",[$h͏_a => (defineCausalConsoleFromLogger = $h͏_a)]]]],["./error/assert.js", [["loggedErrorHandler",[$h͏_a => (loggedErrorHandler = $h͏_a)]]]]]);



// TODO possible additional exports. Some are privileged.
// export { loggedErrorHandler };
// export {
//   makeCausalConsole,
//   consoleLevelMethods,
//   consoleOtherMethods,
//   makeLoggingConsoleKit,
//   filterConsole,
//   pumpLogToConsole,
// } from './src/error/console.js';
// export { assertLogs, throwsAndLogs } from './src/error/throws-and-logs.js';

/**
 * Makes a Console like the
 * [SES causal `console`](https://github.com/endojs/endo/blob/master/packages/ses/src/error/README.md)
 * but whose output is redirected to the supplied `logger` function.
 */
const makeCausalConsoleFromLoggerForSesAva =
  defineCausalConsoleFromLogger(loggedErrorHandler);

/**
 *`makeCausalConsoleFromLoggerForSesAva` is privileged because it exposes
 * unredacted error info onto the `Logger` provided by the caller. It
 * should not be made available to non-privileged code.
 *
 * Further, we consider this particular API choice to be experimental
 * and may change in the future. It is currently only intended for use by
 * `@endo/ses-ava`, with which it will be co-maintained.
 *
 * Thus, this `console-shim.js` makes `makeCausalConsoleFromLoggerForSesAva`
 * available on `globalThis` which it *assumes* is the global of the start
 * compartment and is therefore allowed to hold powers that should not be
 * available in constructed compartments. It makes it available as the value of
 * a global property named by a registered symbol named
 * `MAKE_CAUSAL_CONSOLE_FROM_LOGGER_KEY_FOR_SES_AVA`.
 *
 * Anyone accessing this, including `@endo/ses-ava`, should feature test for
 * this and be tolerant of its absence. It may indeed disappear from later
 * versions of the ses-shim.
 */
const MAKE_CAUSAL_CONSOLE_FROM_LOGGER_KEY_FOR_SES_AVA = symbolFor(
  'MAKE_CAUSAL_CONSOLE_FROM_LOGGER_KEY_FOR_SES_AVA',
);

globalThis[MAKE_CAUSAL_CONSOLE_FROM_LOGGER_KEY_FOR_SES_AVA] =
  makeCausalConsoleFromLoggerForSesAva;
})()
,
// === 63. ses ./index.js ===
({imports:$h͏_imports,liveVar:$h͏_live,onceVar:$h͏_once,import:$h͏_import,importMeta:$h͏____meta})=>(function(){'use strict';$h͏_imports([["./src/lockdown-shim.js", []],["./src/compartment-shim.js", []],["./src/assert-shim.js", []],["./src/console-shim.js", []]]);
})()
,
])()
;/*! end SES */
(()=>{var e={5654(e,t,r){"use strict";r.d(t,{vb:()=>v});var n=r(290266),s=r(545203),a=r(869864),o=r(984524),i=r(633089),l=r(414221),c=r(833414),u=r(32014),m=r(694729),d=r(988068),p=r(80332),h=r(597361),f=r(936435),g=r(728195),y=r(157392);let b=(0,s.kp)(y.Wu,(0,n.Ik)({children:(0,n.YO)((0,s.RZ)(()=>v))})),k=(0,s.kp)(b,(0,n.Ik)({type:(0,g.eu)(y.Z6.Panel)})),v=(0,g.i5)([i.$,l.z,u.Y,m.x,k,h.t,f.z,p.E,a.A,d.y,c.W,o.s3])},5696(){["XMLHttpRequest"].forEach(e=>{Reflect.has(globalThis,e)||(globalThis[e]=void 0)}),Reflect.has(globalThis,"window")||(globalThis.window=globalThis)},12796(e,t,r){"use strict";r.d(t,{j:()=>n});let n=r(230337).O},16278(e,t,r){"use strict";r.d(t,{E:()=>a,S:()=>o});var n=r(230337),s=r(538600);function a(){return o(n.O),n.O}function o(e){let t=e.__SENTRY__=e.__SENTRY__||{};return t.version=t.version||s.M,t[s.M]=t[s.M]||{}}},16686(e,t,r){"use strict";r.d(t,{Lk:()=>x,Uk:()=>E,V4:()=>j,Y7:()=>A,hb:()=>T,nV:()=>S});var n=r(107842),s=r(572858),a=r(620209),o=r(16278),i=r(933190),l=r(960196),c=r(67904),u=r(812863),m=r(267276),d=r(777217),p=r(71409),h=r(608119),f=r(836164),g=r(24708),y=r(145834),b=r(140722),k=r(105388),v=r(96331),_=r(584222);let w="__SENTRY_SUPPRESS_TRACING__";function x(e,t){let r=O();if(r.startSpan)return r.startSpan(e,t);let n=I(e),{forceTransaction:s,parentSpan:a}=e;return(0,i.v4)(e.scope,()=>D(a)(()=>{let r=(0,i.o5)(),a=N(r),o=e.onlyIfParent&&!a?new b.w:C({parentSpan:a,spanArguments:n,forceTransaction:s,scope:r});return(0,p.r)(r,o),(0,m.x)(()=>t(o),()=>{let{status:e}=(0,h.et)(o);o.isRecording()&&(!e||"ok"===e)&&o.setStatus({code:v.TJ,message:"internal_error"})},()=>o.end())}))}function S(e,t){let r=O();if(r.startSpanManual)return r.startSpanManual(e,t);let n=I(e),{forceTransaction:s,parentSpan:a}=e;return(0,i.v4)(e.scope,()=>D(a)(()=>{let r=(0,i.o5)(),a=N(r),o=e.onlyIfParent&&!a?new b.w:C({parentSpan:a,spanArguments:n,forceTransaction:s,scope:r});function l(){o.end()}return(0,p.r)(r,o),(0,m.x)(()=>t(o,l),()=>{let{status:e}=(0,h.et)(o);o.isRecording()&&(!e||"ok"===e)&&o.setStatus({code:v.TJ,message:"internal_error"})})}))}function E(e){let t=O();if(t.startInactiveSpan)return t.startInactiveSpan(e);let r=I(e),{forceTransaction:n,parentSpan:s}=e;return(e.scope?t=>(0,i.v4)(e.scope,t):void 0!==s?e=>T(s,e):e=>e())(()=>{let t=(0,i.o5)(),s=N(t);return e.onlyIfParent&&!s?new b.w:C({parentSpan:s,spanArguments:r,forceTransaction:n,scope:t})})}let j=({sentryTrace:e,baggage:t},r)=>(0,i.v4)(n=>{let a=(0,s.kM)(e,t);return n.setPropagationContext(a),r()});function T(e,t){let r=O();return r.withActiveSpan?r.withActiveSpan(e,t):(0,i.v4)(r=>((0,p.r)(r,e||void 0),t(r)))}function A(e){return(0,i.v4)(t=>(t.setPropagationContext((0,a.J)()),c.T&&n.vF.info(`Starting a new trace with id ${t.getPropagationContext().traceId}`),T(null,e)))}function C({parentSpan:e,spanArguments:t,forceTransaction:r,scope:n}){let s;if(!(0,d.w)())return new b.w;let a=(0,i.rm)();if(e&&!r)s=function(e,t,r){let{spanId:n,traceId:s}=e.spanContext(),a=!t.getScopeData().sdkProcessingMetadata[w]&&(0,h.pK)(e),o=a?new k.W({...r,parentSpanId:n,traceId:s,sampled:a}):new b.w({traceId:s});(0,h.Hu)(e,o);let l=(0,i.KU)();return l&&(l.emit("spanStart",o),r.endTimestamp&&l.emit("spanEnd",o)),o}(e,n,t),(0,h.Hu)(e,s);else if(e){let r=(0,f.k1)(e),{traceId:a,spanId:o}=e.spanContext(),i=(0,h.pK)(e);s=M({traceId:a,parentSpanId:o,...t},n,i),(0,f.LZ)(s,r)}else{let{traceId:e,dsc:r,parentSpanId:o,sampled:i}={...a.getPropagationContext(),...n.getPropagationContext()};s=M({traceId:e,parentSpanId:o,...t},n,i),r&&(0,f.LZ)(s,r)}return(0,g.z)(s),(0,_.d_)(s,n,a),s}function I(e){let t={isStandalone:(e.experimental||{}).standalone,...e};if(e.startTime){let r={...t};return r.startTimestamp=(0,h.cI)(e.startTime),delete r.startTime,r}return t}function O(){let e=(0,o.E)();return(0,l.h)(e)}function M(e,t,r){let n=(0,i.KU)(),s=n&&n.getOptions()||{},{name:a="",attributes:o}=e,[l,c]=t.getScopeData().sdkProcessingMetadata[w]?[!1]:(0,y.Z)(s,{name:a,parentSampled:r,attributes:o,transactionContext:{name:a,parentSampled:r}}),m=new k.W({...e,attributes:{[u.i_]:"custom",...e.attributes},sampled:l});return void 0!==c&&m.setAttribute(u.sy,c),n&&n.emit("spanStart",m),m}function N(e){let t=(0,p.f)(e);if(!t)return;let r=(0,i.KU)();return(r?r.getOptions():{}).parentSpanIsAlwaysRootSpan?(0,h.zU)(t):t}function D(e){return void 0!==e?t=>T(e,t):e=>e()}},16786(e,t,r){"use strict";r.d(t,{U:()=>n});class n extends Error{constructor(e,t="warn"){super(e),this.message=e,this.name=new.target.prototype.constructor.name,Object.setPrototypeOf(this,new.target.prototype),this.logLevel=t}}},24708(e,t,r){"use strict";r.d(t,{U:()=>i,z:()=>o});var n=r(107842),s=r(67904),a=r(608119);function o(e){if(!s.T)return;let{description:t="< unknown name >",op:r="< unknown op >",parent_span_id:o}=(0,a.et)(e),{spanId:i}=e.spanContext(),l=(0,a.pK)(e),c=(0,a.zU)(e),u=c===e,m=`[Tracing] Starting ${l?"sampled":"unsampled"} ${u?"root ":""}span`,d=[`op: ${r}`,`name: ${t}`,`ID: ${i}`];if(o&&d.push(`parent ID: ${o}`),!u){let{op:e,description:t}=(0,a.et)(c);d.push(`root ID: ${c.spanContext().spanId}`),e&&d.push(`root op: ${e}`),t&&d.push(`root description: ${t}`)}n.vF.log(`${m}
  ${d.join(`
  `)}`)}function i(e){if(!s.T)return;let{description:t="< unknown name >",op:r="< unknown op >"}=(0,a.et)(e),{spanId:o}=e.spanContext(),i=(0,a.zU)(e)===e,l=`[Tracing] Finishing "${r}" ${i?"root ":""}span "${t}" with ID ${o}`;n.vF.log(l)}},25605(e,t,r){"use strict";r.d(t,{AS:()=>c,aj:()=>u,s5:()=>l});var n=r(562298),s=r(107842),a=r(680985);let o={},i={};function l(e,t){o[e]=o[e]||[],o[e].push(t)}function c(e,t){i[e]||(t(),i[e]=!0)}function u(e,t){let r=e&&o[e];if(r)for(let o of r)try{o(t)}catch(t){n.T&&s.vF.error(`Error while triggering instrumentation handler.
Type: ${e}
Name: ${(0,a.qQ)(o)}
Error:`,t)}}},32014(e,t,r){"use strict";r.d(t,{Y:()=>i});var n=r(290266),s=r(545203),a=r(728195),o=r(157392);let i=(0,s.kp)(o.Tl,(0,n.Ik)({type:(0,a.eu)(o.Z6.Heading),value:(0,n.Yj)()}))},33029(e,t,r){"use strict";r.d(t,{Pm:()=>eS});var n,s=r(652825),a=r(290266),o=r(545203),i=r(297564),l=r(973594),c=r(447519),u=r(812805),m=r(434322),d=r(728195),p=r(971188),h=r(159167),f=r(689686),g=r(254995),y=r(833399);let b=(0,p.J)([(0,a.Yj)(),(0,a.ai)()]),k=v([(0,a.Yj)()]);function v(e){let t=1===e.length?e[0]:(0,p.J)(e);var r=(0,a.me)((0,d.E$)(e=>"boolean"==typeof e?(0,a.zM)():t));let n=(0,d.E$)(e=>Array.isArray(e)?(0,a.YO)((0,o.RZ)(()=>n)):r);return n}function _(e){return(0,a.me)((0,d.E$)(t=>"boolean"==typeof t?(0,a.zM)():e))}function w(e,t={}){return(0,a.Ik)({type:(0,d.eu)(e),props:(0,a.Ik)(t),key:(0,a.me)(b)})}(0,a.Ik)({type:(0,a.Yj)(),props:(0,a.g1)((0,a.Yj)(),c.zC),key:(0,a.me)(b)});let x=(0,p.J)([(0,d.eu)("none"),(0,d.eu)("medium"),(0,d.eu)("full")]),S=w("Image",{src:(0,p.J)([(0,h.J)(),(0,g.H)({protocol:(0,d.eu)("https:")})]),alt:(0,a.lq)((0,a.Yj)()),borderRadius:(0,a.lq)(x),width:(0,a.lq)((0,a.ai)()),height:(0,a.lq)((0,a.ai)())}),E=w("Icon",{name:(0,p.J)(Object.values(m.$).map(e=>(0,d.eu)(e))),color:(0,a.lq)((0,p.J)([(0,d.eu)("default"),(0,d.eu)("primary"),(0,d.eu)("muted"),(0,d.eu)("error"),(0,d.eu)("success"),(0,d.eu)("warning")])),size:(0,a.lq)((0,p.J)([(0,d.eu)("md"),(0,d.eu)("inherit")]))}),j=w("Button",{children:v([k,S,E]),name:(0,a.lq)((0,a.Yj)()),type:(0,a.lq)((0,p.J)([(0,d.eu)("button"),(0,d.eu)("submit")])),variant:(0,a.lq)((0,p.J)([(0,d.eu)("primary"),(0,d.eu)("destructive")])),size:(0,a.lq)((0,p.J)([(0,d.eu)("sm"),(0,d.eu)("md")])),disabled:(0,a.lq)((0,a.zM)()),loading:(0,a.lq)((0,a.zM)()),form:(0,a.lq)((0,a.Yj)())}),T=w("Checkbox",{name:(0,a.Yj)(),checked:(0,a.lq)((0,a.zM)()),label:(0,a.lq)((0,a.Yj)()),variant:(0,a.lq)((0,p.J)([(0,d.eu)("default"),(0,d.eu)("toggle")])),disabled:(0,a.lq)((0,a.zM)())}),A=(0,a.Ik)({name:(0,a.Yj)(),value:(0,a.lq)((0,a.Yj)()),placeholder:(0,a.lq)((0,a.Yj)()),disabled:(0,a.lq)((0,a.zM)())}),C=(0,o.kp)(A,(0,a.Ik)({type:(0,d.eu)("text")})),I=(0,o.kp)(A,(0,a.Ik)({type:(0,d.eu)("password")})),O=(0,o.kp)(A,(0,a.Ik)({type:(0,d.eu)("number"),min:(0,a.lq)((0,a.ai)()),max:(0,a.lq)((0,a.ai)()),step:(0,a.lq)((0,a.ai)())})),M=(n=e=>{if((0,u.Qd)(e)&&(0,u.i5)(e,"type"))switch(e.type){case"text":return C;case"password":return I;case"number":return O}return A},(0,a.Ik)({type:(0,d.eu)("Input"),props:(0,d.E$)(n),key:(0,a.me)(b)})),N=w("AddressInput",{name:(0,a.Yj)(),chainId:i.dg,value:(0,a.lq)((0,a.Yj)()),placeholder:(0,a.lq)((0,a.Yj)()),disabled:(0,a.lq)((0,a.zM)()),displayAvatar:(0,a.lq)((0,a.zM)())}),D=w("Option",{value:(0,a.Yj)(),children:(0,a.Yj)(),disabled:(0,a.lq)((0,a.zM)())}),R=w("Dropdown",{name:(0,a.Yj)(),value:(0,a.lq)((0,a.Yj)()),children:v([D]),disabled:(0,a.lq)((0,a.zM)())}),L=w("DateTimePicker",{name:(0,a.Yj)(),type:(0,a.lq)((0,p.J)([(0,d.eu)("date"),(0,d.eu)("time"),(0,d.eu)("datetime")])),placeholder:(0,a.lq)((0,a.Yj)()),disabled:(0,a.lq)((0,a.zM)()),disablePast:(0,a.lq)((0,a.zM)()),disableFuture:(0,a.lq)((0,a.zM)()),value:(0,a.lq)(f.U)}),F=w("Address",{address:(0,d.E$)(e=>"string"==typeof e&&e.startsWith("0x")?l.UG:i.FX),truncate:(0,a.lq)((0,a.zM)()),displayName:(0,a.lq)((0,a.zM)()),avatar:(0,a.lq)((0,a.zM)())}),P=w("AccountSelector",{name:(0,a.Yj)(),hideExternalAccounts:(0,a.lq)((0,a.zM)()),chainIds:(0,a.lq)((0,a.YO)(i.dg)),switchGlobalAccount:(0,a.lq)((0,a.zM)()),value:(0,a.lq)(i.FX),disabled:(0,a.lq)((0,a.zM)())}),q=w("Card",{image:(0,a.lq)((0,a.Yj)()),title:(0,d.E$)(e=>"object"==typeof e?F:(0,a.Yj)()),description:(0,a.lq)((0,a.Yj)()),value:(0,a.Yj)(),extra:(0,a.lq)((0,a.Yj)())}),z=w("SelectorOption",{value:(0,a.Yj)(),children:q,disabled:(0,a.lq)((0,a.zM)())}),$=w("Selector",{name:(0,a.Yj)(),title:(0,a.Yj)(),value:(0,a.lq)((0,a.Yj)()),children:v([z]),disabled:(0,a.lq)((0,a.zM)())}),U=w("AssetSelector",{name:(0,a.Yj)(),addresses:y.j6,chainIds:(0,a.lq)((0,a.YO)(y.s1)),value:(0,a.lq)(y._g),disabled:(0,a.lq)((0,a.zM)())}),B=w("Radio",{value:(0,a.Yj)(),children:(0,a.Yj)(),disabled:(0,a.lq)((0,a.zM)())}),W=w("RadioGroup",{name:(0,a.Yj)(),value:(0,a.lq)((0,a.Yj)()),children:v([B]),disabled:(0,a.lq)((0,a.zM)())}),H=w("FileInput",{name:(0,a.Yj)(),accept:(0,p.J)([(0,a.lq)((0,a.YO)((0,a.Yj)()))]),compact:(0,a.lq)((0,a.zM)()),disabled:(0,a.lq)((0,a.zM)())}),V=[_((0,o.RZ)(()=>ew)),M],Y=[M,_((0,o.RZ)(()=>ew))],G=[_((0,o.RZ)(()=>ew)),M,_((0,o.RZ)(()=>ew))],J=[U,N,P,M,R,W,H,T,$,L];(0,p.J)([...J,...V,...Y,...G]);let Z=(0,d.E$)(e=>{let t=Array.isArray(e);return t&&3===e.length?(0,a.PV)(G):t&&2===e.length?e[0]?.type==="Box"?(0,a.PV)(V):(0,a.PV)(Y):(0,d.i5)(J)}),K=w("Field",{label:(0,a.lq)((0,a.Yj)()),error:(0,a.lq)((0,a.Yj)()),children:Z}),X=w("Bold",{children:v([(0,d.E$)(e=>"string"==typeof e?(0,a.Yj)():Q)])}),Q=w("Italic",{children:v([(0,d.E$)(e=>"string"==typeof e?(0,a.Yj)():X)])}),ee=(0,d.i5)([X,Q]),et=w("Avatar",{address:i.FX,size:(0,a.lq)((0,p.J)([(0,d.eu)("sm"),(0,d.eu)("md"),(0,d.eu)("lg")]))}),er=v([(0,o.RZ)(()=>ew)]),en=w("Box",{children:er,direction:(0,a.lq)((0,p.J)([(0,d.eu)("horizontal"),(0,d.eu)("vertical")])),alignment:(0,a.lq)((0,p.J)([(0,d.eu)("start"),(0,d.eu)("center"),(0,d.eu)("end"),(0,d.eu)("space-between"),(0,d.eu)("space-around")])),crossAlignment:(0,a.lq)((0,p.J)([(0,d.eu)("start"),(0,d.eu)("center"),(0,d.eu)("end")])),center:(0,a.lq)((0,a.zM)())}),es=w("Form",{children:er,name:(0,a.Yj)()}),ea=(0,s.YP)(j,"FooterButton",e=>!!("string"==typeof e.props.children||"boolean"==typeof e.props.children||null===e.props.children||Array.isArray(e.props.children)&&!e.props.children.some(e=>"string"!=typeof e&&"boolean"!=typeof e&&null!==e))||"Footer buttons may only contain text."),eo=w("Section",{children:er,direction:(0,a.lq)((0,p.J)([(0,d.eu)("horizontal"),(0,d.eu)("vertical")])),alignment:(0,a.lq)((0,p.J)([(0,d.eu)("start"),(0,d.eu)("center"),(0,d.eu)("end"),(0,d.eu)("space-between"),(0,d.eu)("space-around")]))}),ei=w("CollapsibleSection",{children:er,label:(0,a.Yj)(),isLoading:(0,a.lq)((0,a.zM)()),isExpanded:(0,a.lq)((0,a.zM)()),direction:(0,a.lq)((0,p.J)([(0,d.eu)("horizontal"),(0,d.eu)("vertical")])),alignment:(0,a.lq)((0,p.J)([(0,d.eu)("start"),(0,d.eu)("center"),(0,d.eu)("end"),(0,d.eu)("space-between"),(0,d.eu)("space-around")]))}),el=w("Footer",{children:(0,d.E$)(e=>Array.isArray(e)?(0,a.PV)([ea,ea]):ea)}),ec=w("Copyable",{value:(0,a.Yj)(),sensitive:(0,a.lq)((0,a.zM)())}),eu=w("Divider"),em=w("Heading",{children:k,size:(0,a.lq)((0,p.J)([(0,d.eu)("sm"),(0,d.eu)("md"),(0,d.eu)("lg")]))}),ed=w("Link",{href:(0,a.Yj)(),children:v([(0,d.E$)(e=>"string"==typeof e?(0,a.Yj)():(0,d.i5)([ee,E,S,F]))])}),ep=w("Skeleton",{width:(0,a.lq)((0,a.KC)([(0,a.ai)(),(0,a.Yj)()])),height:(0,a.lq)((0,a.KC)([(0,a.ai)(),(0,a.Yj)()])),borderRadius:(0,a.lq)(x)}),eh=w("Text",{children:v([(0,d.E$)(e=>"string"==typeof e?(0,a.Yj)():(0,d.i5)([X,Q,ed,E,ep]))]),alignment:(0,a.lq)((0,p.J)([(0,d.eu)("start"),(0,d.eu)("center"),(0,d.eu)("end")])),color:(0,a.lq)((0,p.J)([(0,d.eu)("default"),(0,d.eu)("alternative"),(0,d.eu)("muted"),(0,d.eu)("error"),(0,d.eu)("success"),(0,d.eu)("warning")])),size:(0,a.lq)((0,p.J)([(0,d.eu)("sm"),(0,d.eu)("md")])),fontWeight:(0,a.lq)((0,p.J)([(0,d.eu)("regular"),(0,d.eu)("medium"),(0,d.eu)("bold")]))}),ef=w("Value",{value:(0,d.E$)(e=>"string"==typeof e?(0,a.Yj)():eh),extra:(0,d.E$)(e=>"string"==typeof e?(0,a.Yj)():eh)}),eg=(0,d.E$)(e=>"boolean"==typeof e?(0,a.zM)():(0,d.i5)([eh,X,Q,ed,S,E])),ey=(0,d.E$)(e=>"string"==typeof e?(0,a.Yj)():(0,d.i5)([eh,X,Q,ed,E])),eb=w("Tooltip",{children:(0,a.me)(eg),content:ey}),ek=w("Banner",{children:v([(0,d.i5)([eh,ed,E,j,X,Q,ep])]),title:(0,a.Yj)(),severity:(0,a.KC)([(0,d.eu)("danger"),(0,d.eu)("info"),(0,d.eu)("success"),(0,d.eu)("warning")])}),ev=w("Row",{label:(0,a.Yj)(),children:(0,o.RZ)(()=>(0,d.i5)([ef,ew])),variant:(0,a.lq)((0,p.J)([(0,d.eu)("default"),(0,d.eu)("warning"),(0,d.eu)("critical")])),tooltip:(0,a.lq)((0,a.Yj)())}),e_=w("Spinner"),ew=(0,d.i5)([P,F,U,N,X,en,j,ec,L,eu,R,W,K,H,es,em,M,S,Q,ed,ev,e_,eh,eb,T,q,E,$,eo,et,ek,ep,ei]),ex=w("Container",{children:(0,d.E$)(e=>Array.isArray(e)?(0,a.PV)([ew,el]):ew),backgroundColor:(0,a.lq)((0,p.J)([(0,d.eu)("default"),(0,d.eu)("alternative")]))}),eS=(0,d.i5)([ew,ex]);(0,d.i5)([U,N,P,j,M,H,K,es,X,Q,F,en,ec,L,eu,em,S,ed,ev,e_,eh,R,D,W,B,ef,eb,T,el,ex,q,E,$,z,eo,et,ek,ep,ei])},36915(e,t,r){"use strict";Object.freeze({"endowment:network-access":"endowment:network-access","endowment:transaction-insight":"endowment:transaction-insight","endowment:cronjob":"endowment:cronjob","endowment:ethereum-provider":"endowment:ethereum-provider","endowment:rpc":"endowment:rpc","endowment:webassembly":"endowment:webassembly","endowment:lifecycle-hooks":"endowment:lifecycle-hooks","endowment:messenger":"endowment:messenger","endowment:multichain-provider":"endowment:multichain-provider","endowment:page-home":"endowment:page-home","endowment:page-settings":"endowment:page-settings","endowment:signature-insight":"endowment:signature-insight","endowment:name-lookup":"endowment:name-lookup","endowment:assets":"endowment:assets","endowment:protocol":"endowment:protocol","endowment:keyring":"endowment:keyring"}),Object.freeze({}),Object.freeze({"endowment:caip25":"eth_accounts is disabled. For more information please see https://github.com/MetaMask/snaps/issues/990."}),Object.freeze(["endowment:caip25"])},37853(e,t,r){"use strict";r.d(t,{k3:()=>o,lu:()=>s,zf:()=>a});var n=r(230337);function s(){return Date.now()/1e3}let a=function(){let{performance:e}=n.O;if(!e||!e.now)return s;let t=Date.now()-e.now(),r=void 0==e.timeOrigin?t:e.timeOrigin;return()=>(r+e.now())/1e3}(),o=(()=>{let{performance:e}=n.O;if(!e||!e.now)return;let t=e.now(),r=Date.now(),s=e.timeOrigin?Math.abs(e.timeOrigin+t-r):36e5,a=e.timing&&e.timing.navigationStart,o="number"==typeof a?Math.abs(a+t-r):36e5;if(s<36e5||o<36e5)if(s<=o)return e.timeOrigin;else return a;return r})()},40209(e,t,r){"use strict";r.d(t,{Xr:()=>i,gt:()=>o,nC:()=>a,xv:()=>s});var n=r(397718);function s(e,t=0){return"string"!=typeof e||0===t||e.length<=t?e:`${e.slice(0,t)}...`}function a(e,t){let r=e,n=r.length;if(n<=150)return r;t>n&&(t=n);let s=Math.max(t-60,0);s<5&&(s=0);let a=Math.min(s+140,n);return a>n-5&&(a=n),a===n&&(s=Math.max(a-140,0)),r=r.slice(s,a),s>0&&(r=`'{snip} ${r}`),a<n&&(r+=" {snip}"),r}function o(e,t){if(!Array.isArray(e))return"";let r=[];for(let t=0;t<e.length;t++){let s=e[t];try{(0,n.L2)(s)?r.push("[VueViewModel]"):r.push(String(s))}catch(e){r.push("[value cannot be serialized]")}}return r.join(t)}function i(e,t=[],r=!1){return t.some(t=>(function(e,t,r=!1){return!!(0,n.Kg)(e)&&((0,n.gd)(t)?t.test(e):!!(0,n.Kg)(t)&&(r?e===t:e.includes(t)))})(e,t,r))}},47810(e,t,r){"use strict";r.d(t,{_:()=>o});var n=r(104168),s=r(136244),a=r(586312);function o(e,t=(0,n.qd)("fetch")){let r=0,i=0;return(0,s.o)(e,function(s){let o=s.body.length;r+=o,i++;let l={body:s.body,method:"POST",referrerPolicy:"origin",headers:e.headers,keepalive:r<=6e4&&i<15,...e.fetchOptions};if(!t)return(0,n.y7)("fetch"),(0,a.xg)("No fetch implementation available");try{return t(e.url,l).then(e=>(r-=o,i--,{statusCode:e.status,headers:{"x-sentry-rate-limits":e.headers.get("X-Sentry-Rate-Limits"),"retry-after":e.headers.get("Retry-After")}}))}catch(e){return(0,n.y7)("fetch"),r-=o,i--,(0,a.xg)(e)}})}},48718(e,t,r){"use strict";r.d(t,{D:()=>c});var n=r(107842),s=r(696294),a=r(40209),o=r(67904),i=r(290264);let l=[/^Script error\.?$/,/^Javascript error: Script error\.? on line 0$/,/^ResizeObserver loop completed with undelivered notifications.$/,/^Cannot redefine property: googletag$/,"undefined is not an object (evaluating 'a.L')",'can\'t redefine non-configurable property "solana"',"vv().getRestrictions is not a function. (In 'vv().getRestrictions(1,a)', 'vv().getRestrictions' is undefined)","Can't find variable: _AutofillCallbackHandler"],c=(0,i._C)((e={})=>({name:"InboundFilters",processEvent:(t,r,i)=>{var c,m,d,p,h;return(c=t,(m=function(e={},t={}){return{allowUrls:[...e.allowUrls||[],...t.allowUrls||[]],denyUrls:[...e.denyUrls||[],...t.denyUrls||[]],ignoreErrors:[...e.ignoreErrors||[],...t.ignoreErrors||[],...e.disableErrorDefaults?[]:l],ignoreTransactions:[...e.ignoreTransactions||[],...t.ignoreTransactions||[]],ignoreInternal:void 0===e.ignoreInternal||e.ignoreInternal}}(e,i.getOptions())).ignoreInternal&&function(e){try{return"SentryError"===e.exception.values[0].type}catch(e){}return!1}(c)?(o.T&&n.vF.warn(`Event dropped due to being internal Sentry Error.
Event: ${(0,s.$X)(c)}`),0):(d=c,p=m.ignoreErrors,!d.type&&p&&p.length&&(function(e){let t,r=[];e.message&&r.push(e.message);try{t=e.exception.values[e.exception.values.length-1]}catch(e){}return t&&t.value&&(r.push(t.value),t.type&&r.push(`${t.type}: ${t.value}`)),r})(d).some(e=>(0,a.Xr)(e,p)))?(o.T&&n.vF.warn(`Event dropped due to being matched by \`ignoreErrors\` option.
Event: ${(0,s.$X)(c)}`),0):(h=c).type||!h.exception||!h.exception.values||0===h.exception.values.length||h.message||h.exception.values.some(e=>e.stacktrace||e.type&&"Error"!==e.type||e.value)?!function(e,t){if("transaction"!==e.type||!t||!t.length)return!1;let r=e.transaction;return!!r&&(0,a.Xr)(r,t)}(c,m.ignoreTransactions)?!function(e,t){if(!t||!t.length)return!1;let r=u(e);return!!r&&(0,a.Xr)(r,t)}(c,m.denyUrls)?function(e,t){if(!t||!t.length)return!0;let r=u(e);return!r||(0,a.Xr)(r,t)}(c,m.allowUrls)||(o.T&&n.vF.warn(`Event dropped due to not being matched by \`allowUrls\` option.
Event: ${(0,s.$X)(c)}.
Url: ${u(c)}`),0):(o.T&&n.vF.warn(`Event dropped due to being matched by \`denyUrls\` option.
Event: ${(0,s.$X)(c)}.
Url: ${u(c)}`),0):(o.T&&n.vF.warn(`Event dropped due to being matched by \`ignoreTransactions\` option.
Event: ${(0,s.$X)(c)}`),0):(o.T&&n.vF.warn(`Event dropped due to not having an error message, error type or stacktrace.
Event: ${(0,s.$X)(c)}`),0))?t:null}}));function u(e){try{let t;try{t=e.exception.values[0].stacktrace.frames}catch(e){}return t?function(e=[]){for(let t=e.length-1;t>=0;t--){let r=e[t];if(r&&"<anonymous>"!==r.filename&&"[native code]"!==r.filename)return r.filename||null}return null}(t):null}catch(t){return o.T&&n.vF.error(`Cannot extract url for event ${(0,s.$X)(e)}`),null}}},59555(e,t,r){"use strict";r.d(t,{A:()=>a});let n="Error: [ethjs-rpc] rpc error with payload ",s="Error: ";function a(e){if(e.includes(n)){let t=e.slice(n.length);return t.slice(t.indexOf(s)+s.length)}return e}},67904(e,t,r){"use strict";r.d(t,{T:()=>n});let n="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__},71409(e,t,r){"use strict";r.d(t,{f:()=>o,r:()=>a});var n=r(97407);let s="_sentrySpan";function a(e,t){t?(0,n.my)(e,s,t):delete e[s]}function o(e){return e[s]}},76838(e,t,r){"use strict";r.d(t,{Z:()=>o,k:()=>i});var n=r(895315),s=r(97407);function a(e){let t=e.protocol?`${e.protocol}:`:"",r=e.port?`:${e.port}`:"";return`${t}//${e.host}${r}${e.path?`/${e.path}`:""}/api/`}function o(e,t,r){return t||`${a(e)}${e.projectId}/envelope/?${(0,s.u4)({sentry_key:e.publicKey,sentry_version:"7",...r&&{sentry_client:`${r.name}/${r.version}`}})}`}function i(e,t){let r=(0,n.AD)(e);if(!r)return"";let s=`${a(r)}embed/error-page/`,o=`dsn=${(0,n.SB)(r)}`;for(let e in t)if("dsn"!==e&&"onClose"!==e)if("user"===e){let e=t.user;if(!e)continue;e.name&&(o+=`&name=${encodeURIComponent(e.name)}`),e.email&&(o+=`&email=${encodeURIComponent(e.email)}`)}else o+=`&${encodeURIComponent(e)}=${encodeURIComponent(t[e])}`;return`${s}?${o}`}},77614(e,t,r){"use strict";r.d(t,{U:()=>s});var n=r(718800);function s(){(0,n.s)()}},78121(e,t,r){"use strict";r.d(t,{Qi:()=>f});var n,s,a=r(290266),o=r(297564),i=r(447519),l=r(812805),c=r(814006),u=r(728195),m=r(33029),d=r(5654);let p=(0,a.KC)([c.rI,c.Es,c.ux,(0,a.Yj)(),(0,a.zM)(),o.FX]),h=(0,a.g1)((0,a.Yj)(),(0,a.me)(p));(0,a.g1)((0,a.Yj)(),(0,a.KC)([h,(0,a.me)(p)]));let f=(0,u.E$)(e=>(0,l.Gv)(e)&&!(0,l.i5)(e,"props")?d.vb:m.Pm);(0,a.g1)((0,a.Yj)(),i.zC),(n=s||(s={})).Insight="Insight",n.Dialog="Dialog",n.Notification="Notification",n.HomePage="HomePage"},80332(e,t,r){"use strict";r.d(t,{E:()=>p});var n,s,a=r(290266),o=r(545203),i=r(869864),l=r(694729),c=r(936435),u=r(728195),m=r(157392);(n=s||(s={})).Default="default",n.Critical="critical",n.Warning="warning";let d=(0,a.KC)([l.x,c.z,i.A]),p=(0,o.kp)(m.Tl,(0,a.Ik)({type:(0,u.eu)(m.Z6.Row),variant:(0,a.lq)((0,a.KC)([(0,u.$9)(s.Default),(0,u.$9)(s.Critical),(0,u.$9)(s.Warning)])),label:(0,a.Yj)(),value:d}))},85013(e,t,r){"use strict";r.d(t,{A:()=>a});var n=r(360569);function s(e,t){let r=e=>e.toUTC(0,{keepLocalTime:!0}).startOf("day").valueOf(),s=r(t)-r(e);return Math.floor(n.Ay.fromMillis(s).as("days"))}function a(e,t,r,a){let[o,i,l,c]=function(e,t,r){let n,a,o={},i=e;for(let[l,c]of[["years",(e,t)=>t.year-e.year],["quarters",(e,t)=>t.quarter-e.quarter+(t.year-e.year)*4],["months",(e,t)=>t.month-e.month+(t.year-e.year)*12],["weeks",(e,t)=>{let r=s(e,t);return(r-r%7)/7}],["days",s]])r.indexOf(l)>=0&&(n=l,o[l]=c(e,t),(a=i.plus(o))>t?(o[l]--,(e=i.plus(o))>t&&(a=e,o[l]--,e=i.plus(o))):e=a);return[e,o,a,n]}(e,t,r),u=t-o,m=r.filter(e=>["hours","minutes","seconds","milliseconds"].indexOf(e)>=0);0===m.length&&(l<t&&(l=o.plus({[c]:1})),l!==o&&(i[c]=(i[c]||0)+u/(l-o)));let d=n.Ay.fromObject(i,a);return m.length>0?n.Ay.fromMillis(u,a).shiftTo(...m).plus(d):d}},85182(e,t,r){"use strict";r.d(t,{Cj:()=>b,W3:()=>l,bN:()=>d,bm:()=>f,h4:()=>i,hP:()=>u,mE:()=>p,n2:()=>k,y5:()=>h,yH:()=>c,zk:()=>y});var n=r(895315),s=r(654761),a=r(97407),o=r(230337);function i(e,t=[]){return[e,t]}function l(e,t){let[r,n]=e;return[r,[...n,t]]}function c(e,t){for(let r of e[1]){let e=r[0].type;if(t(r,e))return!0}return!1}function u(e,t){return c(e,(e,r)=>t.includes(r))}function m(e){return o.O.__SENTRY__&&o.O.__SENTRY__.encodePolyfill?o.O.__SENTRY__.encodePolyfill(e):new TextEncoder().encode(e)}function d(e){let[t,r]=e,n=JSON.stringify(t);function a(e){"string"==typeof n?n="string"==typeof e?n+e:[m(n),e]:n.push("string"==typeof e?m(e):e)}for(let e of r){let[t,r]=e;if(a(`
${JSON.stringify(t)}
`),"string"==typeof r||r instanceof Uint8Array)a(r);else{let e;try{e=JSON.stringify(r)}catch(t){e=JSON.stringify((0,s.S8)(r))}a(e)}}return"string"==typeof n?n:function(e){let t=new Uint8Array(e.reduce((e,t)=>e+t.length,0)),r=0;for(let n of e)t.set(n,r),r+=n.length;return t}(n)}function p(e){let t="string"==typeof e?m(e):e;function r(e){let r=t.subarray(0,e);return t=t.subarray(e+1),r}function n(){var e;let n=t.indexOf(10);return n<0&&(n=t.length),JSON.parse((e=r(n),o.O.__SENTRY__&&o.O.__SENTRY__.decodePolyfill?o.O.__SENTRY__.decodePolyfill(e):new TextDecoder().decode(e)))}let s=n(),a=[];for(;t.length;){let e=n(),t="number"==typeof e.length?e.length:void 0;a.push([e,t?r(t):n()])}return[s,a]}function h(e){return[{type:"span"},e]}function f(e){let t="string"==typeof e.data?m(e.data):e.data;return[(0,a.Ce)({type:"attachment",length:t.length,filename:e.filename,content_type:e.contentType,attachment_type:e.attachmentType}),t]}let g={session:"session",sessions:"session",attachment:"attachment",transaction:"transaction",event:"error",client_report:"internal",user_report:"default",profile:"profile",profile_chunk:"profile",replay_event:"replay",replay_recording:"replay",check_in:"monitor",feedback:"feedback",span:"span",statsd:"metric_bucket"};function y(e){return g[e]}function b(e){if(!e||!e.sdk)return;let{name:t,version:r}=e.sdk;return{name:t,version:r}}function k(e,t,r,s){let o=e.sdkProcessingMetadata&&e.sdkProcessingMetadata.dynamicSamplingContext;return{event_id:e.event_id,sent_at:new Date().toISOString(),...t&&{sdk:t},...!!r&&s&&{dsn:(0,n.SB)(s)},...o&&{trace:(0,a.Ce)({...o})}}}},92376(e,t,r){"use strict";r.d(t,{Z:()=>o});var n=r(107842),s=r(37853),a=r(933190);function o(e,t){let r=(0,a.KU)(),o=(0,a.rm)();if(!r)return;let{beforeBreadcrumb:i=null,maxBreadcrumbs:l=100}=r.getOptions();if(l<=0)return;let c={timestamp:(0,s.lu)(),...e},u=i?(0,n.pq)(()=>i(c,t)):c;null!==u&&(r.emit&&r.emit("beforeAddBreadcrumb",u,t),o.addBreadcrumb(u,l))}},96331(e,t,r){"use strict";r.d(t,{AJ:()=>o,F3:()=>s,N8:()=>i,TJ:()=>a,a3:()=>n});let n=0,s=1,a=2;function o(e){if(e<400&&e>=100)return{code:s};if(e>=400&&e<500)switch(e){case 401:return{code:a,message:"unauthenticated"};case 403:return{code:a,message:"permission_denied"};case 404:return{code:a,message:"not_found"};case 409:return{code:a,message:"already_exists"};case 413:return{code:a,message:"failed_precondition"};case 429:return{code:a,message:"resource_exhausted"};case 499:return{code:a,message:"cancelled"};default:return{code:a,message:"invalid_argument"}}if(e>=500&&e<600)switch(e){case 501:return{code:a,message:"unimplemented"};case 503:return{code:a,message:"unavailable"};case 504:return{code:a,message:"deadline_exceeded"};default:return{code:a,message:"internal_error"}}return{code:a,message:"unknown_error"}}function i(e,t){e.setAttribute("http.response.status_code",t);let r=o(t);"unknown_error"!==r.message&&e.setStatus(r)}},97407(e,t,r){"use strict";r.d(t,{Ce:()=>y,GS:()=>l,HF:()=>g,W4:()=>p,my:()=>c,pO:()=>u,sp:()=>m,u4:()=>d});var n=r(834028),s=r(562298),a=r(397718),o=r(107842),i=r(40209);function l(e,t,r){if(!(t in e))return;let n=e[t],s=r(n);"function"==typeof s&&u(s,n),e[t]=s}function c(e,t,r){try{Object.defineProperty(e,t,{value:r,writable:!0,configurable:!0})}catch(r){s.T&&o.vF.log(`Failed to add non-enumerable property "${t}" to object`,e)}}function u(e,t){try{let r=t.prototype||{};e.prototype=t.prototype=r,c(e,"__sentry_original__",t)}catch(e){}}function m(e){return e.__sentry_original__}function d(e){return Object.keys(e).map(t=>`${encodeURIComponent(t)}=${encodeURIComponent(e[t])}`).join("&")}function p(e){if((0,a.bJ)(e))return{message:e.message,name:e.name,stack:e.stack,...f(e)};if(!(0,a.xH)(e))return e;{let t={type:e.type,target:h(e.target),currentTarget:h(e.currentTarget),...f(e)};return"undefined"!=typeof CustomEvent&&(0,a.tH)(e,CustomEvent)&&(t.detail=e.detail),t}}function h(e){try{return(0,a.vq)(e)?(0,n.Hd)(e):Object.prototype.toString.call(e)}catch(e){return"<unknown>"}}function f(e){if("object"!=typeof e||null===e)return{};{let t={};for(let r in e)Object.prototype.hasOwnProperty.call(e,r)&&(t[r]=e[r]);return t}}function g(e,t=40){let r=Object.keys(p(e));r.sort();let n=r[0];if(!n)return"[object has no keys]";if(n.length>=t)return(0,i.xv)(n,t);for(let e=r.length;e>0;e--){let n=r.slice(0,e).join(", ");if(!(n.length>t)){if(e===r.length)return n;return(0,i.xv)(n,t)}}return""}function y(e){return function e(t,r){if(function(e){if(!(0,a.Qd)(e))return!1;try{let t=Object.getPrototypeOf(e).constructor.name;return!t||"Object"===t}catch(e){return!0}}(t)){let n=r.get(t);if(void 0!==n)return n;let s={};for(let n of(r.set(t,s),Object.getOwnPropertyNames(t)))void 0!==t[n]&&(s[n]=e(t[n],r));return s}if(Array.isArray(t)){let n=r.get(t);if(void 0!==n)return n;let s=[];return r.set(t,s),t.forEach(t=>{s.push(e(t,r))}),s}return t}(e,new Map)}},101292(e){e.exports=o,o.default=o,o.stable=c,o.stableStringify=c;var t="[...]",r="[Circular]",n=[],s=[];function a(){return{depthLimit:Number.MAX_SAFE_INTEGER,edgesLimit:Number.MAX_SAFE_INTEGER}}function o(e,o,l,c){void 0===c&&(c=a()),function e(n,s,a,o,l,c,u){if(c+=1,"object"==typeof n&&null!==n){for(m=0;m<o.length;m++)if(o[m]===n)return void i(r,n,s,l);if(void 0!==u.depthLimit&&c>u.depthLimit||void 0!==u.edgesLimit&&a+1>u.edgesLimit)return void i(t,n,s,l);if(o.push(n),Array.isArray(n))for(m=0;m<n.length;m++)e(n[m],m,m,o,n,c,u);else{var m,d=Object.keys(n);for(m=0;m<d.length;m++){var p=d[m];e(n[p],p,m,o,n,c,u)}}o.pop()}}(e,"",0,[],void 0,0,c);try{m=0===s.length?JSON.stringify(e,o,l):JSON.stringify(e,u(o),l)}catch(e){return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]")}finally{for(;0!==n.length;){var m,d=n.pop();4===d.length?Object.defineProperty(d[0],d[1],d[3]):d[0][d[1]]=d[2]}}return m}function i(e,t,r,a){var o=Object.getOwnPropertyDescriptor(a,r);void 0!==o.get?o.configurable?(Object.defineProperty(a,r,{value:e}),n.push([a,r,t,o])):s.push([t,r,e]):(a[r]=e,n.push([a,r,t]))}function l(e,t){return e<t?-1:+(e>t)}function c(e,o,c,m){void 0===m&&(m=a());var d,p=function e(s,a,o,c,u,m,d){if(m+=1,"object"==typeof s&&null!==s){for(p=0;p<c.length;p++)if(c[p]===s)return void i(r,s,a,u);try{if("function"==typeof s.toJSON)return}catch(e){return}if(void 0!==d.depthLimit&&m>d.depthLimit||void 0!==d.edgesLimit&&o+1>d.edgesLimit)return void i(t,s,a,u);if(c.push(s),Array.isArray(s))for(p=0;p<s.length;p++)e(s[p],p,p,c,s,m,d);else{var p,h={},f=Object.keys(s).sort(l);for(p=0;p<f.length;p++){var g=f[p];e(s[g],g,p,c,s,m,d),h[g]=s[g]}if(void 0===u)return h;n.push([u,a,s]),u[a]=h}c.pop()}}(e,"",0,[],void 0,0,m)||e;try{d=0===s.length?JSON.stringify(p,o,c):JSON.stringify(p,u(o),c)}catch(e){return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]")}finally{for(;0!==n.length;){var h=n.pop();4===h.length?Object.defineProperty(h[0],h[1],h[3]):h[0][h[1]]=h[2]}}return d}function u(e){return e=void 0!==e?e:function(e,t){return t},function(t,r){if(s.length>0)for(var n=0;n<s.length;n++){var a=s[n];if(a[1]===t&&a[0]===r){r=a[2],s.splice(n,1);break}}return e.call(this,t,r)}}},104168(e,t,r){"use strict";r.d(t,{qd:()=>l,wg:()=>u,y7:()=>c});var n=r(107842),s=r(388006),a=r(756025),o=r(12796);let i={};function l(e){let t=i[e];if(t)return t;let r=o.j[e];if((0,s.a3)(r))return i[e]=r.bind(o.j);let l=o.j.document;if(l&&"function"==typeof l.createElement)try{let t=l.createElement("iframe");t.hidden=!0,l.head.appendChild(t);let n=t.contentWindow;n&&n[e]&&(r=n[e]),l.head.removeChild(t)}catch(t){a.T&&n.vF.warn(`Could not create sandbox iframe for ${e} check, bailing to window.${e}: `,t)}return r?i[e]=r.bind(o.j):r}function c(e){i[e]=void 0}function u(...e){return l("setTimeout")(...e)}},105388(e,t,r){"use strict";r.d(t,{W:()=>y});var n=r(107842),s=r(696294),a=r(97407),o=r(37853),i=r(933190),l=r(67904),c=r(179184),u=r(973149),m=r(812863),d=r(608119),p=r(836164),h=r(24708),f=r(173177),g=r(584222);class y{constructor(e={}){this._traceId=e.traceId||(0,s.eJ)(),this._spanId=e.spanId||(0,s.eJ)().substring(16),this._startTime=e.startTimestamp||(0,o.zf)(),this._attributes={},this.setAttributes({[m.JD]:"manual",[m.uT]:e.op,...e.attributes}),this._name=e.name,e.parentSpanId&&(this._parentSpanId=e.parentSpanId),"sampled"in e&&(this._sampled=e.sampled),e.endTimestamp&&(this._endTime=e.endTimestamp),this._events=[],this._isStandaloneSpan=e.isStandalone,this._endTime&&this._onSpanEnded()}addLink(e){return this}addLinks(e){return this}recordException(e,t){}spanContext(){let{_spanId:e,_traceId:t,_sampled:r}=this;return{spanId:e,traceId:t,traceFlags:r?d.aO:d.CC}}setAttribute(e,t){return void 0===t?delete this._attributes[e]:this._attributes[e]=t,this}setAttributes(e){return Object.keys(e).forEach(t=>this.setAttribute(t,e[t])),this}updateStartTime(e){this._startTime=(0,d.cI)(e)}setStatus(e){return this._status=e,this}updateName(e){return this._name=e,this}end(e){this._endTime||(this._endTime=(0,d.cI)(e),(0,h.U)(this),this._onSpanEnded())}getSpanJSON(){return(0,a.Ce)({data:this._attributes,description:this._name,op:this._attributes[m.uT],parent_span_id:this._parentSpanId,span_id:this._spanId,start_timestamp:this._startTime,status:(0,d.yW)(this._status),timestamp:this._endTime,trace_id:this._traceId,origin:this._attributes[m.JD],_metrics_summary:(0,u.g)(this),profile_id:this._attributes[m.E1],exclusive_time:this._attributes[m.jG],measurements:(0,f.$)(this._events),is_segment:this._isStandaloneSpan&&(0,d.zU)(this)===this||void 0,segment_id:this._isStandaloneSpan?(0,d.zU)(this).spanContext().spanId:void 0})}isRecording(){return!this._endTime&&!!this._sampled}addEvent(e,t,r){l.T&&n.vF.log("[Tracing] Adding an event to span:",e);let s=b(t)?t:r||(0,o.zf)(),a=b(t)?{}:t||{},i={name:e,time:(0,d.cI)(s),attributes:a};return this._events.push(i),this}isStandaloneSpan(){return!!this._isStandaloneSpan}_onSpanEnded(){let e=(0,i.KU)();if(e&&e.emit("spanEnd",this),!(this._isStandaloneSpan||this===(0,d.zU)(this)))return;if(this._isStandaloneSpan)return void(this._sampled?function(e){let t=(0,i.KU)();if(!t)return;let r=e[1];if(!r||0===r.length)return t.recordDroppedEvent("before_send","span");let s=t.getTransport();s&&s.send(e).then(null,e=>{l.T&&n.vF.error("Error while sending span:",e)})}((0,c.lu)([this],e)):(l.T&&n.vF.log("[Tracing] Discarding standalone span because its trace was not chosen to be sampled."),e&&e.recordDroppedEvent("sample_rate","span")));let t=this._convertSpanToTransaction();t&&((0,g.Lb)(this).scope||(0,i.o5)()).captureEvent(t)}_convertSpanToTransaction(){if(!k((0,d.et)(this)))return;this._name||(l.T&&n.vF.warn("Transaction has no name, falling back to `<unlabeled transaction>`."),this._name="<unlabeled transaction>");let{scope:e,isolationScope:t}=(0,g.Lb)(this),r=(e||(0,i.o5)()).getClient()||(0,i.KU)();if(!0!==this._sampled){l.T&&n.vF.log("[Tracing] Discarding transaction because its trace was not chosen to be sampled."),r&&r.recordDroppedEvent("sample_rate","transaction");return}let s=(0,d.xO)(this).filter(e=>{var t;return e!==this&&!((t=e)instanceof y&&t.isStandaloneSpan())}).map(e=>(0,d.et)(e)).filter(k),o=this._attributes[m.i_],c={contexts:{trace:(0,d.Ck)(this)},spans:s.length>1e3?s.sort((e,t)=>e.start_timestamp-t.start_timestamp).slice(0,1e3):s,start_timestamp:this._startTime,timestamp:this._endTime,transaction:this._name,type:"transaction",sdkProcessingMetadata:{capturedSpanScope:e,capturedSpanIsolationScope:t,...(0,a.Ce)({dynamicSamplingContext:(0,p.k1)(this)})},_metrics_summary:(0,u.g)(this),...o&&{transaction_info:{source:o}}},h=(0,f.$)(this._events);return h&&Object.keys(h).length&&(l.T&&n.vF.log("[Measurements] Adding measurements to transaction event",JSON.stringify(h,void 0,2)),c.measurements=h),c}}function b(e){return e&&"number"==typeof e||e instanceof Date||Array.isArray(e)}function k(e){return!!e.start_timestamp&&!!e.timestamp&&!!e.span_id&&!!e.trace_id}},106438(e,t,r){"use strict";r.d(t,{C:()=>a});var n=r(666012),s=r(360023);let a=(0,n.aD)({lazyLoadIntegration:s.b})},107842(e,t,r){"use strict";r.d(t,{Ow:()=>a,Z9:()=>o,pq:()=>i,vF:()=>l});var n=r(562298),s=r(230337);let a=["debug","info","warn","error","log","assert","trace"],o={};function i(e){if(!("console"in s.O))return e();let t=s.O.console,r={},n=Object.keys(o);n.forEach(e=>{let n=o[e];r[e]=t[e],t[e]=n});try{return e()}finally{n.forEach(e=>{t[e]=r[e]})}}let l=(0,s.B)("logger",function(){let e=!1,t={enable:()=>{e=!0},disable:()=>{e=!1},isEnabled:()=>e};return n.T?a.forEach(r=>{t[r]=(...t)=>{e&&i(()=>{s.O.console[r](`Sentry Logger [${r}]:`,...t)})}}):a.forEach(e=>{t[e]=()=>void 0}),t})},115433(e,t,r){"use strict";r.d(t,{_:()=>s});var n=r(107842);let s=(0,r(290264)._C)((e={})=>{let t={debugger:!1,stringify:!1,...e};return{name:"Debug",setup(e){e.on("beforeSendEvent",(e,r)=>{t.debugger,(0,n.pq)(()=>{t.stringify?(console.log(JSON.stringify(e,null,2)),r&&Object.keys(r).length&&console.log(JSON.stringify(r,null,2))):(console.log(e),r&&Object.keys(r).length&&console.log(r))})})}}})},117172(e,t,r){"use strict";let o,i,l,c,u,m;r.d(t,{M:()=>rG,w:()=>rH});var d,p,h,f,g,y,b,k,v=r(799130),_=r(834529),w=r(812863),x=r(793111),S=r(933190),E=r(884405),j=r(719509),T=r(608119),A=r(768881),C=r(92376),I=r(834028),O=r(230337),M=r(424264),N=r(107842),D=r(696294),R=r(654761),L=r(97407),F=r(837075),P=r(40209),q=r(586312),z=r(37853),$=r(85182),U=r(425535),B=r(932294),W=r(133481),H=r(225669),V=r(104168),Y=r(714599);let G=O.O,J="sentryReplaySession",Z="Unable to send Replay";function K(e,t){return null!=e?e:t()}function X(e){let t,r=e[0],n=1;for(;n<e.length;){let s=e[n],a=e[n+1];if(n+=2,("optionalAccess"===s||"optionalCall"===s)&&null==r)return;"access"===s||"optionalAccess"===s?(t=r,r=a(r)):("call"===s||"optionalCall"===s)&&(r=a((...e)=>r.call(t,...e)),t=void 0)}return r}function Q(e){let t=X([e,"optionalAccess",e=>e.host]);return X([t,"optionalAccess",e=>e.shadowRoot])===e}function ee(e){return"[object ShadowRoot]"===Object.prototype.toString.call(e)}function et(e){try{var t;let r=e.rules||e.cssRules;return r?((t=Array.from(r,er).join("")).includes(" background-clip: text;")&&!t.includes(" -webkit-background-clip: text;")&&(t=t.replace(" background-clip: text;"," -webkit-background-clip: text; background-clip: text;")),t):null}catch(e){return null}}function er(e){let t;if("styleSheet"in e)try{t=et(e.styleSheet)||function(e){let{cssText:t}=e;if(t.split('"').length<3)return t;let r=["@import",`url(${JSON.stringify(e.href)})`];return""===e.layerName?r.push("layer"):e.layerName&&r.push(`layer(${e.layerName})`),e.supportsText&&r.push(`supports(${e.supportsText})`),e.media.length&&r.push(e.media.mediaText),r.join(" ")+";"}(e)}catch(e){}else if("selectorText"in e&&e.selectorText.includes(":"))return e.cssText.replace(/(\[(?:[\w-]+)[^\\])(:(?:[\w-]+)\])/gm,"$1\\$2");return t||e.cssText}(d=b||(b={}))[d.Document=0]="Document",d[d.DocumentType=1]="DocumentType",d[d.Element=2]="Element",d[d.Text=3]="Text",d[d.CDATA=4]="CDATA",d[d.Comment=5]="Comment";class en{constructor(){this.idNodeMap=new Map,this.nodeMetaMap=new WeakMap}getId(e){return e?K(X([this,"access",e=>e.getMeta,"call",t=>t(e),"optionalAccess",e=>e.id]),()=>-1):-1}getNode(e){return this.idNodeMap.get(e)||null}getIds(){return Array.from(this.idNodeMap.keys())}getMeta(e){return this.nodeMetaMap.get(e)||null}removeNodeFromMap(e){let t=this.getId(e);this.idNodeMap.delete(t),e.childNodes&&e.childNodes.forEach(e=>this.removeNodeFromMap(e))}has(e){return this.idNodeMap.has(e)}hasNode(e){return this.nodeMetaMap.has(e)}add(e,t){let r=t.id;this.idNodeMap.set(r,e),this.nodeMetaMap.set(e,t)}replace(e,t){let r=this.getNode(e);if(r){let e=this.nodeMetaMap.get(r);e&&this.nodeMetaMap.set(t,e)}this.idNodeMap.set(e,t)}reset(){this.idNodeMap=new Map,this.nodeMetaMap=new WeakMap}}function es({maskInputOptions:e,tagName:t,type:r}){return"OPTION"===t&&(t="SELECT"),!!(e[t.toLowerCase()]||r&&e[r]||"password"===r||"INPUT"===t&&!r&&e.text)}function ea({isMasked:e,element:t,value:r,maskInputFn:n}){let s=r||"";return e?(n&&(s=n(s,t)),"*".repeat(s.length)):s}function eo(e){return e.toLowerCase()}function ei(e){return e.toUpperCase()}let el="__rrweb_original__";function ec(e){let t=e.type;return e.hasAttribute("data-rr-is-password")?"password":t?eo(t):null}function eu(e,t,r){return"INPUT"===t&&("radio"===r||"checkbox"===r)?e.getAttribute("value")||"":e.value}function em(e,t){let r;try{r=new URL(e,K(t,()=>window.location.href))}catch(e){return null}return K(X([r.pathname.match(/\.([0-9a-z]+)(?:$)/i),"optionalAccess",e=>e[1]]),()=>null)}let ed={};function ep(e){let t=ed[e];if(t)return t;let r=window.document,n=window[e];if(r&&"function"==typeof r.createElement)try{let t=r.createElement("iframe");t.hidden=!0,r.head.appendChild(t);let s=t.contentWindow;s&&s[e]&&(n=s[e]),r.head.removeChild(t)}catch(e){}return ed[e]=n.bind(window)}function eh(...e){return ep("setTimeout")(...e)}function ef(...e){return ep("clearTimeout")(...e)}let eg=1,ey=RegExp("[^a-z0-9-_:]");function eb(){return eg++}let ek=/url\((?:(')([^']*)'|(")(.*?)"|([^)]*))\)/gm,ev=/^(?:[a-z+]+:)?\/\//i,e_=/^www\..*/i,ew=/^(data:)([^,]*),(.*)/i;function ex(e,t){return(e||"").replace(ek,(e,r,n,s,a,o)=>{let i=n||a||o,l=r||s||"";if(!i)return e;if(ev.test(i)||e_.test(i)||ew.test(i))return`url(${l}${i}${l})`;if("/"===i[0])return`url(${l}${(t.indexOf("//")>-1?t.split("/").slice(0,3).join("/"):t.split("/")[0]).split("?")[0]+i}${l})`;let c=t.split("/"),u=i.split("/");for(let e of(c.pop(),u))if("."===e)continue;else".."===e?c.pop():c.push(e);return`url(${l}${c.join("/")}${l})`})}let eS=/^[^ \t\n\r\u000c]+/,eE=/^[, \t\n\r\u000c]+/;function ej(e,t){if(!t||""===t.trim())return t;let r=e.createElement("a");return r.href=t,r.href}function eT(){let e=a.createElement("a");return e.href="",e.href}function eA(e,t,r,n,s,a){if(!n)return n;if("src"===r||"href"===r&&("use"!==t||"#"!==n[0])||"xlink:href"===r&&"#"!==n[0])return ej(e,n);if("background"===r&&("table"===t||"td"===t||"th"===t))return ej(e,n);if("srcset"===r)return function(e,t){if(""===t.trim())return t;let r=0;function n(e){let n,s=e.exec(t.substring(r));return s?(n=s[0],r+=n.length,n):""}let s=[];for(;n(eE),!(r>=t.length);){let a=n(eS);if(","===a.slice(-1))a=ej(e,a.substring(0,a.length-1)),s.push(a);else{let n="";a=ej(e,a);let o=!1;for(;;){let e=t.charAt(r);if(""===e){s.push((a+n).trim());break}if(o)")"===e&&(o=!1);else if(","===e){r+=1,s.push((a+n).trim());break}else"("===e&&(o=!0);n+=e,r+=1}}}return s.join(", ")}(e,n);if("style"===r)return ex(n,eT());else if("object"===t&&"data"===r)return ej(e,n);return"function"==typeof a?a(r,n,s):n}function eC(e,t,r){return("video"===e||"audio"===e)&&"autoplay"===t}function eI(e,t,r=1/0,n=0){return!e||e.nodeType!==e.ELEMENT_NODE||n>r?-1:t(e)?n:eI(e.parentNode,t,r,n+1)}function eO(e,t){return r=>{if(null===r)return!1;try{if(e){if("string"==typeof e){if(r.matches(`.${e}`))return!0}else if(function(e,t){for(let r=e.classList.length;r--;){let n=e.classList[r];if(t.test(n))return!0}return!1}(r,e))return!0}if(t&&r.matches(t))return!0;return!1}catch(e){return!1}}}function eM(e,t,r,n,s,a){try{let o=e.nodeType===e.ELEMENT_NODE?e:e.parentElement;if(null===o)return!1;if("INPUT"===o.tagName){let e=o.getAttribute("autocomplete");if(["current-password","new-password","cc-number","cc-exp","cc-exp-month","cc-exp-year","cc-csc"].includes(e))return!0}let i=-1,l=-1;if(a){if((l=eI(o,eO(n,s)))<0)return!0;i=eI(o,eO(t,r),l>=0?l:1/0)}else{if((i=eI(o,eO(t,r)))<0)return!1;l=eI(o,eO(n,s),i>=0?i:1/0)}return i>=0?!(l>=0)||i<=l:!(l>=0)&&!!a}catch(e){}return!!a}function eN(e){return null==e?"":e.toLowerCase()}function eD(e,t){let r,{doc:n,mirror:s,blockClass:l,blockSelector:c,unblockSelector:u,maskAllText:m,maskTextClass:d,unmaskTextClass:p,maskTextSelector:h,unmaskTextSelector:f,skipChild:g=!1,inlineStylesheet:y=!0,maskInputOptions:k={},maskAttributeFn:v,maskTextFn:_,maskInputFn:w,slimDOMOptions:x,dataURLOptions:S={},inlineImages:E=!1,recordCanvas:j=!1,onSerialize:T,onIframeLoad:A,iframeLoadTimeout:C=5e3,onStylesheetLoad:I,stylesheetLoadTimeout:O=5e3,keepIframeSrcFn:M=()=>!1,newlyAddedElement:N=!1}=t,{preserveWhiteSpace:D=!0}=t,R=function(e,t){let{doc:r,mirror:n,blockClass:s,blockSelector:l,unblockSelector:c,maskAllText:u,maskAttributeFn:m,maskTextClass:d,unmaskTextClass:p,maskTextSelector:h,unmaskTextSelector:f,inlineStylesheet:g,maskInputOptions:y={},maskTextFn:k,maskInputFn:v,dataURLOptions:_={},inlineImages:w,recordCanvas:x,keepIframeSrcFn:S,newlyAddedElement:E=!1}=t,j=function(e,t){if(!t.hasNode(e))return;let r=t.getId(e);return 1===r?void 0:r}(r,n);switch(e.nodeType){case e.DOCUMENT_NODE:if("CSS1Compat"!==e.compatMode)return{type:b.Document,childNodes:[],compatMode:e.compatMode};return{type:b.Document,childNodes:[]};case e.DOCUMENT_TYPE_NODE:return{type:b.DocumentType,name:e.name,publicId:e.publicId,systemId:e.systemId,rootId:j};case e.ELEMENT_NODE:return function(e,t){let r,{doc:n,blockClass:s,blockSelector:l,unblockSelector:c,inlineStylesheet:u,maskInputOptions:m={},maskAttributeFn:d,maskInputFn:p,dataURLOptions:h={},inlineImages:f,recordCanvas:g,keepIframeSrcFn:y,newlyAddedElement:k=!1,rootId:v,maskAllText:_,maskTextClass:w,unmaskTextClass:x,maskTextSelector:S,unmaskTextSelector:E}=t,j=function(e,t,r,n){try{if(n&&e.matches(n))return!1;if("string"==typeof t){if(e.classList.contains(t))return!0}else for(let r=e.classList.length;r--;){let n=e.classList[r];if(t.test(n))return!0}if(r)return e.matches(r)}catch(e){}return!1}(e,s,l,c),T=function(e){if(e instanceof HTMLFormElement)return"form";let t=eo(e.tagName);return ey.test(t)?"div":t}(e),A={},C=e.attributes.length;for(let t=0;t<C;t++){let r=e.attributes[t];r.name&&!eC(T,r.name,r.value)&&(A[r.name]=eA(n,T,eo(r.name),r.value,e,d))}if("link"===T&&u){let t=Array.from(n.styleSheets).find(t=>t.href===e.href),r=null;t&&(r=et(t)),r&&(delete A.rel,delete A.href,A._cssText=ex(r,t.href))}if("style"===T&&e.sheet&&!(e.innerText||e.textContent||"").trim().length){let t=et(e.sheet);t&&(A._cssText=ex(t,eT()))}if("input"===T||"textarea"===T||"select"===T||"option"===T){let t=ec(e),r=eu(e,ei(T),t),n=e.checked;if("submit"!==t&&"button"!==t&&r){let n=eM(e,w,S,x,E,es({type:t,tagName:ei(T),maskInputOptions:m}));A.value=ea({isMasked:n,element:e,value:r,maskInputFn:p})}n&&(A.checked=n)}if("option"===T&&(e.selected&&!m.select?A.selected=!0:delete A.selected),"canvas"===T&&g){if("2d"===e.__context)!function(e){let t=e.getContext("2d");if(!t)return!0;for(let r=0;r<e.width;r+=50)for(let n=0;n<e.height;n+=50){let s=t.getImageData;if(new Uint32Array((el in s?s[el]:s).call(t,r,n,Math.min(50,e.width-r),Math.min(50,e.height-n)).data.buffer).some(e=>0!==e))return!1}return!0}(e)&&(A.rr_dataURL=e.toDataURL(h.type,h.quality));else if(!("__context"in e)){let t=e.toDataURL(h.type,h.quality),r=a.createElement("canvas");r.width=e.width,r.height=e.height,t!==r.toDataURL(h.type,h.quality)&&(A.rr_dataURL=t)}}if("img"===T&&f){o||(i=(o=n.createElement("canvas")).getContext("2d"));let t=e.crossOrigin;e.crossOrigin="anonymous";let r=()=>{e.removeEventListener("load",r);try{o.width=e.naturalWidth,o.height=e.naturalHeight,i.drawImage(e,0,0),A.rr_dataURL=o.toDataURL(h.type,h.quality)}catch(t){console.warn(`Cannot inline img src=${e.currentSrc}! Error: ${t}`)}t?A.crossOrigin=t:e.removeAttribute("crossorigin")};e.complete&&0!==e.naturalWidth?r():e.addEventListener("load",r)}if(("audio"===T||"video"===T)&&(A.rr_mediaState=e.paused?"paused":"played",A.rr_mediaCurrentTime=e.currentTime),!k&&(e.scrollLeft&&(A.rr_scrollLeft=e.scrollLeft),e.scrollTop&&(A.rr_scrollTop=e.scrollTop)),j){let{width:t,height:r}=e.getBoundingClientRect();A={class:A.class,rr_width:`${t}px`,rr_height:`${r}px`}}"iframe"!==T||y(A.src)||(j||e.contentDocument||(A.rr_src=A.src),delete A.src);try{customElements.get(T)&&(r=!0)}catch(e){}return{type:b.Element,tagName:T,attributes:A,childNodes:[],isSVG:!!("svg"===e.tagName||e.ownerSVGElement)||void 0,needBlock:j,rootId:v,isCustom:r}}(e,{doc:r,blockClass:s,blockSelector:l,unblockSelector:c,inlineStylesheet:g,maskAttributeFn:m,maskInputOptions:y,maskInputFn:v,dataURLOptions:_,inlineImages:w,recordCanvas:x,keepIframeSrcFn:S,newlyAddedElement:E,rootId:j,maskAllText:u,maskTextClass:d,unmaskTextClass:p,maskTextSelector:h,unmaskTextSelector:f});case e.TEXT_NODE:return function(e,t){let{maskAllText:r,maskTextClass:n,unmaskTextClass:s,maskTextSelector:a,unmaskTextSelector:o,maskTextFn:i,maskInputOptions:l,maskInputFn:c,rootId:u}=t,m=e.parentNode&&e.parentNode.tagName,d=e.textContent,p="STYLE"===m||void 0,h="SCRIPT"===m||void 0,f="TEXTAREA"===m||void 0;if(p&&d){try{e.nextSibling||e.previousSibling||X([e,"access",e=>e.parentNode,"access",e=>e.sheet,"optionalAccess",e=>e.cssRules])&&(d=et(e.parentNode.sheet))}catch(t){console.warn(`Cannot get CSS styles from text's parentNode. Error: ${t}`,e)}d=ex(d,eT())}h&&(d="SCRIPT_PLACEHOLDER");let g=eM(e,n,a,s,o,r);return p||h||f||!d||!g||(d=i?i(d,e.parentElement):d.replace(/[\S]/g,"*")),f&&d&&(l.textarea||g)&&(d=c?c(d,e.parentNode):d.replace(/[\S]/g,"*")),"OPTION"===m&&d&&(d=ea({isMasked:eM(e,n,a,s,o,es({type:null,tagName:m,maskInputOptions:l})),element:e,value:d,maskInputFn:c})),{type:b.Text,textContent:d||"",isStyle:p,rootId:u}}(e,{maskAllText:u,maskTextClass:d,unmaskTextClass:p,maskTextSelector:h,unmaskTextSelector:f,maskTextFn:k,maskInputOptions:y,maskInputFn:v,rootId:j});case e.CDATA_SECTION_NODE:return{type:b.CDATA,textContent:"",rootId:j};case e.COMMENT_NODE:return{type:b.Comment,textContent:e.textContent||"",rootId:j};default:return!1}}(e,{doc:n,mirror:s,blockClass:l,blockSelector:c,maskAllText:m,unblockSelector:u,maskTextClass:d,unmaskTextClass:p,maskTextSelector:h,unmaskTextSelector:f,inlineStylesheet:y,maskInputOptions:k,maskAttributeFn:v,maskTextFn:_,maskInputFn:w,dataURLOptions:S,inlineImages:E,recordCanvas:j,keepIframeSrcFn:M,newlyAddedElement:N});if(!R)return console.warn(e,"not serialized"),null;r=s.hasNode(e)?s.getId(e):!function(e,t){if(t.comment&&e.type===b.Comment)return!0;if(e.type===b.Element){if(t.script&&("script"===e.tagName||"link"===e.tagName&&("preload"===e.attributes.rel||"modulepreload"===e.attributes.rel)&&"script"===e.attributes.as||"link"===e.tagName&&"prefetch"===e.attributes.rel&&"string"==typeof e.attributes.href&&"js"===em(e.attributes.href)))return!0;else if(t.headFavicon&&("link"===e.tagName&&"shortcut icon"===e.attributes.rel||"meta"===e.tagName&&(eN(e.attributes.name).match(/^msapplication-tile(image|color)$/)||"application-name"===eN(e.attributes.name)||"icon"===eN(e.attributes.rel)||"apple-touch-icon"===eN(e.attributes.rel)||"shortcut icon"===eN(e.attributes.rel))))return!0;else if("meta"===e.tagName){if(t.headMetaDescKeywords&&eN(e.attributes.name).match(/^description|keywords$/))return!0;else if(t.headMetaSocial&&(eN(e.attributes.property).match(/^(og|twitter|fb):/)||eN(e.attributes.name).match(/^(og|twitter):/)||"pinterest"===eN(e.attributes.name)))return!0;else if(t.headMetaRobots&&("robots"===eN(e.attributes.name)||"googlebot"===eN(e.attributes.name)||"bingbot"===eN(e.attributes.name)))return!0;else if(t.headMetaHttpEquiv&&void 0!==e.attributes["http-equiv"])return!0;else if(t.headMetaAuthorship&&("author"===eN(e.attributes.name)||"generator"===eN(e.attributes.name)||"framework"===eN(e.attributes.name)||"publisher"===eN(e.attributes.name)||"progid"===eN(e.attributes.name)||eN(e.attributes.property).match(/^article:/)||eN(e.attributes.property).match(/^product:/)))return!0;else if(t.headMetaVerification&&("google-site-verification"===eN(e.attributes.name)||"yandex-verification"===eN(e.attributes.name)||"csrf-token"===eN(e.attributes.name)||"p:domain_verify"===eN(e.attributes.name)||"verify-v1"===eN(e.attributes.name)||"verification"===eN(e.attributes.name)||"shopify-checkout-api-token"===eN(e.attributes.name)))return!0}}return!1}(R,x)&&(D||R.type!==b.Text||R.isStyle||R.textContent.replace(/^\s+|\s+$/gm,"").length)?eb():-2;let L=Object.assign(R,{id:r});if(s.add(e,L),-2===r)return null;T&&T(e);let F=!g;if(L.type===b.Element){F=F&&!L.needBlock,delete L.needBlock;let t=e.shadowRoot;t&&ee(t)&&(L.isShadowHost=!0)}if((L.type===b.Document||L.type===b.Element)&&F){x.headWhitespace&&L.type===b.Element&&"head"===L.tagName&&(D=!1);let t={doc:n,mirror:s,blockClass:l,blockSelector:c,maskAllText:m,unblockSelector:u,maskTextClass:d,unmaskTextClass:p,maskTextSelector:h,unmaskTextSelector:f,skipChild:g,inlineStylesheet:y,maskInputOptions:k,maskAttributeFn:v,maskTextFn:_,maskInputFn:w,slimDOMOptions:x,dataURLOptions:S,inlineImages:E,recordCanvas:j,preserveWhiteSpace:D,onSerialize:T,onIframeLoad:A,iframeLoadTimeout:C,onStylesheetLoad:I,stylesheetLoadTimeout:O,keepIframeSrcFn:M};for(let r of Array.from(e.childNodes)){let e=eD(r,t);e&&L.childNodes.push(e)}if(e.nodeType===e.ELEMENT_NODE&&e.shadowRoot)for(let r of Array.from(e.shadowRoot.childNodes)){let n=eD(r,t);n&&(ee(e.shadowRoot)&&(n.isShadow=!0),L.childNodes.push(n))}}return e.parentNode&&Q(e.parentNode)&&ee(e.parentNode)&&(L.isShadow=!0),L.type===b.Element&&"iframe"===L.tagName&&function(e,t,r){let n,s=e.contentWindow;if(!s)return;let a=!1;try{n=s.document.readyState}catch(e){return}if("complete"!==n){let n=eh(()=>{a||(t(),a=!0)},r);e.addEventListener("load",()=>{ef(n),a=!0,t()});return}let o="about:blank";if(s.location.href!==o||e.src===o||""===e.src)return eh(t,0),e.addEventListener("load",t);e.addEventListener("load",t)}(e,()=>{let t=e.contentDocument;if(t&&A){let r=eD(t,{doc:t,mirror:s,blockClass:l,blockSelector:c,unblockSelector:u,maskAllText:m,maskTextClass:d,unmaskTextClass:p,maskTextSelector:h,unmaskTextSelector:f,skipChild:!1,inlineStylesheet:y,maskInputOptions:k,maskAttributeFn:v,maskTextFn:_,maskInputFn:w,slimDOMOptions:x,dataURLOptions:S,inlineImages:E,recordCanvas:j,preserveWhiteSpace:D,onSerialize:T,onIframeLoad:A,iframeLoadTimeout:C,onStylesheetLoad:I,stylesheetLoadTimeout:O,keepIframeSrcFn:M});r&&A(e,r)}},C),L.type===b.Element&&"link"===L.tagName&&"string"==typeof L.attributes.rel&&("stylesheet"===L.attributes.rel||"preload"===L.attributes.rel&&"string"==typeof L.attributes.href&&"css"===em(L.attributes.href))&&function(e,t,r){let n,s=!1;try{n=e.sheet}catch(e){return}if(n)return;let a=eh(()=>{s||(t(),s=!0)},r);e.addEventListener("load",()=>{ef(a),s=!0,t()})}(e,()=>{if(I){let t=eD(e,{doc:n,mirror:s,blockClass:l,blockSelector:c,unblockSelector:u,maskAllText:m,maskTextClass:d,unmaskTextClass:p,maskTextSelector:h,unmaskTextSelector:f,skipChild:!1,inlineStylesheet:y,maskInputOptions:k,maskAttributeFn:v,maskTextFn:_,maskInputFn:w,slimDOMOptions:x,dataURLOptions:S,inlineImages:E,recordCanvas:j,preserveWhiteSpace:D,onSerialize:T,onIframeLoad:A,iframeLoadTimeout:C,onStylesheetLoad:I,stylesheetLoadTimeout:O,keepIframeSrcFn:M});t&&I(e,t)}},O),L}function eR(e){let t,r=e[0],n=1;for(;n<e.length;){let s=e[n],a=e[n+1];if(n+=2,("optionalAccess"===s||"optionalCall"===s)&&null==r)return;"access"===s||"optionalAccess"===s?(t=r,r=a(r)):("call"===s||"optionalCall"===s)&&(r=a((...e)=>r.call(t,...e)),t=void 0)}return r}function eL(e,t,r=a){let n={capture:!0,passive:!0};return r.addEventListener(e,t,n),()=>r.removeEventListener(e,t,n)}let eF=`Please stop import mirror directly. Instead of that,\r
now you can use replayer.getMirror() to access the mirror instance of a replayer,\r
or you can use record.mirror to access the mirror instance during recording.`,eP={map:{},getId:()=>(console.error(eF),-1),getNode:()=>(console.error(eF),null),removeNodeFromMap(){console.error(eF)},has:()=>(console.error(eF),!1),reset(){console.error(eF)}};function eq(e,t,r={}){let n=null,s=0;return function(...a){let o=Date.now();s||!1!==r.leading||(s=o);let i=t-(o-s),l=this;i<=0||i>t?(n&&(function(...e){e2("clearTimeout")(...e)}(n),n=null),s=o,e.apply(l,a)):n||!1===r.trailing||(n=e3(()=>{s=!1===r.leading?0:Date.now(),n=null,e.apply(l,a)},i))}}function ez(e,t,r){try{if(!(t in e))return()=>{};let n=e[t],s=r(n);return"function"==typeof s&&(s.prototype=s.prototype||{},Object.defineProperties(s,{__rrweb_original__:{enumerable:!1,value:n}})),e[t]=s,()=>{e[t]=n}}catch(e){return()=>{}}}"undefined"!=typeof window&&window.Proxy&&window.Reflect&&(eP=new Proxy(eP,{get:(e,t,r)=>("map"===t&&console.error(eF),Reflect.get(e,t,r))}));let e$=Date.now;function eU(e){let t=e.document;return{left:t.scrollingElement?t.scrollingElement.scrollLeft:void 0!==e.pageXOffset?e.pageXOffset:eR([t,"optionalAccess",e=>e.documentElement,"access",e=>e.scrollLeft])||eR([t,"optionalAccess",e=>e.body,"optionalAccess",e=>e.parentElement,"optionalAccess",e=>e.scrollLeft])||eR([t,"optionalAccess",e=>e.body,"optionalAccess",e=>e.scrollLeft])||0,top:t.scrollingElement?t.scrollingElement.scrollTop:void 0!==e.pageYOffset?e.pageYOffset:eR([t,"optionalAccess",e=>e.documentElement,"access",e=>e.scrollTop])||eR([t,"optionalAccess",e=>e.body,"optionalAccess",e=>e.parentElement,"optionalAccess",e=>e.scrollTop])||eR([t,"optionalAccess",e=>e.body,"optionalAccess",e=>e.scrollTop])||0}}function eB(){return window.innerHeight||a.documentElement&&a.documentElement.clientHeight||a.body&&a.body.clientHeight}function eW(){return window.innerWidth||a.documentElement&&a.documentElement.clientWidth||a.body&&a.body.clientWidth}function eH(e){return e?e.nodeType===e.ELEMENT_NODE?e:e.parentElement:null}function eV(e,t,r,n,s){if(!e)return!1;let a=eH(e);if(!a)return!1;let o=eO(t,r);if(!s){let e=n&&a.matches(n);return o(a)&&!e}let i=eI(a,o),l=-1;return!(i<0)&&(n&&(l=eI(a,eO(null,n))),i>-1&&l<0||i<l)}function eY(e,t){return -2===t.getId(e)}function eG(e){return!!e.changedTouches}function eJ(e,t){return!!("IFRAME"===e.nodeName&&t.getMeta(e))}function eZ(e,t){return!!("LINK"===e.nodeName&&e.nodeType===e.ELEMENT_NODE&&e.getAttribute&&"stylesheet"===e.getAttribute("rel")&&t.getMeta(e))}function eK(e){return!!eR([e,"optionalAccess",e=>e.shadowRoot])}/[1-9][0-9]{12}/.test(Date.now().toString())||(e$=()=>new Date().getTime());class eX{constructor(){this.id=1,this.styleIDMap=new WeakMap,this.idStyleMap=new Map}getId(e){return(0,v.S)(this.styleIDMap.get(e),()=>-1)}has(e){return this.styleIDMap.has(e)}add(e,t){let r;return this.has(e)?this.getId(e):(r=void 0===t?this.id++:t,this.styleIDMap.set(e,r),this.idStyleMap.set(r,e),r)}getStyle(e){return this.idStyleMap.get(e)||null}reset(){this.styleIDMap=new WeakMap,this.idStyleMap=new Map,this.id=1}generateId(){return this.id++}}function eQ(e){let t=null;return eR([e,"access",e=>e.getRootNode,"optionalCall",e=>e(),"optionalAccess",e=>e.nodeType])===Node.DOCUMENT_FRAGMENT_NODE&&e.getRootNode().host&&(t=e.getRootNode().host),t}function e0(e){let t=e.ownerDocument;return!!t&&(t.contains(e)||function(e){let t=e.ownerDocument;if(!t)return!1;let r=function(e){let t,r=e;for(;t=eQ(r);)r=t;return r}(e);return t.contains(r)}(e))}let e1={};function e2(e){let t=e1[e];if(t)return t;let r=window.document,n=window[e];if(r&&"function"==typeof r.createElement)try{let t=r.createElement("iframe");t.hidden=!0,r.head.appendChild(t);let s=t.contentWindow;s&&s[e]&&(n=s[e]),r.head.removeChild(t)}catch(e){}return e1[e]=n.bind(window)}function e3(...e){return e2("setTimeout")(...e)}var e5=((p=e5||{})[p.DomContentLoaded=0]="DomContentLoaded",p[p.Load=1]="Load",p[p.FullSnapshot=2]="FullSnapshot",p[p.IncrementalSnapshot=3]="IncrementalSnapshot",p[p.Meta=4]="Meta",p[p.Custom=5]="Custom",p[p.Plugin=6]="Plugin",p),e6=((h=e6||{})[h.Mutation=0]="Mutation",h[h.MouseMove=1]="MouseMove",h[h.MouseInteraction=2]="MouseInteraction",h[h.Scroll=3]="Scroll",h[h.ViewportResize=4]="ViewportResize",h[h.Input=5]="Input",h[h.TouchMove=6]="TouchMove",h[h.MediaInteraction=7]="MediaInteraction",h[h.StyleSheetRule=8]="StyleSheetRule",h[h.CanvasMutation=9]="CanvasMutation",h[h.Font=10]="Font",h[h.Log=11]="Log",h[h.Drag=12]="Drag",h[h.StyleDeclaration=13]="StyleDeclaration",h[h.Selection=14]="Selection",h[h.AdoptedStyleSheet=15]="AdoptedStyleSheet",h[h.CustomElement=16]="CustomElement",h),e8=((f=e8||{})[f.MouseUp=0]="MouseUp",f[f.MouseDown=1]="MouseDown",f[f.Click=2]="Click",f[f.ContextMenu=3]="ContextMenu",f[f.DblClick=4]="DblClick",f[f.Focus=5]="Focus",f[f.Blur=6]="Blur",f[f.TouchStart=7]="TouchStart",f[f.TouchMove_Departed=8]="TouchMove_Departed",f[f.TouchEnd=9]="TouchEnd",f[f.TouchCancel=10]="TouchCancel",f),e4=((g=e4||{})[g.Mouse=0]="Mouse",g[g.Pen=1]="Pen",g[g.Touch=2]="Touch",g);class e9{constructor(){this.length=0,this.head=null,this.tail=null}get(e){if(e>=this.length)throw Error("Position outside of list range");let t=this.head;for(let r=0;r<e;r++)t=function(e){let t,r=e[0],n=1;for(;n<e.length;){let s=e[n],a=e[n+1];if(n+=2,("optionalAccess"===s||"optionalCall"===s)&&null==r)return;"access"===s||"optionalAccess"===s?(t=r,r=a(r)):("call"===s||"optionalCall"===s)&&(r=a((...e)=>r.call(t,...e)),t=void 0)}return r}([t,"optionalAccess",e=>e.next])||null;return t}addNode(e){let t={value:e,previous:null,next:null};if(e.__ln=t,e.previousSibling&&"__ln"in e.previousSibling){let r=e.previousSibling.__ln.next;t.next=r,t.previous=e.previousSibling.__ln,e.previousSibling.__ln.next=t,r&&(r.previous=t)}else if(e.nextSibling&&"__ln"in e.nextSibling&&e.nextSibling.__ln.previous){let r=e.nextSibling.__ln.previous;t.previous=r,t.next=e.nextSibling.__ln,e.nextSibling.__ln.previous=t,r&&(r.next=t)}else this.head&&(this.head.previous=t),t.next=this.head,this.head=t;null===t.next&&(this.tail=t),this.length++}removeNode(e){let t=e.__ln;this.head&&(t.previous?(t.previous.next=t.next,t.next?t.next.previous=t.previous:this.tail=t.previous):(this.head=t.next,this.head?this.head.previous=null:this.tail=null),e.__ln&&delete e.__ln,this.length--)}}let e7=(e,t)=>`${e}@${t}`;class te{constructor(){this.frozen=!1,this.locked=!1,this.texts=[],this.attributes=[],this.attributeMap=new WeakMap,this.removes=[],this.mapRemoves=[],this.movedMap={},this.addedSet=new Set,this.movedSet=new Set,this.droppedSet=new Set,this.processMutations=e=>{e.forEach(this.processMutation),this.emit()},this.emit=()=>{if(this.frozen||this.locked)return;let e=[],t=new Set,r=new e9,n=e=>{let t=e,r=-2;for(;-2===r;)r=(t=t&&t.nextSibling)&&this.mirror.getId(t);return r},s=s=>{if(!s.parentNode||!e0(s))return;let a=Q(s.parentNode)?this.mirror.getId(eQ(s)):this.mirror.getId(s.parentNode),o=n(s);if(-1===a||-1===o)return r.addNode(s);let i=eD(s,{doc:this.doc,mirror:this.mirror,blockClass:this.blockClass,blockSelector:this.blockSelector,maskAllText:this.maskAllText,unblockSelector:this.unblockSelector,maskTextClass:this.maskTextClass,unmaskTextClass:this.unmaskTextClass,maskTextSelector:this.maskTextSelector,unmaskTextSelector:this.unmaskTextSelector,skipChild:!0,newlyAddedElement:!0,inlineStylesheet:this.inlineStylesheet,maskInputOptions:this.maskInputOptions,maskAttributeFn:this.maskAttributeFn,maskTextFn:this.maskTextFn,maskInputFn:this.maskInputFn,slimDOMOptions:this.slimDOMOptions,dataURLOptions:this.dataURLOptions,recordCanvas:this.recordCanvas,inlineImages:this.inlineImages,onSerialize:e=>{eJ(e,this.mirror)&&!eV(e,this.blockClass,this.blockSelector,this.unblockSelector,!1)&&this.iframeManager.addIframe(e),eZ(e,this.mirror)&&this.stylesheetManager.trackLinkElement(e),eK(s)&&this.shadowDomManager.addShadowRoot(s.shadowRoot,this.doc)},onIframeLoad:(e,t)=>{eV(e,this.blockClass,this.blockSelector,this.unblockSelector,!1)||(this.iframeManager.attachIframe(e,t),e.contentWindow&&this.canvasManager.addWindow(e.contentWindow),this.shadowDomManager.observeAttachShadow(e))},onStylesheetLoad:(e,t)=>{this.stylesheetManager.attachLinkElement(e,t)}});i&&(e.push({parentId:a,nextId:o,node:i}),t.add(i.id))};for(;this.mapRemoves.length;)this.mirror.removeNodeFromMap(this.mapRemoves.shift());for(let e of this.movedSet)(!tr(this.removes,e,this.mirror)||this.movedSet.has(e.parentNode))&&s(e);for(let e of this.addedSet)tn(this.droppedSet,e)||tr(this.removes,e,this.mirror)?tn(this.movedSet,e)?s(e):this.droppedSet.add(e):s(e);let a=null;for(;r.length;){let e=null;if(a){let t=this.mirror.getId(a.value.parentNode),r=n(a.value);-1!==t&&-1!==r&&(e=a)}if(!e){let t=r.tail;for(;t;){let r=t;if(t=t.previous,r){let t=this.mirror.getId(r.value.parentNode);if(-1===n(r.value))continue;if(-1!==t){e=r;break}{let t=r.value;if(t.parentNode&&t.parentNode.nodeType===Node.DOCUMENT_FRAGMENT_NODE){let n=t.parentNode.host;if(-1!==this.mirror.getId(n)){e=r;break}}}}}}if(!e){for(;r.head;)r.removeNode(r.head.value);break}a=e.previous,r.removeNode(e.value),s(e.value)}let o={texts:this.texts.map(e=>({id:this.mirror.getId(e.node),value:e.value})).filter(e=>!t.has(e.id)).filter(e=>this.mirror.has(e.id)),attributes:this.attributes.map(e=>{let{attributes:t}=e;if("string"==typeof t.style){let r=JSON.stringify(e.styleDiff),n=JSON.stringify(e._unchangedStyles);r.length<t.style.length&&(r+n).split("var(").length===t.style.split("var(").length&&(t.style=e.styleDiff)}return{id:this.mirror.getId(e.node),attributes:t}}).filter(e=>!t.has(e.id)).filter(e=>this.mirror.has(e.id)),removes:this.removes,adds:e};(o.texts.length||o.attributes.length||o.removes.length||o.adds.length)&&(this.texts=[],this.attributes=[],this.attributeMap=new WeakMap,this.removes=[],this.addedSet=new Set,this.movedSet=new Set,this.droppedSet=new Set,this.movedMap={},this.mutationCb(o))},this.processMutation=e=>{if(!eY(e.target,this.mirror))switch(e.type){case"characterData":{let t=e.target.textContent;eV(e.target,this.blockClass,this.blockSelector,this.unblockSelector,!1)||t===e.oldValue||this.texts.push({value:eM(e.target,this.maskTextClass,this.maskTextSelector,this.unmaskTextClass,this.unmaskTextSelector,this.maskAllText)&&t?this.maskTextFn?this.maskTextFn(t,eH(e.target)):t.replace(/[\S]/g,"*"):t,node:e.target});break}case"attributes":{let t=e.target,r=e.attributeName,n=e.target.getAttribute(r);if("value"===r){let r=ec(t),s=t.tagName;n=eu(t,s,r);let a=es({maskInputOptions:this.maskInputOptions,tagName:s,type:r});n=ea({isMasked:eM(e.target,this.maskTextClass,this.maskTextSelector,this.unmaskTextClass,this.unmaskTextSelector,a),element:t,value:n,maskInputFn:this.maskInputFn})}if(eV(e.target,this.blockClass,this.blockSelector,this.unblockSelector,!1)||n===e.oldValue)return;let s=this.attributeMap.get(e.target);if("IFRAME"===t.tagName&&"src"===r&&!this.keepIframeSrcFn(n))if(t.contentDocument)return;else r="rr_src";if(s||(s={node:e.target,attributes:{},styleDiff:{},_unchangedStyles:{}},this.attributes.push(s),this.attributeMap.set(e.target,s)),"type"===r&&"INPUT"===t.tagName&&"password"===(e.oldValue||"").toLowerCase()&&t.setAttribute("data-rr-is-password","true"),!eC(t.tagName,r)&&(s.attributes[r]=eA(this.doc,eo(t.tagName),eo(r),n,t,this.maskAttributeFn),"style"===r)){if(!this.unattachedDoc)try{this.unattachedDoc=a.implementation.createHTMLDocument()}catch(e){this.unattachedDoc=this.doc}let r=this.unattachedDoc.createElement("span");for(let n of(e.oldValue&&r.setAttribute("style",e.oldValue),Array.from(t.style))){let e=t.style.getPropertyValue(n),a=t.style.getPropertyPriority(n);e!==r.style.getPropertyValue(n)||a!==r.style.getPropertyPriority(n)?""===a?s.styleDiff[n]=e:s.styleDiff[n]=[e,a]:s._unchangedStyles[n]=[e,a]}for(let e of Array.from(r.style))""===t.style.getPropertyValue(e)&&(s.styleDiff[e]=!1)}break}case"childList":if(eV(e.target,this.blockClass,this.blockSelector,this.unblockSelector,!0))return;e.addedNodes.forEach(t=>this.genAdds(t,e.target)),e.removedNodes.forEach(t=>{let r=this.mirror.getId(t),n=Q(e.target)?this.mirror.getId(e.target.host):this.mirror.getId(e.target);eV(e.target,this.blockClass,this.blockSelector,this.unblockSelector,!1)||eY(t,this.mirror)||-1===this.mirror.getId(t)||(this.addedSet.has(t)?(tt(this.addedSet,t),this.droppedSet.add(t)):this.addedSet.has(e.target)&&-1===r||function e(t,r){if(Q(t))return!1;let n=r.getId(t);return!r.has(n)||(!t.parentNode||t.parentNode.nodeType!==t.DOCUMENT_NODE)&&(!t.parentNode||e(t.parentNode,r))}(e.target,this.mirror)||(this.movedSet.has(t)&&this.movedMap[e7(r,n)]?tt(this.movedSet,t):this.removes.push({parentId:n,id:r,isShadow:!!(Q(e.target)&&ee(e.target))||void 0})),this.mapRemoves.push(t))})}},this.genAdds=(e,t)=>{if(!this.processedNodeManager.inOtherBuffer(e,this)&&!(this.addedSet.has(e)||this.movedSet.has(e))){if(this.mirror.hasNode(e)){if(eY(e,this.mirror))return;this.movedSet.add(e);let r=null;t&&this.mirror.hasNode(t)&&(r=this.mirror.getId(t)),r&&-1!==r&&(this.movedMap[e7(this.mirror.getId(e),r)]=!0)}else this.addedSet.add(e),this.droppedSet.delete(e);!eV(e,this.blockClass,this.blockSelector,this.unblockSelector,!1)&&(e.childNodes.forEach(e=>this.genAdds(e)),eK(e)&&e.shadowRoot.childNodes.forEach(t=>{this.processedNodeManager.add(t,this),this.genAdds(t,e)}))}}}init(e){["mutationCb","blockClass","blockSelector","unblockSelector","maskAllText","maskTextClass","unmaskTextClass","maskTextSelector","unmaskTextSelector","inlineStylesheet","maskInputOptions","maskAttributeFn","maskTextFn","maskInputFn","keepIframeSrcFn","recordCanvas","inlineImages","slimDOMOptions","dataURLOptions","doc","mirror","iframeManager","stylesheetManager","shadowDomManager","canvasManager","processedNodeManager"].forEach(t=>{this[t]=e[t]})}freeze(){this.frozen=!0,this.canvasManager.freeze()}unfreeze(){this.frozen=!1,this.canvasManager.unfreeze(),this.emit()}isFrozen(){return this.frozen}lock(){this.locked=!0,this.canvasManager.lock()}unlock(){this.locked=!1,this.canvasManager.unlock(),this.emit()}reset(){this.shadowDomManager.reset(),this.canvasManager.reset()}}function tt(e,t){e.delete(t),t.childNodes.forEach(t=>tt(e,t))}function tr(e,t,r){return 0!==e.length&&function e(t,r,n){let{parentNode:s}=r;if(!s)return!1;let a=n.getId(s);return!!t.some(e=>e.id===a)||e(t,s,n)}(e,t,r)}function tn(e,t){return 0!==e.size&&function e(t,r){let{parentNode:n}=r;return!!n&&(!!t.has(n)||e(t,n))}(e,t)}let ts=e=>l?(...t)=>{try{return e(...t)}catch(e){if(l&&!0===l(e))return()=>{};throw e}}:e;function ta(e){let t,r=e[0],n=1;for(;n<e.length;){let s=e[n],a=e[n+1];if(n+=2,("optionalAccess"===s||"optionalCall"===s)&&null==r)return;"access"===s||"optionalAccess"===s?(t=r,r=a(r)):("call"===s||"optionalCall"===s)&&(r=a((...e)=>r.call(t,...e)),t=void 0)}return r}let to=[];function ti(e){try{if("composedPath"in e){let t=e.composedPath();if(t.length)return t[0]}else if("path"in e&&e.path.length)return e.path[0]}catch(e){}return e&&e.target}function tl(e,t){let r=new te;to.push(r),r.init(e);let n=window.MutationObserver||window.__rrMutationObserver,s=ta([window,"optionalAccess",e=>e.Zone,"optionalAccess",e=>e.__symbol__,"optionalCall",e=>e("MutationObserver")]);s&&window[s]&&(n=window[s]);let a=new n(ts(t=>{e.onMutation&&!1===e.onMutation(t)||r.processMutations.bind(r)(t)}));return a.observe(t,{attributes:!0,attributeOldValue:!0,characterData:!0,characterDataOldValue:!0,childList:!0,subtree:!0}),a}function tc({scrollCb:e,doc:t,mirror:r,blockClass:n,blockSelector:s,unblockSelector:a,sampling:o}){return eL("scroll",ts(eq(ts(o=>{let i=ti(o);if(!i||eV(i,n,s,a,!0))return;let l=r.getId(i);if(i===t&&t.defaultView){let r=eU(t.defaultView);e({id:l,x:r.left,y:r.top})}else e({id:l,x:i.scrollLeft,y:i.scrollTop})}),o.scroll||100)),t)}let tu=["INPUT","TEXTAREA","SELECT"],tm=new WeakMap;function td(e){var t=[];if(tg("CSSGroupingRule")&&e.parentRule instanceof CSSGroupingRule||tg("CSSMediaRule")&&e.parentRule instanceof CSSMediaRule||tg("CSSSupportsRule")&&e.parentRule instanceof CSSSupportsRule||tg("CSSConditionRule")&&e.parentRule instanceof CSSConditionRule){let r=Array.from(e.parentRule.cssRules).indexOf(e);t.unshift(r)}else if(e.parentStyleSheet){let r=Array.from(e.parentStyleSheet.cssRules).indexOf(e);t.unshift(r)}return t}function tp(e,t,r){let n,s;return e?(e.ownerNode?n=t.getId(e.ownerNode):s=r.getId(e),{styleId:s,id:n}):{}}function th({mirror:e,stylesheetManager:t},r){let n=null;n="#document"===r.nodeName?e.getId(r):e.getId(r.host);let s="#document"===r.nodeName?ta([r,"access",e=>e.defaultView,"optionalAccess",e=>e.Document]):ta([r,"access",e=>e.ownerDocument,"optionalAccess",e=>e.defaultView,"optionalAccess",e=>e.ShadowRoot]),a=ta([s,"optionalAccess",e=>e.prototype])?Object.getOwnPropertyDescriptor(ta([s,"optionalAccess",e=>e.prototype]),"adoptedStyleSheets"):void 0;return null!==n&&-1!==n&&s&&a?(Object.defineProperty(r,"adoptedStyleSheets",{configurable:a.configurable,enumerable:a.enumerable,get(){return ta([a,"access",e=>e.get,"optionalAccess",e=>e.call,"call",e=>e(this)])},set(e){let r=ta([a,"access",e=>e.set,"optionalAccess",e=>e.call,"call",t=>t(this,e)]);if(null!==n&&-1!==n)try{t.adoptStyleSheets(e,n)}catch(e){}return r}}),ts(()=>{Object.defineProperty(r,"adoptedStyleSheets",{configurable:a.configurable,enumerable:a.enumerable,get:a.get,set:a.set})})):()=>{}}function tf(e,t={}){let r,n=e.doc.defaultView;if(!n)return()=>{};e.recordDOM&&(r=tl(e,e.doc));let s=function({mousemoveCb:e,sampling:t,doc:r,mirror:n}){let s;if(!1===t.mousemove)return()=>{};let a="number"==typeof t.mousemove?t.mousemove:50,o="number"==typeof t.mousemoveCallback?t.mousemoveCallback:500,i=[],l=eq(ts(t=>{let r=Date.now()-s;e(i.map(e=>(e.timeOffset-=r,e)),t),i=[],s=null}),o),c=ts(eq(ts(e=>{let t=ti(e),{clientX:r,clientY:a}=eG(e)?e.changedTouches[0]:e;s||(s=e$()),i.push({x:r,y:a,id:n.getId(t),timeOffset:e$()-s}),l("undefined"!=typeof DragEvent&&e instanceof DragEvent?e6.Drag:e instanceof MouseEvent?e6.MouseMove:e6.TouchMove)}),a,{trailing:!1})),u=[eL("mousemove",c,r),eL("touchmove",c,r),eL("drag",c,r)];return ts(()=>{u.forEach(e=>e())})}(e),a=function({mouseInteractionCb:e,doc:t,mirror:r,blockClass:n,blockSelector:s,unblockSelector:a,sampling:o}){if(!1===o.mouseInteraction)return()=>{};let i=!0===o.mouseInteraction||void 0===o.mouseInteraction?{}:o.mouseInteraction,l=[],c=null;return Object.keys(e8).filter(e=>Number.isNaN(Number(e))&&!e.endsWith("_Departed")&&!1!==i[e]).forEach(o=>{let i=eo(o),u=t=>{let i=ti(t);if(eV(i,n,s,a,!0))return;let l=null,u=o;if("pointerType"in t){switch(t.pointerType){case"mouse":l=e4.Mouse;break;case"touch":l=e4.Touch;break;case"pen":l=e4.Pen}l===e4.Touch?e8[o]===e8.MouseDown?u="TouchStart":e8[o]===e8.MouseUp&&(u="TouchEnd"):e4.Pen}else eG(t)&&(l=e4.Touch);null!==l?(c=l,(u.startsWith("Touch")&&l===e4.Touch||u.startsWith("Mouse")&&l===e4.Mouse)&&(l=null)):e8[o]===e8.Click&&(l=c,c=null);let m=eG(t)?t.changedTouches[0]:t;if(!m)return;let d=r.getId(i),{clientX:p,clientY:h}=m;ts(e)({type:e8[u],id:d,x:p,y:h,...null!==l&&{pointerType:l}})};if(window.PointerEvent)switch(e8[o]){case e8.MouseDown:case e8.MouseUp:i=i.replace("mouse","pointer");break;case e8.TouchStart:case e8.TouchEnd:return}l.push(eL(i,u,t))}),ts(()=>{l.forEach(e=>e())})}(e),o=tc(e),i=function({viewportResizeCb:e},{win:t}){let r=-1,n=-1;return eL("resize",ts(eq(ts(()=>{let t=eB(),s=eW();(r!==t||n!==s)&&(e({width:Number(s),height:Number(t)}),r=t,n=s)}),200)),t)}(e,{win:n}),l=function({inputCb:e,doc:t,mirror:r,blockClass:n,blockSelector:s,unblockSelector:a,ignoreClass:o,ignoreSelector:i,maskInputOptions:l,maskInputFn:c,sampling:u,userTriggeredOnInput:m,maskTextClass:d,unmaskTextClass:p,maskTextSelector:h,unmaskTextSelector:f}){function g(e){let r=ti(e),u=e.isTrusted,g=r&&ei(r.tagName);if("OPTION"===g&&(r=r.parentElement),!r||!g||0>tu.indexOf(g)||eV(r,n,s,a,!0))return;let b=r;if(b.classList.contains(o)||i&&b.matches(i))return;let k=ec(r),v=eu(b,g,k),_=!1,w=es({maskInputOptions:l,tagName:g,type:k}),x=eM(r,d,h,p,f,w);("radio"===k||"checkbox"===k)&&(_=r.checked),v=ea({isMasked:x,element:r,value:v,maskInputFn:c}),y(r,m?{text:v,isChecked:_,userTriggered:u}:{text:v,isChecked:_});let S=r.name;"radio"===k&&S&&_&&t.querySelectorAll(`input[type="radio"][name="${S}"]`).forEach(e=>{if(e!==r){let t=ea({isMasked:x,element:e,value:eu(e,g,k),maskInputFn:c});y(e,m?{text:t,isChecked:!_,userTriggered:!1}:{text:t,isChecked:!_})}})}function y(t,n){let s=tm.get(t);if(!s||s.text!==n.text||s.isChecked!==n.isChecked){tm.set(t,n);let s=r.getId(t);ts(e)({...n,id:s})}}let b=("last"===u.input?["change"]:["input","change"]).map(e=>eL(e,ts(g),t)),k=t.defaultView;if(!k)return()=>{b.forEach(e=>e())};let v=k.Object.getOwnPropertyDescriptor(k.HTMLInputElement.prototype,"value"),_=[[k.HTMLInputElement.prototype,"value"],[k.HTMLInputElement.prototype,"checked"],[k.HTMLSelectElement.prototype,"value"],[k.HTMLTextAreaElement.prototype,"value"],[k.HTMLSelectElement.prototype,"selectedIndex"],[k.HTMLOptionElement.prototype,"selected"]];return v&&v.set&&b.push(..._.map(e=>(function e(t,r,n,s,a=window){let o=a.Object.getOwnPropertyDescriptor(t,r);return a.Object.defineProperty(t,r,s?n:{set(e){e3(()=>{n.set.call(this,e)},0),o&&o.set&&o.set.call(this,e)}}),()=>e(t,r,o||{},!0)})(e[0],e[1],{set(){ts(g)({target:this,isTrusted:!1})}},!1,k))),ts(()=>{b.forEach(e=>e())})}(e),c=function({mediaInteractionCb:e,blockClass:t,blockSelector:r,unblockSelector:n,mirror:s,sampling:a,doc:o}){let i=ts(o=>eq(ts(a=>{let i=ti(a);if(!i||eV(i,t,r,n,!0))return;let{currentTime:l,volume:c,muted:u,playbackRate:m}=i;e({type:o,id:s.getId(i),currentTime:l,volume:c,muted:u,playbackRate:m})}),a.media||500)),l=[eL("play",i(0),o),eL("pause",i(1),o),eL("seeked",i(2),o),eL("volumechange",i(3),o),eL("ratechange",i(4),o)];return ts(()=>{l.forEach(e=>e())})}(e),u=()=>{},m=()=>{},d=()=>{},p=()=>{};e.recordDOM&&(u=function({styleSheetRuleCb:e,mirror:t,stylesheetManager:r},{win:n}){let s,a;if(!n.CSSStyleSheet||!n.CSSStyleSheet.prototype)return()=>{};let o=n.CSSStyleSheet.prototype.insertRule;n.CSSStyleSheet.prototype.insertRule=new Proxy(o,{apply:ts((n,s,a)=>{let[o,i]=a,{id:l,styleId:c}=tp(s,t,r.styleMirror);return(l&&-1!==l||c&&-1!==c)&&e({id:l,styleId:c,adds:[{rule:o,index:i}]}),n.apply(s,a)})});let i=n.CSSStyleSheet.prototype.deleteRule;n.CSSStyleSheet.prototype.deleteRule=new Proxy(i,{apply:ts((n,s,a)=>{let[o]=a,{id:i,styleId:l}=tp(s,t,r.styleMirror);return(i&&-1!==i||l&&-1!==l)&&e({id:i,styleId:l,removes:[{index:o}]}),n.apply(s,a)})}),n.CSSStyleSheet.prototype.replace&&(s=n.CSSStyleSheet.prototype.replace,n.CSSStyleSheet.prototype.replace=new Proxy(s,{apply:ts((n,s,a)=>{let[o]=a,{id:i,styleId:l}=tp(s,t,r.styleMirror);return(i&&-1!==i||l&&-1!==l)&&e({id:i,styleId:l,replace:o}),n.apply(s,a)})})),n.CSSStyleSheet.prototype.replaceSync&&(a=n.CSSStyleSheet.prototype.replaceSync,n.CSSStyleSheet.prototype.replaceSync=new Proxy(a,{apply:ts((n,s,a)=>{let[o]=a,{id:i,styleId:l}=tp(s,t,r.styleMirror);return(i&&-1!==i||l&&-1!==l)&&e({id:i,styleId:l,replaceSync:o}),n.apply(s,a)})}));let l={};ty("CSSGroupingRule")?l.CSSGroupingRule=n.CSSGroupingRule:(ty("CSSMediaRule")&&(l.CSSMediaRule=n.CSSMediaRule),ty("CSSConditionRule")&&(l.CSSConditionRule=n.CSSConditionRule),ty("CSSSupportsRule")&&(l.CSSSupportsRule=n.CSSSupportsRule));let c={};return Object.entries(l).forEach(([n,s])=>{c[n]={insertRule:s.prototype.insertRule,deleteRule:s.prototype.deleteRule},s.prototype.insertRule=new Proxy(c[n].insertRule,{apply:ts((n,s,a)=>{let[o,i]=a,{id:l,styleId:c}=tp(s.parentStyleSheet,t,r.styleMirror);return(l&&-1!==l||c&&-1!==c)&&e({id:l,styleId:c,adds:[{rule:o,index:[...td(s),i||0]}]}),n.apply(s,a)})}),s.prototype.deleteRule=new Proxy(c[n].deleteRule,{apply:ts((n,s,a)=>{let[o]=a,{id:i,styleId:l}=tp(s.parentStyleSheet,t,r.styleMirror);return(i&&-1!==i||l&&-1!==l)&&e({id:i,styleId:l,removes:[{index:[...td(s),o]}]}),n.apply(s,a)})})}),ts(()=>{n.CSSStyleSheet.prototype.insertRule=o,n.CSSStyleSheet.prototype.deleteRule=i,s&&(n.CSSStyleSheet.prototype.replace=s),a&&(n.CSSStyleSheet.prototype.replaceSync=a),Object.entries(l).forEach(([e,t])=>{t.prototype.insertRule=c[e].insertRule,t.prototype.deleteRule=c[e].deleteRule})})}(e,{win:n}),m=th(e,e.doc),d=function({styleDeclarationCb:e,mirror:t,ignoreCSSAttributes:r,stylesheetManager:n},{win:s}){let a=s.CSSStyleDeclaration.prototype.setProperty;s.CSSStyleDeclaration.prototype.setProperty=new Proxy(a,{apply:ts((s,o,i)=>{let[l,c,u]=i;if(r.has(l))return a.apply(o,[l,c,u]);let{id:m,styleId:d}=tp(ta([o,"access",e=>e.parentRule,"optionalAccess",e=>e.parentStyleSheet]),t,n.styleMirror);return(m&&-1!==m||d&&-1!==d)&&e({id:m,styleId:d,set:{property:l,value:c,priority:u},index:td(o.parentRule)}),s.apply(o,i)})});let o=s.CSSStyleDeclaration.prototype.removeProperty;return s.CSSStyleDeclaration.prototype.removeProperty=new Proxy(o,{apply:ts((s,a,i)=>{let[l]=i;if(r.has(l))return o.apply(a,[l]);let{id:c,styleId:u}=tp(ta([a,"access",e=>e.parentRule,"optionalAccess",e=>e.parentStyleSheet]),t,n.styleMirror);return(c&&-1!==c||u&&-1!==u)&&e({id:c,styleId:u,remove:{property:l},index:td(a.parentRule)}),s.apply(a,i)})}),ts(()=>{s.CSSStyleDeclaration.prototype.setProperty=a,s.CSSStyleDeclaration.prototype.removeProperty=o})}(e,{win:n}),e.collectFonts&&(p=function({fontCb:e,doc:t}){let r=t.defaultView;if(!r)return()=>{};let n=[],s=new WeakMap,a=r.FontFace;r.FontFace=function(e,t,r){let n=new a(e,t,r);return s.set(n,{family:e,buffer:"string"!=typeof t,descriptors:r,fontSource:"string"==typeof t?t:JSON.stringify(Array.from(new Uint8Array(t)))}),n};let o=ez(t.fonts,"add",function(t){return function(r){return e3(ts(()=>{let t=s.get(r);t&&(e(t),s.delete(r))}),0),t.apply(this,[r])}});return n.push(()=>{r.FontFace=a}),n.push(o),ts(()=>{n.forEach(e=>e())})}(e)));let h=function(e){let{doc:t,mirror:r,blockClass:n,blockSelector:s,unblockSelector:a,selectionCb:o}=e,i=!0,l=ts(()=>{let e=t.getSelection();if(!e||i&&ta([e,"optionalAccess",e=>e.isCollapsed]))return;i=e.isCollapsed||!1;let l=[],c=e.rangeCount||0;for(let t=0;t<c;t++){let{startContainer:o,startOffset:i,endContainer:c,endOffset:u}=e.getRangeAt(t);eV(o,n,s,a,!0)||eV(c,n,s,a,!0)||l.push({start:r.getId(o),startOffset:i,end:r.getId(c),endOffset:u})}o({ranges:l})});return l(),eL("selectionchange",l)}(e),f=function({doc:e,customElementCb:t}){let r=e.defaultView;return r&&r.customElements?ez(r.customElements,"define",function(e){return function(r,n,s){try{t({define:{name:r}})}catch(e){}return e.apply(this,[r,n,s])}}):()=>{}}(e),g=[];for(let t of e.plugins)g.push(t.observer(t.callback,n,t.options));return ts(()=>{to.forEach(e=>e.reset()),ta([r,"optionalAccess",e=>e.disconnect,"call",e=>e()]),s(),a(),o(),i(),l(),c(),u(),m(),d(),p(),h(),f(),g.forEach(e=>e())})}function tg(e){return void 0!==window[e]}function ty(e){return!!(void 0!==window[e]&&window[e].prototype&&"insertRule"in window[e].prototype&&"deleteRule"in window[e].prototype)}class tb{constructor(e){this.generateIdFn=e,this.iframeIdToRemoteIdMap=new WeakMap,this.iframeRemoteIdToIdMap=new WeakMap}getId(e,t,r,n){let s=r||this.getIdToRemoteIdMap(e),a=n||this.getRemoteIdToIdMap(e),o=s.get(t);return o||(o=this.generateIdFn(),s.set(t,o),a.set(o,t)),o}getIds(e,t){let r=this.getIdToRemoteIdMap(e),n=this.getRemoteIdToIdMap(e);return t.map(t=>this.getId(e,t,r,n))}getRemoteId(e,t,r){let n=r||this.getRemoteIdToIdMap(e);if("number"!=typeof t)return t;let s=n.get(t);return s||-1}getRemoteIds(e,t){let r=this.getRemoteIdToIdMap(e);return t.map(t=>this.getRemoteId(e,t,r))}reset(e){if(!e){this.iframeIdToRemoteIdMap=new WeakMap,this.iframeRemoteIdToIdMap=new WeakMap;return}this.iframeIdToRemoteIdMap.delete(e),this.iframeRemoteIdToIdMap.delete(e)}getIdToRemoteIdMap(e){let t=this.iframeIdToRemoteIdMap.get(e);return t||(t=new Map,this.iframeIdToRemoteIdMap.set(e,t)),t}getRemoteIdToIdMap(e){let t=this.iframeRemoteIdToIdMap.get(e);return t||(t=new Map,this.iframeRemoteIdToIdMap.set(e,t)),t}}function tk(e){let t,r=e[0],n=1;for(;n<e.length;){let s=e[n],a=e[n+1];if(n+=2,("optionalAccess"===s||"optionalCall"===s)&&null==r)return;"access"===s||"optionalAccess"===s?(t=r,r=a(r)):("call"===s||"optionalCall"===s)&&(r=a((...e)=>r.call(t,...e)),t=void 0)}return r}class tv{constructor(){this.crossOriginIframeMirror=new tb(eb),this.crossOriginIframeRootIdMap=new WeakMap}addIframe(){}addLoadListener(){}attachIframe(){}}class t_{constructor(e){this.iframes=new WeakMap,this.crossOriginIframeMap=new WeakMap,this.crossOriginIframeMirror=new tb(eb),this.crossOriginIframeRootIdMap=new WeakMap,this.mutationCb=e.mutationCb,this.wrappedEmit=e.wrappedEmit,this.stylesheetManager=e.stylesheetManager,this.recordCrossOriginIframes=e.recordCrossOriginIframes,this.crossOriginIframeStyleMirror=new tb(this.stylesheetManager.styleMirror.generateId.bind(this.stylesheetManager.styleMirror)),this.mirror=e.mirror,this.recordCrossOriginIframes&&window.addEventListener("message",this.handleMessage.bind(this))}addIframe(e){this.iframes.set(e,!0),e.contentWindow&&this.crossOriginIframeMap.set(e.contentWindow,e)}addLoadListener(e){this.loadListener=e}attachIframe(e,t){this.mutationCb({adds:[{parentId:this.mirror.getId(e),nextId:null,node:t}],removes:[],texts:[],attributes:[],isAttachIframe:!0}),tk([this,"access",e=>e.loadListener,"optionalCall",t=>t(e)]),e.contentDocument&&e.contentDocument.adoptedStyleSheets&&e.contentDocument.adoptedStyleSheets.length>0&&this.stylesheetManager.adoptStyleSheets(e.contentDocument.adoptedStyleSheets,this.mirror.getId(e.contentDocument))}handleMessage(e){if("rrweb"!==e.data.type||e.origin!==e.data.origin||!e.source)return;let t=this.crossOriginIframeMap.get(e.source);if(!t)return;let r=this.transformCrossOriginEvent(t,e.data.event);r&&this.wrappedEmit(r,e.data.isCheckout)}transformCrossOriginEvent(e,t){switch(t.type){case e5.FullSnapshot:{this.crossOriginIframeMirror.reset(e),this.crossOriginIframeStyleMirror.reset(e),this.replaceIdOnNode(t.data.node,e);let r=t.data.node.id;return this.crossOriginIframeRootIdMap.set(e,r),this.patchRootIdOnNode(t.data.node,r),{timestamp:t.timestamp,type:e5.IncrementalSnapshot,data:{source:e6.Mutation,adds:[{parentId:this.mirror.getId(e),nextId:null,node:t.data.node}],removes:[],texts:[],attributes:[],isAttachIframe:!0}}}case e5.Meta:case e5.Load:case e5.DomContentLoaded:break;case e5.Plugin:return t;case e5.Custom:return this.replaceIds(t.data.payload,e,["id","parentId","previousId","nextId"]),t;case e5.IncrementalSnapshot:switch(t.data.source){case e6.Mutation:return t.data.adds.forEach(t=>{this.replaceIds(t,e,["parentId","nextId","previousId"]),this.replaceIdOnNode(t.node,e);let r=this.crossOriginIframeRootIdMap.get(e);r&&this.patchRootIdOnNode(t.node,r)}),t.data.removes.forEach(t=>{this.replaceIds(t,e,["parentId","id"])}),t.data.attributes.forEach(t=>{this.replaceIds(t,e,["id"])}),t.data.texts.forEach(t=>{this.replaceIds(t,e,["id"])}),t;case e6.Drag:case e6.TouchMove:case e6.MouseMove:return t.data.positions.forEach(t=>{this.replaceIds(t,e,["id"])}),t;case e6.ViewportResize:return!1;case e6.MediaInteraction:case e6.MouseInteraction:case e6.Scroll:case e6.CanvasMutation:case e6.Input:return this.replaceIds(t.data,e,["id"]),t;case e6.StyleSheetRule:case e6.StyleDeclaration:return this.replaceIds(t.data,e,["id"]),this.replaceStyleIds(t.data,e,["styleId"]),t;case e6.Font:return t;case e6.Selection:return t.data.ranges.forEach(t=>{this.replaceIds(t,e,["start","end"])}),t;case e6.AdoptedStyleSheet:return this.replaceIds(t.data,e,["id"]),this.replaceStyleIds(t.data,e,["styleIds"]),tk([t,"access",e=>e.data,"access",e=>e.styles,"optionalAccess",e=>e.forEach,"call",t=>t(t=>{this.replaceStyleIds(t,e,["styleId"])})]),t}}return!1}replace(e,t,r,n){for(let s of n)(Array.isArray(t[s])||"number"==typeof t[s])&&(Array.isArray(t[s])?t[s]=e.getIds(r,t[s]):t[s]=e.getId(r,t[s]));return t}replaceIds(e,t,r){return this.replace(this.crossOriginIframeMirror,e,t,r)}replaceStyleIds(e,t,r){return this.replace(this.crossOriginIframeStyleMirror,e,t,r)}replaceIdOnNode(e,t){this.replaceIds(e,t,["id","rootId"]),"childNodes"in e&&e.childNodes.forEach(e=>{this.replaceIdOnNode(e,t)})}patchRootIdOnNode(e,t){e.type===b.Document||e.rootId||(e.rootId=t),"childNodes"in e&&e.childNodes.forEach(e=>{this.patchRootIdOnNode(e,t)})}}class tw{init(){}addShadowRoot(){}observeAttachShadow(){}reset(){}}class tx{constructor(e){this.shadowDoms=new WeakSet,this.restoreHandlers=[],this.mutationCb=e.mutationCb,this.scrollCb=e.scrollCb,this.bypassOptions=e.bypassOptions,this.mirror=e.mirror,this.init()}init(){this.reset(),this.patchAttachShadow(Element,a)}addShadowRoot(e,t){if(!ee(e)||this.shadowDoms.has(e))return;this.shadowDoms.add(e),this.bypassOptions.canvasManager.addShadowRoot(e);let r=tl({...this.bypassOptions,doc:t,mutationCb:this.mutationCb,mirror:this.mirror,shadowDomManager:this},e);this.restoreHandlers.push(()=>r.disconnect()),this.restoreHandlers.push(tc({...this.bypassOptions,scrollCb:this.scrollCb,doc:e,mirror:this.mirror})),e3(()=>{e.adoptedStyleSheets&&e.adoptedStyleSheets.length>0&&this.bypassOptions.stylesheetManager.adoptStyleSheets(e.adoptedStyleSheets,this.mirror.getId(e.host)),this.restoreHandlers.push(th({mirror:this.mirror,stylesheetManager:this.bypassOptions.stylesheetManager},e))},0)}observeAttachShadow(e){e.contentWindow&&e.contentDocument&&this.patchAttachShadow(e.contentWindow.Element,e.contentDocument)}patchAttachShadow(e,t){let r=this;this.restoreHandlers.push(ez(e.prototype,"attachShadow",function(e){return function(n){let s=e.call(this,n);return this.shadowRoot&&e0(this)&&r.addShadowRoot(this.shadowRoot,t),s}}))}reset(){this.restoreHandlers.forEach(e=>{try{e()}catch(e){}}),this.restoreHandlers=[],this.shadowDoms=new WeakSet,this.bypassOptions.canvasManager.resetShadowRoots()}}class tS{reset(){}freeze(){}unfreeze(){}lock(){}unlock(){}snapshot(){}addWindow(){}addShadowRoot(){}resetShadowRoots(){}}class tE{constructor(e){this.trackedLinkElements=new WeakSet,this.styleMirror=new eX,this.mutationCb=e.mutationCb,this.adoptedStyleSheetCb=e.adoptedStyleSheetCb}attachLinkElement(e,t){"_cssText"in t.attributes&&this.mutationCb({adds:[],removes:[],texts:[],attributes:[{id:t.id,attributes:t.attributes}]}),this.trackLinkElement(e)}trackLinkElement(e){this.trackedLinkElements.has(e)||(this.trackedLinkElements.add(e),this.trackStylesheetInLinkElement(e))}adoptStyleSheets(e,t){if(0===e.length)return;let r={id:t,styleIds:[]},n=[];for(let t of e){let e;this.styleMirror.has(t)?e=this.styleMirror.getId(t):(e=this.styleMirror.add(t),n.push({styleId:e,rules:Array.from(t.rules||CSSRule,(e,t)=>({rule:er(e),index:t}))})),r.styleIds.push(e)}n.length>0&&(r.styles=n),this.adoptedStyleSheetCb(r)}reset(){this.styleMirror.reset(),this.trackedLinkElements=new WeakSet}trackStylesheetInLinkElement(e){}}class tj{constructor(){this.nodeMap=new WeakMap,this.loop=!0,this.periodicallyClear()}periodicallyClear(){!function(...e){e2("requestAnimationFrame")(...e)}(()=>{this.clear(),this.loop&&this.periodicallyClear()})}inOtherBuffer(e,t){let r=this.nodeMap.get(e);return r&&Array.from(r).some(e=>e!==t)}add(e,t){this.nodeMap.set(e,(this.nodeMap.get(e)||new Set).add(t))}clear(){this.nodeMap=new WeakMap}destroy(){this.loop=!1}}try{if(2!==Array.from([1],e=>2*e)[0]){let e=a.createElement("iframe");a.body.appendChild(e),Array.from=(0,_.z)([e,"access",e=>e.contentWindow,"optionalAccess",e=>e.Array,"access",e=>e.from])||Array.from,a.body.removeChild(e)}}catch(e){console.debug("Unable to override Array.from",e)}let tT=new en;function tA(e={}){let t,{emit:r,checkoutEveryNms:n,checkoutEveryNth:s,blockClass:o="rr-block",blockSelector:i=null,unblockSelector:m=null,ignoreClass:d="rr-ignore",ignoreSelector:p=null,maskAllText:h=!1,maskTextClass:f="rr-mask",unmaskTextClass:g=null,maskTextSelector:y=null,unmaskTextSelector:b=null,inlineStylesheet:k=!0,maskAllInputs:v,maskInputOptions:w,slimDOMOptions:x,maskAttributeFn:S,maskInputFn:E,maskTextFn:j,maxCanvasSize:T=null,packFn:A,sampling:C={},dataURLOptions:I={},mousemoveWait:O,recordDOM:M=!0,recordCanvas:N=!1,recordCrossOriginIframes:D=!1,recordAfter:R="DOMContentLoaded"===e.recordAfter?e.recordAfter:"load",userTriggeredOnInput:L=!1,collectFonts:F=!1,inlineImages:P=!1,plugins:q,keepIframeSrcFn:z=()=>!1,ignoreCSSAttributes:$=new Set([]),errorHandler:U,onMutation:B,getCanvasManager:W}=e;l=U;let H=!D||window.parent===window,V=!1;if(!H)try{window.parent.document&&(V=!1)}catch(e){V=!0}if(H&&!r)throw Error("emit function is required");void 0!==O&&void 0===C.mousemove&&(C.mousemove=O),tT.reset();let Y=!0===v?{color:!0,date:!0,"datetime-local":!0,email:!0,month:!0,number:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0,textarea:!0,select:!0,radio:!0,checkbox:!0}:void 0!==w?w:{},G=!0===x||"all"===x?{script:!0,comment:!0,headFavicon:!0,headWhitespace:!0,headMetaSocial:!0,headMetaRobots:!0,headMetaHttpEquiv:!0,headMetaVerification:!0,headMetaAuthorship:"all"===x,headMetaDescKeywords:"all"===x}:x||{};!function(e=window){"NodeList"in e&&!e.NodeList.prototype.forEach&&(e.NodeList.prototype.forEach=Array.prototype.forEach),"DOMTokenList"in e&&!e.DOMTokenList.prototype.forEach&&(e.DOMTokenList.prototype.forEach=Array.prototype.forEach),Node.prototype.contains||(Node.prototype.contains=(...e)=>{let t=e[0];if(!(0 in e))throw TypeError("1 argument is required");do if(this===t)return!0;while(t=t&&t.parentNode)return!1})}();let J=0,Z=e=>{for(let t of q||[])t.eventProcessor&&(e=t.eventProcessor(e));return A&&!V&&(e=A(e)),e};c=(e,a)=>{if(e.timestamp=e$(),(0,_.z)([to,"access",e=>e[0],"optionalAccess",e=>e.isFrozen,"call",e=>e()])&&e.type!==e5.FullSnapshot&&(e.type!==e5.IncrementalSnapshot||e.data.source!==e6.Mutation)&&to.forEach(e=>e.unfreeze()),H)(0,_.z)([r,"optionalCall",t=>t(Z(e),a)]);else if(V){let t={type:"rrweb",event:Z(e),origin:window.location.origin,isCheckout:a};window.parent.postMessage(t,"*")}if(e.type===e5.FullSnapshot)t=e,J=0;else if(e.type===e5.IncrementalSnapshot){if(e.data.source===e6.Mutation&&e.data.isAttachIframe)return;J++;let r=s&&J>=s,a=n&&t&&e.timestamp-t.timestamp>n;(r||a)&&eo(!0)}};let K=e=>{c({type:e5.IncrementalSnapshot,data:{source:e6.Mutation,...e}})},X=e=>c({type:e5.IncrementalSnapshot,data:{source:e6.Scroll,...e}}),Q=e=>c({type:e5.IncrementalSnapshot,data:{source:e6.CanvasMutation,...e}}),ee=new tE({mutationCb:K,adoptedStyleSheetCb:e=>c({type:e5.IncrementalSnapshot,data:{source:e6.AdoptedStyleSheet,...e}})}),et="boolean"==typeof __RRWEB_EXCLUDE_IFRAME__&&__RRWEB_EXCLUDE_IFRAME__?new tv:new t_({mirror:tT,mutationCb:K,stylesheetManager:ee,recordCrossOriginIframes:D,wrappedEmit:c});for(let e of q||[])e.getMirror&&e.getMirror({nodeMirror:tT,crossOriginIframeMirror:et.crossOriginIframeMirror,crossOriginIframeStyleMirror:et.crossOriginIframeStyleMirror});let er=new tj,es=function(e,t){try{return e?e(t):new tS}catch(e){return console.warn("Unable to initialize CanvasManager"),new tS}}(W,{mirror:tT,win:window,mutationCb:e=>c({type:e5.IncrementalSnapshot,data:{source:e6.CanvasMutation,...e}}),recordCanvas:N,blockClass:o,blockSelector:i,unblockSelector:m,maxCanvasSize:T,sampling:C.canvas,dataURLOptions:I,errorHandler:U}),ea="boolean"==typeof __RRWEB_EXCLUDE_SHADOW_DOM__&&__RRWEB_EXCLUDE_SHADOW_DOM__?new tw:new tx({mutationCb:K,scrollCb:X,bypassOptions:{onMutation:B,blockClass:o,blockSelector:i,unblockSelector:m,maskAllText:h,maskTextClass:f,unmaskTextClass:g,maskTextSelector:y,unmaskTextSelector:b,inlineStylesheet:k,maskInputOptions:Y,dataURLOptions:I,maskAttributeFn:S,maskTextFn:j,maskInputFn:E,recordCanvas:N,inlineImages:P,sampling:C,slimDOMOptions:G,iframeManager:et,stylesheetManager:ee,canvasManager:es,keepIframeSrcFn:z,processedNodeManager:er},mirror:tT}),eo=(e=!1)=>{if(!M)return;c({type:e5.Meta,data:{href:window.location.href,width:eW(),height:eB()}},e),ee.reset(),ea.init(),to.forEach(e=>e.lock());let t=function(e,t){let{mirror:r=new en,blockClass:n="rr-block",blockSelector:s=null,unblockSelector:a=null,maskAllText:o=!1,maskTextClass:i="rr-mask",unmaskTextClass:l=null,maskTextSelector:c=null,unmaskTextSelector:u=null,inlineStylesheet:m=!0,inlineImages:d=!1,recordCanvas:p=!1,maskAllInputs:h=!1,maskAttributeFn:f,maskTextFn:g,maskInputFn:y,slimDOM:b=!1,dataURLOptions:k,preserveWhiteSpace:v,onSerialize:_,onIframeLoad:w,iframeLoadTimeout:x,onStylesheetLoad:S,stylesheetLoadTimeout:E,keepIframeSrcFn:j=()=>!1}=t||{};return eD(e,{doc:e,mirror:r,blockClass:n,blockSelector:s,unblockSelector:a,maskAllText:o,maskTextClass:i,unmaskTextClass:l,maskTextSelector:c,unmaskTextSelector:u,skipChild:!1,inlineStylesheet:m,maskInputOptions:!0===h?{color:!0,date:!0,"datetime-local":!0,email:!0,month:!0,number:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0,textarea:!0,select:!0}:!1===h?{}:h,maskAttributeFn:f,maskTextFn:g,maskInputFn:y,slimDOMOptions:!0===b||"all"===b?{script:!0,comment:!0,headFavicon:!0,headWhitespace:!0,headMetaDescKeywords:"all"===b,headMetaSocial:!0,headMetaRobots:!0,headMetaHttpEquiv:!0,headMetaAuthorship:!0,headMetaVerification:!0}:!1===b?{}:b,dataURLOptions:k,inlineImages:d,recordCanvas:p,preserveWhiteSpace:v,onSerialize:_,onIframeLoad:w,iframeLoadTimeout:x,onStylesheetLoad:S,stylesheetLoadTimeout:E,keepIframeSrcFn:j,newlyAddedElement:!1})}(a,{mirror:tT,blockClass:o,blockSelector:i,unblockSelector:m,maskAllText:h,maskTextClass:f,unmaskTextClass:g,maskTextSelector:y,unmaskTextSelector:b,inlineStylesheet:k,maskAllInputs:Y,maskAttributeFn:S,maskInputFn:E,maskTextFn:j,slimDOM:G,dataURLOptions:I,recordCanvas:N,inlineImages:P,onSerialize:e=>{eJ(e,tT)&&et.addIframe(e),eZ(e,tT)&&ee.trackLinkElement(e),eK(e)&&ea.addShadowRoot(e.shadowRoot,a)},onIframeLoad:(e,t)=>{et.attachIframe(e,t),e.contentWindow&&es.addWindow(e.contentWindow),ea.observeAttachShadow(e)},onStylesheetLoad:(e,t)=>{ee.attachLinkElement(e,t)},keepIframeSrcFn:z});if(!t)return console.warn("Failed to snapshot the document");c({type:e5.FullSnapshot,data:{node:t,initialOffset:eU(window)}}),to.forEach(e=>e.unlock()),a.adoptedStyleSheets&&a.adoptedStyleSheets.length>0&&ee.adoptStyleSheets(a.adoptedStyleSheets,tT.getId(a))};u=eo;try{let e=[],t=e=>ts(tf)({onMutation:B,mutationCb:K,mousemoveCb:(e,t)=>c({type:e5.IncrementalSnapshot,data:{source:t,positions:e}}),mouseInteractionCb:e=>c({type:e5.IncrementalSnapshot,data:{source:e6.MouseInteraction,...e}}),scrollCb:X,viewportResizeCb:e=>c({type:e5.IncrementalSnapshot,data:{source:e6.ViewportResize,...e}}),inputCb:e=>c({type:e5.IncrementalSnapshot,data:{source:e6.Input,...e}}),mediaInteractionCb:e=>c({type:e5.IncrementalSnapshot,data:{source:e6.MediaInteraction,...e}}),styleSheetRuleCb:e=>c({type:e5.IncrementalSnapshot,data:{source:e6.StyleSheetRule,...e}}),styleDeclarationCb:e=>c({type:e5.IncrementalSnapshot,data:{source:e6.StyleDeclaration,...e}}),canvasMutationCb:Q,fontCb:e=>c({type:e5.IncrementalSnapshot,data:{source:e6.Font,...e}}),selectionCb:e=>{c({type:e5.IncrementalSnapshot,data:{source:e6.Selection,...e}})},customElementCb:e=>{c({type:e5.IncrementalSnapshot,data:{source:e6.CustomElement,...e}})},blockClass:o,ignoreClass:d,ignoreSelector:p,maskAllText:h,maskTextClass:f,unmaskTextClass:g,maskTextSelector:y,unmaskTextSelector:b,maskInputOptions:Y,inlineStylesheet:k,sampling:C,recordDOM:M,recordCanvas:N,inlineImages:P,userTriggeredOnInput:L,collectFonts:F,doc:e,maskAttributeFn:S,maskInputFn:E,maskTextFn:j,keepIframeSrcFn:z,blockSelector:i,unblockSelector:m,slimDOMOptions:G,dataURLOptions:I,mirror:tT,iframeManager:et,stylesheetManager:ee,shadowDomManager:ea,processedNodeManager:er,canvasManager:es,ignoreCSSAttributes:$,plugins:(0,_.z)([q,"optionalAccess",e=>e.filter,"call",e=>e(e=>e.observer),"optionalAccess",e=>e.map,"call",e=>e(e=>({observer:e.observer,options:e.options,callback:t=>c({type:e5.Plugin,data:{plugin:e.name,payload:t}})}))])||[]},{});et.addLoadListener(r=>{try{e.push(t(r.contentDocument))}catch(e){console.warn(e)}});let r=()=>{eo(),e.push(t(a))};return"interactive"===a.readyState||"complete"===a.readyState?r():(e.push(eL("DOMContentLoaded",()=>{c({type:e5.DomContentLoaded,data:{}}),"DOMContentLoaded"===R&&r()})),e.push(eL("load",()=>{c({type:e5.Load,data:{}}),"load"===R&&r()},window))),()=>{e.forEach(e=>e()),er.destroy(),u=void 0,l=void 0}}catch(e){console.warn(e)}}tA.mirror=tT,tA.takeFullSnapshot=function(e){if(!u)throw Error("please take full snapshot after start recording");u(e)};let tC="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__,tI=["info","warn","error","log"],tO="[Replay] ";function tM(e,t="info"){(0,C.Z)({category:"console",data:{logger:"replay"},level:t,message:`${tO}${e}`},{level:t})}let tN=function(){let e=!1,t=!1,r={exception:()=>void 0,infoTick:()=>void 0,setConfig:r=>{e=r.captureExceptions,t=r.traceInternals}};return tC?(tI.forEach(e=>{r[e]=(...r)=>{N.vF[e](tO,...r),t&&tM(r.join(""),(0,F.t)(e))}}),r.exception=(n,...s)=>{s.length&&r.error&&r.error(...s),N.vF.error(tO,n),e?(0,x.Cp)(n):t&&tM(n,"error")},r.infoTick=(...e)=>{N.vF.info(tO,...e),t&&n(()=>tM(e[0]),0)}):tI.forEach(e=>{r[e]=()=>void 0}),r}();function tD(e){return e>0x2540be3ff?e:1e3*e}function tR(e){return e>0x2540be3ff?e/1e3:e}function tL(e,t){"sentry.transaction"!==t.category&&(["ui.click","ui.input"].includes(t.category)?e.triggerUserActivity():e.checkAndHandleExpiredSession(),e.addUpdate(()=>(e.throttledAddEvent({type:e5.Custom,timestamp:1e3*(t.timestamp||0),data:{tag:"breadcrumb",payload:(0,R.S8)(t,10,1e3)}}),"console"===t.category)))}function tF(e){return e.closest("button,a")||e}function tP(e){let t=tq(e);return t&&t instanceof Element?tF(t):t}function tq(e){var t;return"object"==typeof(t=e)&&t&&"target"in t?e.target:e}let tz=new Set([e6.Mutation,e6.StyleSheetRule,e6.StyleDeclaration,e6.AdoptedStyleSheet,e6.CanvasMutation,e6.Selection,e6.MediaInteraction]);class t${constructor(e,t,r=tL){this._lastMutation=0,this._lastScroll=0,this._clicks=[],this._timeout=t.timeout/1e3,this._threshold=t.threshold/1e3,this._scollTimeout=t.scrollTimeout/1e3,this._replay=e,this._ignoreSelector=t.ignoreSelector,this._addBreadcrumbEvent=r}addListeners(){var e;let t=(e=()=>{this._lastMutation=tB()},m||(m=[],(0,L.GS)(G,"open",function(e){return function(...t){if(m)try{m.forEach(e=>e())}catch(e){}return e.apply(G,t)}})),m.push(e),()=>{let t=m?m.indexOf(e):-1;t>-1&&m.splice(t,1)});this._teardown=()=>{t(),this._clicks=[],this._lastMutation=0,this._lastScroll=0}}removeListeners(){this._teardown&&this._teardown(),this._checkClickTimeout&&s(this._checkClickTimeout)}handleClick(e,t){var r,n,s;if(r=t,n=this._ignoreSelector,!tU.includes(r.tagName)||"INPUT"===r.tagName&&!["submit","button"].includes(r.getAttribute("type")||"")||"A"===r.tagName&&(r.hasAttribute("download")||r.hasAttribute("target")&&"_self"!==r.getAttribute("target"))||n&&r.matches(n)||!((s=e).data&&"number"==typeof s.data.nodeId&&s.timestamp))return;let a={timestamp:tR(e.timestamp),clickBreadcrumb:e,clickCount:0,node:t};this._clicks.some(e=>e.node===a.node&&1>Math.abs(e.timestamp-a.timestamp))||(this._clicks.push(a),1===this._clicks.length&&this._scheduleCheckClicks())}registerMutation(e=Date.now()){this._lastMutation=tR(e)}registerScroll(e=Date.now()){this._lastScroll=tR(e)}registerClick(e){let t=tF(e);this._handleMultiClick(t)}_handleMultiClick(e){this._getClicks(e).forEach(e=>{e.clickCount++})}_getClicks(e){return this._clicks.filter(t=>t.node===e)}_checkClicks(){let e=[],t=tB();for(let r of(this._clicks.forEach(r=>{!r.mutationAfter&&this._lastMutation&&(r.mutationAfter=r.timestamp<=this._lastMutation?this._lastMutation-r.timestamp:void 0),!r.scrollAfter&&this._lastScroll&&(r.scrollAfter=r.timestamp<=this._lastScroll?this._lastScroll-r.timestamp:void 0),r.timestamp+this._timeout<=t&&e.push(r)}),e)){let e=this._clicks.indexOf(r);e>-1&&(this._generateBreadcrumbs(r),this._clicks.splice(e,1))}this._clicks.length&&this._scheduleCheckClicks()}_generateBreadcrumbs(e){let t=this._replay,r=e.scrollAfter&&e.scrollAfter<=this._scollTimeout,n=e.mutationAfter&&e.mutationAfter<=this._threshold,{clickCount:s,clickBreadcrumb:a}=e;if(!r&&!n){let r=1e3*Math.min(e.mutationAfter||this._timeout,this._timeout),n=r<1e3*this._timeout?"mutation":"timeout",o={type:"default",message:a.message,timestamp:a.timestamp,category:"ui.slowClickDetected",data:{...a.data,url:G.location.href,route:t.getCurrentRoute(),timeAfterClickMs:r,endReason:n,clickCount:s||1}};this._addBreadcrumbEvent(t,o);return}if(s>1){let e={type:"default",message:a.message,timestamp:a.timestamp,category:"ui.multiClick",data:{...a.data,url:G.location.href,route:t.getCurrentRoute(),clickCount:s,metric:!0}};this._addBreadcrumbEvent(t,e)}}_scheduleCheckClicks(){this._checkClickTimeout&&s(this._checkClickTimeout),this._checkClickTimeout=(0,V.wg)(()=>this._checkClicks(),1e3)}}let tU=["A","BUTTON","INPUT"];function tB(){return Date.now()/1e3}function tW(e){return{timestamp:Date.now()/1e3,type:"default",...e}}(y=k||(k={}))[y.Document=0]="Document",y[y.DocumentType=1]="DocumentType",y[y.Element=2]="Element",y[y.Text=3]="Text",y[y.CDATA=4]="CDATA",y[y.Comment=5]="Comment";let tH=new Set(["id","class","aria-label","role","name","alt","title","data-test-id","data-testid","disabled","aria-disabled","data-sentry-component"]);function tV(e,t){let r=tA.mirror.getId(e),n=r&&tA.mirror.getNode(r),s=n&&tA.mirror.getMeta(n),a=s&&s.type===k.Element?s:null;return{message:t,data:a?{nodeId:r,node:{id:r,tagName:a.tagName,textContent:Array.from(a.childNodes).map(e=>e.type===k.Text&&e.textContent).filter(Boolean).map(e=>e.trim()).join(""),attributes:function(e){let t={};for(let r in!e["data-sentry-component"]&&e["data-sentry-element"]&&(e["data-sentry-component"]=e["data-sentry-element"]),e)if(tH.has(r)){let n=r;("data-testid"===r||"data-test-id"===r)&&(n="testId"),t[n]=e[r]}return t}(a.attributes)}}:{}}}let tY={resource:function(e){let{entryType:t,initiatorType:r,name:n,responseEnd:s,startTime:a,decodedBodySize:o,encodedBodySize:i,responseStatus:l,transferSize:c}=e;return["fetch","xmlhttprequest"].includes(r)?null:{type:`${t}.${r}`,start:tZ(a),end:tZ(s),name:n,data:{size:c,statusCode:l,decodedBodySize:o,encodedBodySize:i}}},paint:function(e){let{duration:t,entryType:r,name:n,startTime:s}=e,a=tZ(s);return{type:r,name:n,start:a,end:a+t,data:void 0}},navigation:function(e){let{entryType:t,name:r,decodedBodySize:n,duration:s,domComplete:a,encodedBodySize:o,domContentLoadedEventStart:i,domContentLoadedEventEnd:l,domInteractive:c,loadEventStart:u,loadEventEnd:m,redirectCount:d,startTime:p,transferSize:h,type:f}=e;return 0===s?null:{type:`${t}.${f}`,start:tZ(p),end:tZ(a),name:r,data:{size:h,decodedBodySize:n,encodedBodySize:o,duration:s,domInteractive:c,domContentLoadedEventStart:i,domContentLoadedEventEnd:l,loadEventStart:u,loadEventEnd:m,domComplete:a,redirectCount:d}}}};function tG(e,t){return({metric:r})=>void t.replayPerformanceEntries.push(e(r))}function tJ(e){let t=tY[e.entryType];return t?t(e):null}function tZ(e){return((z.k3||G.performance.timeOrigin)+e)/1e3}function tK(e){let t=e.entries[e.entries.length-1];return t1(e,"largest-contentful-paint",t&&t.element?[t.element]:void 0)}function tX(e){let t=[],r=[];for(let n of e.entries)if(void 0!==n.sources){let e=[];for(let t of n.sources)if(t.node){r.push(t.node);let n=tA.mirror.getId(t.node);n&&e.push(n)}t.push({value:n.value,nodeIds:e.length?e:void 0})}return t1(e,"cumulative-layout-shift",r,t)}function tQ(e){let t=e.entries[e.entries.length-1];return t1(e,"first-input-delay",t&&t.target?[t.target]:void 0)}function t0(e){let t=e.entries[e.entries.length-1];return t1(e,"interaction-to-next-paint",t&&t.target?[t.target]:void 0)}function t1(e,t,r,n){let s=e.value,a=e.rating,o=tZ(s);return{type:"web-vital",name:t,start:o,end:o,data:{value:s,size:s,rating:a,nodeIds:r?r.map(e=>tA.mirror.getId(e)):void 0,attributions:n}}}class t2 extends Error{constructor(){super("Event buffer exceeded maximum size of 20000000.")}}class t3{constructor(){this.events=[],this._totalSize=0,this.hasCheckout=!1}get hasEvents(){return this.events.length>0}get type(){return"sync"}destroy(){this.events=[]}async addEvent(e){let t=JSON.stringify(e).length;if(this._totalSize+=t,this._totalSize>2e7)throw new t2;this.events.push(e)}finish(){return new Promise(e=>{let t=this.events;this.clear(),e(JSON.stringify(t))})}clear(){this.events=[],this._totalSize=0,this.hasCheckout=!1}getEarliestTimestamp(){let e=this.events.map(e=>e.timestamp).sort()[0];return e?tD(e):null}}class t5{constructor(e){this._worker=e,this._id=0}ensureReady(){return this._ensureReadyPromise||(this._ensureReadyPromise=new Promise((e,t)=>{this._worker.addEventListener("message",({data:r})=>{r.success?e():t()},{once:!0}),this._worker.addEventListener("error",e=>{t(e)},{once:!0})})),this._ensureReadyPromise}destroy(){tC&&tN.info("Destroying compression worker"),this._worker.terminate()}postMessage(e,t){let r=this._getAndIncrementId();return new Promise((n,s)=>{let a=({data:t})=>{if(t.method===e&&t.id===r){if(this._worker.removeEventListener("message",a),!t.success){tC&&tN.error("Error in compression worker: ",t.response),s(Error("Error in compression worker"));return}n(t.response)}};this._worker.addEventListener("message",a),this._worker.postMessage({id:r,method:e,arg:t})})}_getAndIncrementId(){return this._id++}}class t6{constructor(e){this._worker=new t5(e),this._earliestTimestamp=null,this._totalSize=0,this.hasCheckout=!1}get hasEvents(){return!!this._earliestTimestamp}get type(){return"worker"}ensureReady(){return this._worker.ensureReady()}destroy(){this._worker.destroy()}addEvent(e){let t=tD(e.timestamp);(!this._earliestTimestamp||t<this._earliestTimestamp)&&(this._earliestTimestamp=t);let r=JSON.stringify(e);return(this._totalSize+=r.length,this._totalSize>2e7)?Promise.reject(new t2):this._sendEventToWorker(r)}finish(){return this._finishRequest()}clear(){this._earliestTimestamp=null,this._totalSize=0,this.hasCheckout=!1,this._worker.postMessage("clear").then(null,e=>{tC&&tN.exception(e,'Sending "clear" message to worker failed',e)})}getEarliestTimestamp(){return this._earliestTimestamp}_sendEventToWorker(e){return this._worker.postMessage("addEvent",e)}async _finishRequest(){let e=await this._worker.postMessage("finish");return this._earliestTimestamp=null,this._totalSize=0,e}}class t8{constructor(e){this._fallback=new t3,this._compression=new t6(e),this._used=this._fallback,this._ensureWorkerIsLoadedPromise=this._ensureWorkerIsLoaded()}get type(){return this._used.type}get hasEvents(){return this._used.hasEvents}get hasCheckout(){return this._used.hasCheckout}set hasCheckout(e){this._used.hasCheckout=e}destroy(){this._fallback.destroy(),this._compression.destroy()}clear(){return this._used.clear()}getEarliestTimestamp(){return this._used.getEarliestTimestamp()}addEvent(e){return this._used.addEvent(e)}async finish(){return await this.ensureWorkerIsLoaded(),this._used.finish()}ensureWorkerIsLoaded(){return this._ensureWorkerIsLoadedPromise}async _ensureWorkerIsLoaded(){try{await this._compression.ensureReady()}catch(e){tC&&tN.exception(e,"Failed to load the compression worker, falling back to simple buffer");return}await this._switchToCompressionWorker()}async _switchToCompressionWorker(){let{events:e,hasCheckout:t}=this._fallback,r=[];for(let t of e)r.push(this._compression.addEvent(t));this._compression.hasCheckout=t,this._used=this._compression;try{await Promise.all(r)}catch(e){tC&&tN.exception(e,"Failed to add events when switching buffers.")}}}function t4(){try{return"sessionStorage"in G&&!!G.sessionStorage}catch(e){return!1}}function t9(e){return void 0!==e&&Math.random()<e}function t7(e){let t=Date.now(),r=e.id||(0,D.eJ)(),n=e.started||t,s=e.lastActivity||t,a=e.segmentId||0;return{id:r,started:n,lastActivity:s,segmentId:a,sampled:e.sampled,previousSessionId:e.previousSessionId}}function re(e){if(t4())try{G.sessionStorage.setItem(J,JSON.stringify(e))}catch(e){}}function rt({sessionSampleRate:e,allowBuffering:t,stickySession:r=!1},{previousSessionId:n}={}){let s=t7({sampled:t9(e)?"session":!!t&&"buffer",previousSessionId:n});return r&&re(s),s}function rr(e,t,r=+new Date){return null===e||void 0===t||t<0||0!==t&&e+t<=r}function rn(e,{maxReplayDuration:t,sessionIdleExpire:r,targetTime:n=Date.now()}){return rr(e.started,t,n)||rr(e.lastActivity,r,n)}function rs(e,{sessionIdleExpire:t,maxReplayDuration:r}){return!!rn(e,{sessionIdleExpire:t,maxReplayDuration:r})&&("buffer"!==e.sampled||0!==e.segmentId)}function ra({sessionIdleExpire:e,maxReplayDuration:t,previousSessionId:r},n){let s=n.stickySession&&function(){if(!t4())return null;try{let e=G.sessionStorage.getItem(J);if(!e)return null;let t=JSON.parse(e);return tC&&tN.infoTick("Loading existing session"),t7(t)}catch(e){return null}}();return s?rs(s,{sessionIdleExpire:e,maxReplayDuration:t})?(tC&&tN.infoTick("Session in sessionStorage is expired, creating new one..."),rt(n,{previousSessionId:s.id})):s:(tC&&tN.infoTick("Creating new session"),rt(n,{previousSessionId:r}))}function ro(e,t,r){return!!rl(e,t)&&(ri(e,t,r),!0)}async function ri(e,t,r){if(!e.eventBuffer)return null;try{r&&"buffer"===e.recordingMode&&e.eventBuffer.clear(),r&&(e.eventBuffer.hasCheckout=!0);let n=e.getOptions(),s=function(e,t){try{if("function"==typeof t&&e.type===e5.Custom)return t(e)}catch(e){return tC&&tN.exception(e,"An error occured in the `beforeAddRecordingEvent` callback, skipping the event..."),null}return e}(t,n.beforeAddRecordingEvent);if(!s)return;return await e.eventBuffer.addEvent(s)}catch(n){let t=n&&n instanceof t2?"addEventSizeExceeded":"addEvent";e.handleException(n),await e.stop({reason:t});let r=(0,S.KU)();r&&r.recordDroppedEvent("internal_sdk_error","replay")}}function rl(e,t){if(!e.eventBuffer||e.isPaused()||!e.isEnabled())return!1;let r=tD(t.timestamp);return!(r+e.timeouts.sessionIdlePause<Date.now())&&(!(r>e.getContext().initialTimestamp+e.getOptions().maxReplayDuration)||(tC&&tN.infoTick(`Skipping event with timestamp ${r} because it is after maxReplayDuration`),!1))}function rc(e){return"transaction"===e.type}function ru(e){return"feedback"===e.type}function rm(e){return!!e.category}function rd(e,t){return t.map(({type:t,start:r,end:n,name:s,data:a})=>{let o=e.throttledAddEvent({type:e5.Custom,timestamp:r,data:{tag:"performanceSpan",payload:{op:t,description:s,startTimestamp:r,endTimestamp:n,data:a}}});return"string"==typeof o?Promise.resolve(null):o})}function rp(e,t){var r;e.isEnabled()&&null!==t&&(r=t.name,(!tC||!e.getOptions()._experiments.traceInternals)&&(0,j.A)(r,(0,S.KU)())||e.addUpdate(()=>(rd(e,[t]),!0)))}function rh(e){if(!e)return;let t=new TextEncoder;try{if("string"==typeof e)return t.encode(e).length;if(e instanceof URLSearchParams)return t.encode(e.toString()).length;if(e instanceof FormData){let r=rw(e);return t.encode(r).length}if(e instanceof Blob)return e.size;if(e instanceof ArrayBuffer)return e.byteLength}catch(e){}}function rf(e){if(!e)return;let t=parseInt(e,10);return isNaN(t)?void 0:t}function rg(e){try{if("string"==typeof e)return[e];if(e instanceof URLSearchParams)return[e.toString()];if(e instanceof FormData)return[rw(e)];if(!e)return[void 0]}catch(t){return tC&&tN.exception(t,"Failed to serialize body",e),[void 0,"BODY_PARSE_ERROR"]}return tC&&tN.info("Skipping network body because of body type",e),[void 0,"UNPARSEABLE_BODY_TYPE"]}function ry(e,t){if(!e)return{headers:{},size:void 0,_meta:{warnings:[t]}};let r={...e._meta},n=r.warnings||[];return r.warnings=[...n,t],e._meta=r,e}function rb(e,t){if(!t)return null;let{startTimestamp:r,endTimestamp:n,url:s,method:a,statusCode:o,request:i,response:l}=t;return{type:e,start:r/1e3,end:n/1e3,name:s,data:(0,L.Ce)({method:a,statusCode:o,request:i,response:l})}}function rk(e){return{headers:{},size:e,_meta:{warnings:["URL_SKIPPED"]}}}function rv(e,t,r){if(!t&&0===Object.keys(e).length)return;if(!t)return{headers:e};if(!r)return{headers:e,size:t};let n={headers:e,size:t},{body:s,warnings:a}=function(e){if(!e||"string"!=typeof e)return{body:e};let t=e.length>15e4,r=function(e){let t=e[0],r=e[e.length-1];return"["===t&&"]"===r||"{"===t&&"}"===r}(e);if(t){let t=e.slice(0,15e4);return r?{body:t,warnings:["MAYBE_JSON_TRUNCATED"]}:{body:`${t}…`,warnings:["TEXT_TRUNCATED"]}}if(r)try{return{body:JSON.parse(e)}}catch(e){}return{body:e}}(r);return n.body=s,a&&a.length>0&&(n._meta={warnings:a}),n}function r_(e,t){return Object.entries(e).reduce((r,[n,s])=>{let a=n.toLowerCase();return t.includes(a)&&e[n]&&(r[a]=s),r},{})}function rw(e){return new URLSearchParams(e).toString()}function rx(e,t){let r=function(e,t=G.document.baseURI){if(e.startsWith("http://")||e.startsWith("https://")||e.startsWith(G.location.origin))return e;let r=new URL(e,t);if(r.origin!==new URL(t).origin)return e;let n=r.href;return!e.endsWith("/")&&n.endsWith("/")?n.slice(0,-1):n}(e);return(0,P.Xr)(r,t)}async function rS(e,t,r){try{let n=await rE(e,t,r),s=rb("resource.fetch",n);rp(r.replay,s)}catch(e){tC&&tN.exception(e,"Failed to capture fetch breadcrumb")}}async function rE(e,t,r){let n=Date.now(),{startTimestamp:s=n,endTimestamp:a=n}=t,{url:o,method:i,status_code:l=0,request_body_size:c,response_body_size:u}=e.data,m=rx(o,r.networkDetailAllowUrls)&&!rx(o,r.networkDetailDenyUrls);return{startTimestamp:s,endTimestamp:a,url:o,method:i,statusCode:l,request:m?function({networkCaptureBodies:e,networkRequestHeaders:t},r,n){var s,a;let o=r?(s=r,a=t,1===s.length&&"string"!=typeof s[0]?rI(s[0],a):2===s.length?rI(s[1],a):{}):{};if(!e)return rv(o,n,void 0);let[i,l]=rg(rA(r)),c=rv(o,n,i);return l?ry(c,l):c}(r,t.input,c):rk(c),response:await rj(m,r,t.response,u)}}async function rj(e,{networkCaptureBodies:t,networkResponseHeaders:r},n,s){if(!e&&void 0!==s)return rk(s);let a=n?rC(n.headers,r):{};if(!n||!t&&void 0!==s)return rv(a,s,void 0);let[o,i]=await rT(n),l=function(e,{networkCaptureBodies:t,responseBodySize:r,captureDetails:n,headers:s}){try{let a=e&&e.length&&void 0===r?rh(e):r;if(!n)return rk(a);if(t)return rv(s,a,e);return rv(s,a,void 0)}catch(e){return tC&&tN.exception(e,"Failed to serialize response body"),rv(s,r,void 0)}}(o,{networkCaptureBodies:t,responseBodySize:s,captureDetails:e,headers:a});return i?ry(l,i):l}async function rT(e){let t=function(e){try{return e.clone()}catch(e){tC&&tN.exception(e,"Failed to clone response body")}}(e);if(!t)return[void 0,"BODY_PARSE_ERROR"];try{var r;return[await (r=t,new Promise((e,t)=>{let n=(0,V.wg)(()=>t(Error("Timeout while trying to read response body")),500);rO(r).then(t=>e(t),e=>t(e)).finally(()=>s(n))}))]}catch(e){return tC&&tN.exception(e,"Failed to get text body from response"),[void 0,"BODY_PARSE_ERROR"]}}function rA(e=[]){if(2===e.length&&"object"==typeof e[1])return e[1].body}function rC(e,t){let r={};return t.forEach(t=>{e.get(t)&&(r[t]=e.get(t))}),r}function rI(e,t){if(!e)return{};let r=e.headers;return r?r instanceof Headers?rC(r,t):Array.isArray(r)?{}:r_(r,t):{}}async function rO(e){return await e.text()}async function rM(e,t,r){try{let n=function(e,t,r){let n=Date.now(),{startTimestamp:s=n,endTimestamp:a=n,input:o,xhr:i}=t,{url:l,method:c,status_code:u=0,request_body_size:m,response_body_size:d}=e.data;if(!l)return null;if(!i||!rx(l,r.networkDetailAllowUrls)||rx(l,r.networkDetailDenyUrls)){let e=rk(m);return{startTimestamp:s,endTimestamp:a,url:l,method:c,statusCode:u,request:e,response:rk(d)}}let p=i[Y.Er],h=p?r_(p.request_headers,r.networkRequestHeaders):{},f=r_(function(e){let t=e.getAllResponseHeaders();return t?t.split(`\r
`).reduce((e,t)=>{let[r,n]=t.split(": ");return n&&(e[r.toLowerCase()]=n),e},{}):{}}(i),r.networkResponseHeaders),[g,y]=r.networkCaptureBodies?rg(o):[void 0],[b,k]=r.networkCaptureBodies?function(e){let t=[];try{return[e.responseText]}catch(e){t.push(e)}try{var r=e.response,n=e.responseType;try{if("string"==typeof r)return[r];if(r instanceof Document)return[r.body.outerHTML];if("json"===n&&r&&"object"==typeof r)return[JSON.stringify(r)];if(!r)return[void 0]}catch(e){return tC&&tN.exception(e,"Failed to serialize body",r),[void 0,"BODY_PARSE_ERROR"]}return tC&&tN.info("Skipping network body because of body type",r),[void 0,"UNPARSEABLE_BODY_TYPE"]}catch(e){t.push(e)}return tC&&tN.warn("Failed to get xhr response body",...t),[void 0]}(i):[void 0],v=rv(h,m,g),_=rv(f,d,b);return{startTimestamp:s,endTimestamp:a,url:l,method:c,statusCode:u,request:y?ry(v,y):v,response:k?ry(_,k):_}}(e,t,r),s=rb("resource.xhr",n);rp(r.replay,s)}catch(e){tC&&tN.exception(e,"Failed to capture xhr breadcrumb")}}async function rN(e){try{return Promise.all(rd(e,[function(e){let{jsHeapSizeLimit:t,totalJSHeapSize:r,usedJSHeapSize:n}=e,s=Date.now()/1e3;return{type:"memory",name:"memory",start:s,end:s,data:{memory:{jsHeapSizeLimit:t,totalJSHeapSize:r,usedJSHeapSize:n}}}}(G.performance.memory)]))}catch(e){return[]}}async function rD({client:e,scope:t,replayId:r,event:n}){let s={event_id:r,integrations:"object"!=typeof e._integrations||null===e._integrations||Array.isArray(e._integrations)?void 0:Object.keys(e._integrations)};e.emit("preprocessEvent",n,s);let a=await (0,E.mG)(e.getOptions(),n,s,t,e,(0,S.rm)());if(!a)return null;a.platform=a.platform||"javascript";let o=e.getSdkMetadata(),{name:i,version:l}=o&&o.sdk||{};return a.sdk={...a.sdk,name:i||"sentry.javascript.unknown",version:l||"0.0.0"},a}async function rR({recordingData:e,replayId:t,segmentId:r,eventContext:n,timestamp:s,session:a}){var o;let i,l=function({recordingData:e,headers:t}){let r,n=`${JSON.stringify(t)}
`;if("string"==typeof e)r=`${n}${e}`;else{let t=new TextEncoder().encode(n);(r=new Uint8Array(t.length+e.length)).set(t),r.set(e,t.length)}return r}({recordingData:e,headers:{segment_id:r}}),{urls:c,errorIds:u,traceIds:m,initialTimestamp:d}=n,p=(0,S.KU)(),h=(0,S.o5)(),f=p&&p.getTransport(),g=p&&p.getDsn();if(!p||!f||!g||!a.sampled)return(0,q.XW)({});let y={type:"replay_event",replay_start_timestamp:d/1e3,timestamp:s/1e3,error_ids:u,trace_ids:m,urls:c,replay_id:t,segment_id:r,replay_type:a.sampled},b=await rD({scope:h,client:p,replayId:t,event:y});if(!b)return p.recordDroppedEvent("event_processor","replay",y),tC&&tN.info("An event processor returned `null`, will not send event."),(0,q.XW)({});delete b.sdkProcessingMetadata;let k=(o=p.getOptions().tunnel,(0,$.h4)((0,$.n2)(b,(0,$.Cj)(b),o,g),[[{type:"replay_event"},b],[{type:"replay_recording",length:"string"==typeof l?new TextEncoder().encode(l).length:l.length},l]]));try{i=await f.send(k)}catch(t){let e=Error(Z);try{e.cause=t}catch(e){}throw e}if("number"==typeof i.statusCode&&(i.statusCode<200||i.statusCode>=300))throw new rL(i.statusCode);let v=(0,U.wq)({},i);if((0,U.Jz)(v,"replay"))throw new rF(v);return i}class rL extends Error{constructor(e){super(`Transport returned status code ${e}`)}}class rF extends Error{constructor(e){super("Rate limit hit"),this.rateLimits=e}}async function rP(e,t={count:0,interval:5e3}){let{recordingData:r,onError:n}=e;if(r.length)try{return await rR(e),!0}catch(r){if(r instanceof rL||r instanceof rF)throw r;if((0,x.o)("Replays",{_retryCount:t.count}),n&&n(r),t.count>=3){let e=Error(`${Z} - max retries exceeded`);try{e.cause=r}catch(e){}throw e}return t.interval*=++t.count,new Promise((r,n)=>{(0,V.wg)(async()=>{try{await rP(e,t),r(!0)}catch(e){n(e)}},t.interval)})}}let rq="__THROTTLED";class rz{constructor({options:e,recordingOptions:t}){rz.prototype.__init.call(this),rz.prototype.__init2.call(this),rz.prototype.__init3.call(this),rz.prototype.__init4.call(this),rz.prototype.__init5.call(this),rz.prototype.__init6.call(this),this.eventBuffer=null,this.performanceEntries=[],this.replayPerformanceEntries=[],this.recordingMode="session",this.timeouts={sessionIdlePause:3e5,sessionIdleExpire:9e5},this._lastActivity=Date.now(),this._isEnabled=!1,this._isPaused=!1,this._requiresManualStart=!1,this._hasInitializedCoreListeners=!1,this._context={errorIds:new Set,traceIds:new Set,urls:[],initialTimestamp:Date.now(),initialUrl:""},this._recordingOptions=t,this._options=e,this._debouncedFlush=function(e,t,r){let n,a,o,i=r&&r.maxWait?Math.max(r.maxWait,t):0;function l(){return c(),n=e()}function c(){void 0!==a&&s(a),void 0!==o&&s(o),a=o=void 0}function u(){return a&&s(a),a=(0,V.wg)(l,t),i&&void 0===o&&(o=(0,V.wg)(l,i)),n}return u.cancel=c,u.flush=function(){return void 0!==a||void 0!==o?l():n},u}(()=>this._flush(),this._options.flushMinDelay,{maxWait:this._options.flushMaxDelay}),this._throttledAddEvent=function(e,t,r){let n=new Map,s=!1;return(...t)=>{let r=Math.floor(Date.now()/1e3),a=r-5;if(n.forEach((e,t)=>{t<a&&n.delete(t)}),[...n.values()].reduce((e,t)=>e+t,0)>=300){let e=s;return s=!0,e?"__SKIPPED":rq}s=!1;let o=n.get(r)||0;return n.set(r,o+1),e(...t)}}((e,t)=>(function(e,t,r){return rl(e,t)?ri(e,t,r):Promise.resolve(null)})(this,e,t),0,0);let{slowClickTimeout:r,slowClickIgnoreSelectors:n}=this.getOptions(),a=r?{threshold:Math.min(3e3,r),timeout:r,scrollTimeout:300,ignoreSelector:n?n.join(","):""}:void 0;if(a&&(this.clickDetector=new t$(this,a)),tC){let t=e._experiments;tN.setConfig({captureExceptions:!!t.captureExceptions,traceInternals:!!t.traceInternals})}}getContext(){return this._context}isEnabled(){return this._isEnabled}isPaused(){return this._isPaused}isRecordingCanvas(){return!!this._canvas}getOptions(){return this._options}handleException(e){tC&&tN.exception(e),this._options.onError&&this._options.onError(e)}initializeSampling(e){let{errorSampleRate:t,sessionSampleRate:r}=this._options,n=t<=0&&r<=0;if(this._requiresManualStart=n,!n){if(this._initializeSessionForSampling(e),!this.session){tC&&tN.exception(Error("Unable to initialize and create session"));return}!1!==this.session.sampled&&(this.recordingMode="buffer"===this.session.sampled&&0===this.session.segmentId?"buffer":"session",tC&&tN.infoTick(`Starting replay in ${this.recordingMode} mode`),this._initializeRecording())}}start(){if(this._isEnabled&&"session"===this.recordingMode){tC&&tN.info("Recording is already in progress");return}if(this._isEnabled&&"buffer"===this.recordingMode){tC&&tN.info("Buffering is in progress, call `flush()` to save the replay");return}tC&&tN.infoTick("Starting replay in session mode"),this._updateUserActivity();let e=ra({maxReplayDuration:this._options.maxReplayDuration,sessionIdleExpire:this.timeouts.sessionIdleExpire},{stickySession:this._options.stickySession,sessionSampleRate:1,allowBuffering:!1});this.session=e,this._initializeRecording()}startBuffering(){if(this._isEnabled){tC&&tN.info("Buffering is in progress, call `flush()` to save the replay");return}tC&&tN.infoTick("Starting replay in buffer mode");let e=ra({sessionIdleExpire:this.timeouts.sessionIdleExpire,maxReplayDuration:this._options.maxReplayDuration},{stickySession:this._options.stickySession,sessionSampleRate:0,allowBuffering:!0});this.session=e,this.recordingMode="buffer",this._initializeRecording()}startRecording(){try{var e;let t,r=this._canvas;this._stopRecording=tA({...this._recordingOptions,..."buffer"===this.recordingMode?{checkoutEveryNms:6e4}:this._options._experiments.continuousCheckout&&{checkoutEveryNms:Math.max(36e4,this._options._experiments.continuousCheckout)},emit:(e=this,t=!1,(r,n)=>{if(!e.checkAndHandleExpiredSession()){tC&&tN.warn("Received replay event after session expired.");return}let s=n||!t;t=!0,e.clickDetector&&function(e,t){try{var r;if(r=t,3!==r.type)return;let{source:n}=t.data;if(tz.has(n)&&e.registerMutation(t.timestamp),n===e6.Scroll&&e.registerScroll(t.timestamp),t.data.source===e6.MouseInteraction){let{type:r,id:n}=t.data,s=tA.mirror.getNode(n);s instanceof HTMLElement&&r===e8.Click&&e.registerClick(s)}}catch(e){}}(e.clickDetector,r),e.addUpdate(()=>{var t;if("buffer"===e.recordingMode&&s&&e.setInitialState(),!ro(e,r,s))return!0;if(!s)return!1;let n=e.session;if(t=e,s&&t.session&&0===t.session.segmentId&&ro(t,function(e){let t=e.getOptions();return{type:e5.Custom,timestamp:Date.now(),data:{tag:"options",payload:{shouldRecordCanvas:e.isRecordingCanvas(),sessionSampleRate:t.sessionSampleRate,errorSampleRate:t.errorSampleRate,useCompressionOption:t.useCompression,blockAllMedia:t.blockAllMedia,maskAllText:t.maskAllText,maskAllInputs:t.maskAllInputs,useCompression:!!e.eventBuffer&&"worker"===e.eventBuffer.type,networkDetailHasUrls:t.networkDetailAllowUrls.length>0,networkCaptureBodies:t.networkCaptureBodies,networkRequestHasHeaders:t.networkRequestHeaders.length>0,networkResponseHasHeaders:t.networkResponseHeaders.length>0}}}}(t),!1),n&&n.previousSessionId)return!0;if("buffer"===e.recordingMode&&n&&e.eventBuffer){let t=e.eventBuffer.getEarliestTimestamp();t&&(tC&&tN.info(`Updating session start time to earliest event in buffer to ${new Date(t)}`),n.started=t,e.getOptions().stickySession&&re(n))}return"session"===e.recordingMode&&e.flush(),!0})}),onMutation:this._onMutationHandler,...r?{recordCanvas:r.recordCanvas,getCanvasManager:r.getCanvasManager,sampling:r.sampling,dataURLOptions:r.dataURLOptions}:{}})}catch(e){this.handleException(e)}}stopRecording(){try{return this._stopRecording&&(this._stopRecording(),this._stopRecording=void 0),!0}catch(e){return this.handleException(e),!1}}async stop({forceFlush:e=!1,reason:t}={}){if(this._isEnabled){this._isEnabled=!1;try{tC&&tN.info(`Stopping Replay${t?` triggered by ${t}`:""}`),this._removeListeners(),this.stopRecording(),this._debouncedFlush.cancel(),e&&await this._flush({force:!0}),this.eventBuffer&&this.eventBuffer.destroy(),this.eventBuffer=null,function(){if(t4())try{G.sessionStorage.removeItem(J)}catch(e){}}(),this.session=void 0}catch(e){this.handleException(e)}}}pause(){!this._isPaused&&(this._isPaused=!0,this.stopRecording(),tC&&tN.info("Pausing replay"))}resume(){this._isPaused&&this._checkSession()&&(this._isPaused=!1,this.startRecording(),tC&&tN.info("Resuming replay"))}async sendBufferedReplayOrFlush({continueRecording:e=!0}={}){if("session"===this.recordingMode)return this.flushImmediate();let t=Date.now();tC&&tN.info("Converting buffer to session"),await this.flushImmediate();let r=this.stopRecording();e&&r&&"session"!==this.recordingMode&&(this.recordingMode="session",this.session&&(this._updateUserActivity(t),this._updateSessionActivity(t),this._maybeSaveSession()),this.startRecording())}addUpdate(e){let t=e();"buffer"!==this.recordingMode&&!0!==t&&this._debouncedFlush()}triggerUserActivity(){if(this._updateUserActivity(),!this._stopRecording){if(!this._checkSession())return;this.resume();return}this.checkAndHandleExpiredSession(),this._updateSessionActivity()}updateUserActivity(){this._updateUserActivity(),this._updateSessionActivity()}conditionalFlush(){return"buffer"===this.recordingMode?Promise.resolve():this.flushImmediate()}flush(){return this._debouncedFlush()}flushImmediate(){return this._debouncedFlush(),this._debouncedFlush.flush()}cancelFlush(){this._debouncedFlush.cancel()}getSessionId(){return this.session&&this.session.id}checkAndHandleExpiredSession(){return this._lastActivity&&rr(this._lastActivity,this.timeouts.sessionIdlePause)&&this.session&&"session"===this.session.sampled?void this.pause():!!this._checkSession()}setInitialState(){let e=`${G.location.pathname}${G.location.hash}${G.location.search}`,t=`${G.location.origin}${e}`;this.performanceEntries=[],this.replayPerformanceEntries=[],this._clearContext(),this._context.initialUrl=t,this._context.initialTimestamp=Date.now(),this._context.urls.push(t)}throttledAddEvent(e,t){let r=this._throttledAddEvent(e,t);if(r===rq){let e=tW({category:"replay.throttled"});this.addUpdate(()=>!ro(this,{type:5,timestamp:e.timestamp||0,data:{tag:"breadcrumb",payload:e,metric:!0}}))}return r}getCurrentRoute(){let e=this.lastActiveSpan||(0,T.Bk)(),t=e&&(0,T.zU)(e),r=(t&&(0,T.et)(t).data||{})[w.i_];if(t&&r&&["route","custom"].includes(r))return(0,T.et)(t).description}_initializeRecording(){this.setInitialState(),this._updateSessionActivity(),this.eventBuffer=function({useCompression:e,workerUrl:t}){if(e&&window.Worker){let e=function(e){try{let t=e||function(){if("undefined"==typeof __SENTRY_EXCLUDE_REPLAY_WORKER__||!__SENTRY_EXCLUDE_REPLAY_WORKER__){let e=new Blob(['var t=Uint8Array,n=Uint16Array,r=Int32Array,e=new t([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),i=new t([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),a=new t([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),s=function(t,e){for(var i=new n(31),a=0;a<31;++a)i[a]=e+=1<<t[a-1];var s=new r(i[30]);for(a=1;a<30;++a)for(var o=i[a];o<i[a+1];++o)s[o]=o-i[a]<<5|a;return{b:i,r:s}},o=s(e,2),f=o.b,h=o.r;f[28]=258,h[258]=28;for(var l=s(i,0).r,u=new n(32768),c=0;c<32768;++c){var v=(43690&c)>>1|(21845&c)<<1;v=(61680&(v=(52428&v)>>2|(13107&v)<<2))>>4|(3855&v)<<4,u[c]=((65280&v)>>8|(255&v)<<8)>>1}var d=function(t,r,e){for(var i=t.length,a=0,s=new n(r);a<i;++a)t[a]&&++s[t[a]-1];var o,f=new n(r);for(a=1;a<r;++a)f[a]=f[a-1]+s[a-1]<<1;if(e){o=new n(1<<r);var h=15-r;for(a=0;a<i;++a)if(t[a])for(var l=a<<4|t[a],c=r-t[a],v=f[t[a]-1]++<<c,d=v|(1<<c)-1;v<=d;++v)o[u[v]>>h]=l}else for(o=new n(i),a=0;a<i;++a)t[a]&&(o[a]=u[f[t[a]-1]++]>>15-t[a]);return o},g=new t(288);for(c=0;c<144;++c)g[c]=8;for(c=144;c<256;++c)g[c]=9;for(c=256;c<280;++c)g[c]=7;for(c=280;c<288;++c)g[c]=8;var w=new t(32);for(c=0;c<32;++c)w[c]=5;var p=d(g,9,0),y=d(w,5,0),m=function(t){return(t+7)/8|0},b=function(n,r,e){return(null==r||r<0)&&(r=0),(null==e||e>n.length)&&(e=n.length),new t(n.subarray(r,e))},M=["unexpected EOF","invalid block type","invalid length/literal","invalid distance","stream finished","no stream handler",,"no callback","invalid UTF-8 data","extra field too long","date not in range 1980-2099","filename too long","stream finishing","invalid zip data"],E=function(t,n,r){var e=new Error(n||M[t]);if(e.code=t,Error.captureStackTrace&&Error.captureStackTrace(e,E),!r)throw e;return e},z=function(t,n,r){r<<=7&n;var e=n/8|0;t[e]|=r,t[e+1]|=r>>8},A=function(t,n,r){r<<=7&n;var e=n/8|0;t[e]|=r,t[e+1]|=r>>8,t[e+2]|=r>>16},_=function(r,e){for(var i=[],a=0;a<r.length;++a)r[a]&&i.push({s:a,f:r[a]});var s=i.length,o=i.slice();if(!s)return{t:F,l:0};if(1==s){var f=new t(i[0].s+1);return f[i[0].s]=1,{t:f,l:1}}i.sort((function(t,n){return t.f-n.f})),i.push({s:-1,f:25001});var h=i[0],l=i[1],u=0,c=1,v=2;for(i[0]={s:-1,f:h.f+l.f,l:h,r:l};c!=s-1;)h=i[i[u].f<i[v].f?u++:v++],l=i[u!=c&&i[u].f<i[v].f?u++:v++],i[c++]={s:-1,f:h.f+l.f,l:h,r:l};var d=o[0].s;for(a=1;a<s;++a)o[a].s>d&&(d=o[a].s);var g=new n(d+1),w=x(i[c-1],g,0);if(w>e){a=0;var p=0,y=w-e,m=1<<y;for(o.sort((function(t,n){return g[n.s]-g[t.s]||t.f-n.f}));a<s;++a){var b=o[a].s;if(!(g[b]>e))break;p+=m-(1<<w-g[b]),g[b]=e}for(p>>=y;p>0;){var M=o[a].s;g[M]<e?p-=1<<e-g[M]++-1:++a}for(;a>=0&&p;--a){var E=o[a].s;g[E]==e&&(--g[E],++p)}w=e}return{t:new t(g),l:w}},x=function(t,n,r){return-1==t.s?Math.max(x(t.l,n,r+1),x(t.r,n,r+1)):n[t.s]=r},D=function(t){for(var r=t.length;r&&!t[--r];);for(var e=new n(++r),i=0,a=t[0],s=1,o=function(t){e[i++]=t},f=1;f<=r;++f)if(t[f]==a&&f!=r)++s;else{if(!a&&s>2){for(;s>138;s-=138)o(32754);s>2&&(o(s>10?s-11<<5|28690:s-3<<5|12305),s=0)}else if(s>3){for(o(a),--s;s>6;s-=6)o(8304);s>2&&(o(s-3<<5|8208),s=0)}for(;s--;)o(a);s=1,a=t[f]}return{c:e.subarray(0,i),n:r}},T=function(t,n){for(var r=0,e=0;e<n.length;++e)r+=t[e]*n[e];return r},k=function(t,n,r){var e=r.length,i=m(n+2);t[i]=255&e,t[i+1]=e>>8,t[i+2]=255^t[i],t[i+3]=255^t[i+1];for(var a=0;a<e;++a)t[i+a+4]=r[a];return 8*(i+4+e)},C=function(t,r,s,o,f,h,l,u,c,v,m){z(r,m++,s),++f[256];for(var b=_(f,15),M=b.t,E=b.l,x=_(h,15),C=x.t,U=x.l,F=D(M),I=F.c,S=F.n,L=D(C),O=L.c,j=L.n,q=new n(19),B=0;B<I.length;++B)++q[31&I[B]];for(B=0;B<O.length;++B)++q[31&O[B]];for(var G=_(q,7),H=G.t,J=G.l,K=19;K>4&&!H[a[K-1]];--K);var N,P,Q,R,V=v+5<<3,W=T(f,g)+T(h,w)+l,X=T(f,M)+T(h,C)+l+14+3*K+T(q,H)+2*q[16]+3*q[17]+7*q[18];if(c>=0&&V<=W&&V<=X)return k(r,m,t.subarray(c,c+v));if(z(r,m,1+(X<W)),m+=2,X<W){N=d(M,E,0),P=M,Q=d(C,U,0),R=C;var Y=d(H,J,0);z(r,m,S-257),z(r,m+5,j-1),z(r,m+10,K-4),m+=14;for(B=0;B<K;++B)z(r,m+3*B,H[a[B]]);m+=3*K;for(var Z=[I,O],$=0;$<2;++$){var tt=Z[$];for(B=0;B<tt.length;++B){var nt=31&tt[B];z(r,m,Y[nt]),m+=H[nt],nt>15&&(z(r,m,tt[B]>>5&127),m+=tt[B]>>12)}}}else N=p,P=g,Q=y,R=w;for(B=0;B<u;++B){var rt=o[B];if(rt>255){A(r,m,N[(nt=rt>>18&31)+257]),m+=P[nt+257],nt>7&&(z(r,m,rt>>23&31),m+=e[nt]);var et=31&rt;A(r,m,Q[et]),m+=R[et],et>3&&(A(r,m,rt>>5&8191),m+=i[et])}else A(r,m,N[rt]),m+=P[rt]}return A(r,m,N[256]),m+P[256]},U=new r([65540,131080,131088,131104,262176,1048704,1048832,2114560,2117632]),F=new t(0),I=function(){for(var t=new Int32Array(256),n=0;n<256;++n){for(var r=n,e=9;--e;)r=(1&r&&-306674912)^r>>>1;t[n]=r}return t}(),S=function(){var t=-1;return{p:function(n){for(var r=t,e=0;e<n.length;++e)r=I[255&r^n[e]]^r>>>8;t=r},d:function(){return~t}}},L=function(){var t=1,n=0;return{p:function(r){for(var e=t,i=n,a=0|r.length,s=0;s!=a;){for(var o=Math.min(s+2655,a);s<o;++s)i+=e+=r[s];e=(65535&e)+15*(e>>16),i=(65535&i)+15*(i>>16)}t=e,n=i},d:function(){return(255&(t%=65521))<<24|(65280&t)<<8|(255&(n%=65521))<<8|n>>8}}},O=function(a,s,o,f,u){if(!u&&(u={l:1},s.dictionary)){var c=s.dictionary.subarray(-32768),v=new t(c.length+a.length);v.set(c),v.set(a,c.length),a=v,u.w=c.length}return function(a,s,o,f,u,c){var v=c.z||a.length,d=new t(f+v+5*(1+Math.ceil(v/7e3))+u),g=d.subarray(f,d.length-u),w=c.l,p=7&(c.r||0);if(s){p&&(g[0]=c.r>>3);for(var y=U[s-1],M=y>>13,E=8191&y,z=(1<<o)-1,A=c.p||new n(32768),_=c.h||new n(z+1),x=Math.ceil(o/3),D=2*x,T=function(t){return(a[t]^a[t+1]<<x^a[t+2]<<D)&z},F=new r(25e3),I=new n(288),S=new n(32),L=0,O=0,j=c.i||0,q=0,B=c.w||0,G=0;j+2<v;++j){var H=T(j),J=32767&j,K=_[H];if(A[J]=K,_[H]=J,B<=j){var N=v-j;if((L>7e3||q>24576)&&(N>423||!w)){p=C(a,g,0,F,I,S,O,q,G,j-G,p),q=L=O=0,G=j;for(var P=0;P<286;++P)I[P]=0;for(P=0;P<30;++P)S[P]=0}var Q=2,R=0,V=E,W=J-K&32767;if(N>2&&H==T(j-W))for(var X=Math.min(M,N)-1,Y=Math.min(32767,j),Z=Math.min(258,N);W<=Y&&--V&&J!=K;){if(a[j+Q]==a[j+Q-W]){for(var $=0;$<Z&&a[j+$]==a[j+$-W];++$);if($>Q){if(Q=$,R=W,$>X)break;var tt=Math.min(W,$-2),nt=0;for(P=0;P<tt;++P){var rt=j-W+P&32767,et=rt-A[rt]&32767;et>nt&&(nt=et,K=rt)}}}W+=(J=K)-(K=A[J])&32767}if(R){F[q++]=268435456|h[Q]<<18|l[R];var it=31&h[Q],at=31&l[R];O+=e[it]+i[at],++I[257+it],++S[at],B=j+Q,++L}else F[q++]=a[j],++I[a[j]]}}for(j=Math.max(j,B);j<v;++j)F[q++]=a[j],++I[a[j]];p=C(a,g,w,F,I,S,O,q,G,j-G,p),w||(c.r=7&p|g[p/8|0]<<3,p-=7,c.h=_,c.p=A,c.i=j,c.w=B)}else{for(j=c.w||0;j<v+w;j+=65535){var st=j+65535;st>=v&&(g[p/8|0]=w,st=v),p=k(g,p+1,a.subarray(j,st))}c.i=v}return b(d,0,f+m(p)+u)}(a,null==s.level?6:s.level,null==s.mem?Math.ceil(1.5*Math.max(8,Math.min(13,Math.log(a.length)))):12+s.mem,o,f,u)},j=function(t,n,r){for(;r;++n)t[n]=r,r>>>=8},q=function(t,n){var r=n.filename;if(t[0]=31,t[1]=139,t[2]=8,t[8]=n.level<2?4:9==n.level?2:0,t[9]=3,0!=n.mtime&&j(t,4,Math.floor(new Date(n.mtime||Date.now())/1e3)),r){t[3]=8;for(var e=0;e<=r.length;++e)t[e+10]=r.charCodeAt(e)}},B=function(t){return 10+(t.filename?t.filename.length+1:0)},G=function(){function n(n,r){if("function"==typeof n&&(r=n,n={}),this.ondata=r,this.o=n||{},this.s={l:0,i:32768,w:32768,z:32768},this.b=new t(98304),this.o.dictionary){var e=this.o.dictionary.subarray(-32768);this.b.set(e,32768-e.length),this.s.i=32768-e.length}}return n.prototype.p=function(t,n){this.ondata(O(t,this.o,0,0,this.s),n)},n.prototype.push=function(n,r){this.ondata||E(5),this.s.l&&E(4);var e=n.length+this.s.z;if(e>this.b.length){if(e>2*this.b.length-32768){var i=new t(-32768&e);i.set(this.b.subarray(0,this.s.z)),this.b=i}var a=this.b.length-this.s.z;a&&(this.b.set(n.subarray(0,a),this.s.z),this.s.z=this.b.length,this.p(this.b,!1)),this.b.set(this.b.subarray(-32768)),this.b.set(n.subarray(a),32768),this.s.z=n.length-a+32768,this.s.i=32766,this.s.w=32768}else this.b.set(n,this.s.z),this.s.z+=n.length;this.s.l=1&r,(this.s.z>this.s.w+8191||r)&&(this.p(this.b,r||!1),this.s.w=this.s.i,this.s.i-=2)},n}();var H=function(){function t(t,n){this.c=L(),this.v=1,G.call(this,t,n)}return t.prototype.push=function(t,n){this.c.p(t),G.prototype.push.call(this,t,n)},t.prototype.p=function(t,n){var r=O(t,this.o,this.v&&(this.o.dictionary?6:2),n&&4,this.s);this.v&&(function(t,n){var r=n.level,e=0==r?0:r<6?1:9==r?3:2;if(t[0]=120,t[1]=e<<6|(n.dictionary&&32),t[1]|=31-(t[0]<<8|t[1])%31,n.dictionary){var i=L();i.p(n.dictionary),j(t,2,i.d())}}(r,this.o),this.v=0),n&&j(r,r.length-4,this.c.d()),this.ondata(r,n)},t}(),J="undefined"!=typeof TextEncoder&&new TextEncoder,K="undefined"!=typeof TextDecoder&&new TextDecoder;try{K.decode(F,{stream:!0})}catch(t){}var N=function(){function t(t){this.ondata=t}return t.prototype.push=function(t,n){this.ondata||E(5),this.d&&E(4),this.ondata(P(t),this.d=n||!1)},t}();function P(n,r){if(r){for(var e=new t(n.length),i=0;i<n.length;++i)e[i]=n.charCodeAt(i);return e}if(J)return J.encode(n);var a=n.length,s=new t(n.length+(n.length>>1)),o=0,f=function(t){s[o++]=t};for(i=0;i<a;++i){if(o+5>s.length){var h=new t(o+8+(a-i<<1));h.set(s),s=h}var l=n.charCodeAt(i);l<128||r?f(l):l<2048?(f(192|l>>6),f(128|63&l)):l>55295&&l<57344?(f(240|(l=65536+(1047552&l)|1023&n.charCodeAt(++i))>>18),f(128|l>>12&63),f(128|l>>6&63),f(128|63&l)):(f(224|l>>12),f(128|l>>6&63),f(128|63&l))}return b(s,0,o)}function Q(t){return function(t,n){n||(n={});var r=S(),e=t.length;r.p(t);var i=O(t,n,B(n),8),a=i.length;return q(i,n),j(i,a-8,r.d()),j(i,a-4,e),i}(P(t))}const R=new class{constructor(){this._init()}clear(){this._init()}addEvent(t){if(!t)throw new Error("Adding invalid event");const n=this._hasEvents?",":"";this.stream.push(n+t),this._hasEvents=!0}finish(){this.stream.push("]",!0);const t=function(t){let n=0;for(const r of t)n+=r.length;const r=new Uint8Array(n);for(let n=0,e=0,i=t.length;n<i;n++){const i=t[n];r.set(i,e),e+=i.length}return r}(this._deflatedData);return this._init(),t}_init(){this._hasEvents=!1,this._deflatedData=[],this.deflate=new H,this.deflate.ondata=(t,n)=>{this._deflatedData.push(t)},this.stream=new N(((t,n)=>{this.deflate.push(t,n)})),this.stream.push("[")}},V={clear:()=>{R.clear()},addEvent:t=>R.addEvent(t),finish:()=>R.finish(),compress:t=>Q(t)};addEventListener("message",(function(t){const n=t.data.method,r=t.data.id,e=t.data.arg;if(n in V&&"function"==typeof V[n])try{const t=V[n](e);postMessage({id:r,method:n,success:!0,response:t})}catch(t){postMessage({id:r,method:n,success:!1,response:t.message}),console.error(t)}})),postMessage({id:void 0,method:"init",success:!0,response:void 0});']);return URL.createObjectURL(e)}return""}();if(!t)return;tC&&tN.info(`Using compression worker${e?` from ${e}`:""}`);let r=new Worker(t);return new t8(r)}catch(e){tC&&tN.exception(e,"Failed to create compression worker")}}(t);if(e)return e}return tC&&tN.info("Using simple buffer"),new t3}({useCompression:this._options.useCompression,workerUrl:this._options.workerUrl}),this._removeListeners(),this._addListeners(),this._isEnabled=!0,this._isPaused=!1,this.startRecording()}_initializeSessionForSampling(e){let t=this._options.errorSampleRate>0,r=ra({sessionIdleExpire:this.timeouts.sessionIdleExpire,maxReplayDuration:this._options.maxReplayDuration,previousSessionId:e},{stickySession:this._options.stickySession,sessionSampleRate:this._options.sessionSampleRate,allowBuffering:t});this.session=r}_checkSession(){if(!this.session)return!1;let e=this.session;return!rs(e,{sessionIdleExpire:this.timeouts.sessionIdleExpire,maxReplayDuration:this._options.maxReplayDuration})||(this._refreshSession(e),!1)}async _refreshSession(e){this._isEnabled&&(await this.stop({reason:"refresh session"}),this.initializeSampling(e.id))}_addListeners(){try{G.document.addEventListener("visibilitychange",this._handleVisibilityChange),G.addEventListener("blur",this._handleWindowBlur),G.addEventListener("focus",this._handleWindowFocus),G.addEventListener("keydown",this._handleKeyboardEvent),this.clickDetector&&this.clickDetector.addListeners(),this._hasInitializedCoreListeners||(!function(e){let t=(0,S.KU)();(0,W.i)(t=>{var r,n;if(!e.isEnabled())return;let s=function(e){let{target:t,message:r}=function(e){let t,r="click"===e.name,n=null;try{n=r?tP(e.event):tq(e.event),t=(0,I.Hd)(n,{maxStringLength:200})||"<unknown>"}catch(e){t="<unknown>"}return{target:n,message:t}}(e);return tW({category:`ui.${e.name}`,...tV(t,r)})}(t);if(!s)return;let a="click"===t.name,o=a?t.event:void 0;a&&e.clickDetector&&o&&o.target&&!o.altKey&&!o.metaKey&&!o.ctrlKey&&!o.shiftKey&&(r=e.clickDetector,n=tP(t.event),r.handleClick(s,n)),tL(e,s)}),(0,H._)(t=>{if(!e.isEnabled())return;let r=function(e){let{from:t,to:r}=e,n=Date.now()/1e3;return{type:"navigation.push",start:n,end:n,name:r,data:{previous:t}}}(t);null!==r&&(e.getContext().urls.push(r.name),e.triggerUserActivity(),e.addUpdate(()=>(rd(e,[r]),!1)))});let r=(0,S.KU)();r&&r.on("beforeAddBreadcrumb",t=>(function(e,t){var r;if(!e.isEnabled()||!rm(t))return;let n=(r=t,!rm(r)||["fetch","xhr","sentry.event","sentry.transaction"].includes(r.category)||r.category.startsWith("ui.")?null:"console"===r.category?function(e){let t=e.data&&e.data.arguments;if(!Array.isArray(t)||0===t.length)return tW(e);let r=!1,n=t.map(e=>{if(!e)return e;if("string"==typeof e)return e.length>5e3?(r=!0,`${e.slice(0,5e3)}…`):e;if("object"==typeof e)try{let t=(0,R.S8)(e,7);if(JSON.stringify(t).length>5e3)return r=!0,`${JSON.stringify(t,null,2).slice(0,5e3)}…`;return t}catch(e){}return e});return tW({...e,data:{...e.data,arguments:n,...r?{_meta:{warnings:["CONSOLE_ARG_TRUNCATED"]}}:{}}})}(r):tW(r));n&&tL(e,n)})(e,t));let n=(0,S.KU)();try{let{networkDetailAllowUrls:t,networkDetailDenyUrls:r,networkCaptureBodies:s,networkRequestHeaders:a,networkResponseHeaders:o}=e.getOptions(),i={replay:e,networkDetailAllowUrls:t,networkDetailDenyUrls:r,networkCaptureBodies:s,networkRequestHeaders:a,networkResponseHeaders:o};n&&n.on("beforeAddBreadcrumb",(e,t)=>(function(e,t,r){if(t.data)try{var n,s,a,o;if(n=t,"xhr"===n.category&&(s=r)&&s.xhr&&(!function(e,t){let{xhr:r,input:n}=t;if(!r)return;let s=rh(n),a=r.getResponseHeader("content-length")?rf(r.getResponseHeader("content-length")):function(e,t){try{let r="json"===t&&e&&"object"==typeof e?JSON.stringify(e):e;return rh(r)}catch(e){return}}(r.response,r.responseType);void 0!==s&&(e.data.request_body_size=s),void 0!==a&&(e.data.response_body_size=a)}(t,r),rM(t,r,e)),a=t,"fetch"===a.category&&(o=r)&&o.response){let{input:n,response:s}=r,a=rh(n?rA(n):void 0),o=s?rf(s.headers.get("content-length")):void 0;void 0!==a&&(t.data.request_body_size=a),void 0!==o&&(t.data.response_body_size=o),rS(t,r,e)}}catch(e){tC&&tN.exception(e,"Error when enriching network breadcrumb")}})(i,e,t))}catch(e){}let s=Object.assign((t,r)=>!e.isEnabled()||e.isPaused()?t:"replay_event"===t.type?(delete t.breadcrumbs,t):(!t.type||rc(t)||ru(t))&&e.checkAndHandleExpiredSession()?ru(t)?(e.flush(),t.contexts.feedback.replay_id=e.getSessionId(),e.triggerUserActivity(),e.addUpdate(()=>!t.timestamp||(e.throttledAddEvent({type:e5.Custom,timestamp:1e3*t.timestamp,data:{tag:"breadcrumb",payload:{timestamp:t.timestamp,type:"default",category:"sentry.feedback",data:{feedbackId:t.event_id}}}}),!1)),t):!t.type&&t.exception&&t.exception.values&&t.exception.values.length&&r.originalException&&r.originalException.__rrweb__&&!e.getOptions()._experiments.captureExceptions?(tC&&tN.log("Ignoring error from rrweb internals",t),null):(("buffer"===e.recordingMode&&t.message!==Z&&t.exception&&!t.type&&t9(e.getOptions().errorSampleRate)||"session"===e.recordingMode)&&(t.tags={...t.tags,replayId:e.getSessionId()}),t):t,{id:"Replay"});(0,x.SA)(s),t&&(t.on("beforeSendEvent",t=>{e.isEnabled()&&!t.type&&function(e,t){let r=t.exception&&t.exception.values&&t.exception.values[0]&&t.exception.values[0].value;"string"==typeof r&&(r.match(/(reactjs\.org\/docs\/error-decoder\.html\?invariant=|react\.dev\/errors\/)(418|419|422|423|425)/)||r.match(/(does not match server-rendered HTML|Hydration failed because)/i))&&tL(e,tW({category:"replay.hydrate-error",data:{url:(0,I.$N)()}}))}(e,t)}),t.on("afterSendEvent",(t,r)=>{if(!e.isEnabled()||t.type&&!rc(t))return;let n=r&&r.statusCode;if(n&&!(n<200)&&!(n>=300)){if(rc(t))return void function(e,t){let r=e.getContext();t.contexts&&t.contexts.trace&&t.contexts.trace.trace_id&&r.traceIds.size<100&&r.traceIds.add(t.contexts.trace.trace_id)}(e,t);!function(e,t){let r=e.getContext();if(t.event_id&&r.errorIds.size<100&&r.errorIds.add(t.event_id),"buffer"!==e.recordingMode||!t.tags||!t.tags.replayId)return;let{beforeErrorSampling:n}=e.getOptions();("function"!=typeof n||n(t))&&(0,V.wg)(()=>{e.sendBufferedReplayOrFlush()})}(e,t)}}),t.on("createDsc",t=>{let r=e.getSessionId();r&&e.isEnabled()&&"session"===e.recordingMode&&e.checkAndHandleExpiredSession()&&(t.replay_id=r)}),t.on("spanStart",t=>{e.lastActiveSpan=t}),t.on("spanEnd",t=>{e.lastActiveSpan=t}),t.on("beforeSendFeedback",(t,r)=>{let n=e.getSessionId();r&&r.includeReplay&&e.isEnabled()&&n&&t.contexts&&t.contexts.feedback&&(t.contexts.feedback.replay_id=n)}))}(this),this._hasInitializedCoreListeners=!0)}catch(e){this.handleException(e)}this._performanceCleanupCallback=function(e){function t(t){e.performanceEntries.includes(t)||e.performanceEntries.push(t)}function r({entries:e}){e.forEach(t)}let n=[];return["navigation","paint","resource"].forEach(e=>{n.push((0,B.wv)(e,r))}),n.push((0,B.Pt)(tG(tK,e)),(0,B.a9)(tG(tX,e)),(0,B.T5)(tG(tQ,e)),(0,B.hT)(tG(t0,e))),()=>{n.forEach(e=>e())}}(this)}_removeListeners(){try{G.document.removeEventListener("visibilitychange",this._handleVisibilityChange),G.removeEventListener("blur",this._handleWindowBlur),G.removeEventListener("focus",this._handleWindowFocus),G.removeEventListener("keydown",this._handleKeyboardEvent),this.clickDetector&&this.clickDetector.removeListeners(),this._performanceCleanupCallback&&this._performanceCleanupCallback()}catch(e){this.handleException(e)}}__init(){this._handleVisibilityChange=()=>{"visible"===G.document.visibilityState?this._doChangeToForegroundTasks():this._doChangeToBackgroundTasks()}}__init2(){this._handleWindowBlur=()=>{let e=tW({category:"ui.blur"});this._doChangeToBackgroundTasks(e)}}__init3(){this._handleWindowFocus=()=>{let e=tW({category:"ui.focus"});this._doChangeToForegroundTasks(e)}}__init4(){this._handleKeyboardEvent=e=>{!function(e,t){if(!e.isEnabled())return;e.updateUserActivity();let r=function(e){var t;let{metaKey:r,shiftKey:n,ctrlKey:s,altKey:a,key:o,target:i}=e;if(!i||"INPUT"===(t=i).tagName||"TEXTAREA"===t.tagName||t.isContentEditable||!o)return null;let l=r||s||a,c=1===o.length;if(!l&&c)return null;let u=(0,I.Hd)(i,{maxStringLength:200})||"<unknown>",m=tV(i,u);return tW({category:"ui.keyDown",message:u,data:{...m.data,metaKey:r,shiftKey:n,ctrlKey:s,altKey:a,key:o}})}(t);r&&tL(e,r)}(this,e)}}_doChangeToBackgroundTasks(e){this.session&&(rn(this.session,{maxReplayDuration:this._options.maxReplayDuration,sessionIdleExpire:this.timeouts.sessionIdleExpire})||(e&&this._createCustomBreadcrumb(e),this.conditionalFlush()))}_doChangeToForegroundTasks(e){if(this.session){if(!this.checkAndHandleExpiredSession()){tC&&tN.info("Document has become active, but session has expired");return}e&&this._createCustomBreadcrumb(e)}}_updateUserActivity(e=Date.now()){this._lastActivity=e}_updateSessionActivity(e=Date.now()){this.session&&(this.session.lastActivity=e,this._maybeSaveSession())}_createCustomBreadcrumb(e){this.addUpdate(()=>{this.throttledAddEvent({type:e5.Custom,timestamp:e.timestamp||0,data:{tag:"breadcrumb",payload:e}})})}_addPerformanceEntries(){let e=this.performanceEntries.map(tJ).filter(Boolean).concat(this.replayPerformanceEntries);return this.performanceEntries=[],this.replayPerformanceEntries=[],Promise.all(rd(this,e))}_clearContext(){this._context.errorIds.clear(),this._context.traceIds.clear(),this._context.urls=[]}_updateInitialTimestampFromEventBuffer(){let{session:e,eventBuffer:t}=this;if(!e||!t||this._requiresManualStart||e.segmentId)return;let r=t.getEarliestTimestamp();r&&r<this._context.initialTimestamp&&(this._context.initialTimestamp=r)}_popEventContext(){let e={initialTimestamp:this._context.initialTimestamp,initialUrl:this._context.initialUrl,errorIds:Array.from(this._context.errorIds),traceIds:Array.from(this._context.traceIds),urls:this._context.urls};return this._clearContext(),e}async _runFlush(){let e=this.getSessionId();if(!this.session||!this.eventBuffer||!e){tC&&tN.error("No session or eventBuffer found to flush.");return}if(await this._addPerformanceEntries(),this.eventBuffer&&this.eventBuffer.hasEvents){if((await rN(this),this.eventBuffer)&&e===this.getSessionId())try{this._updateInitialTimestampFromEventBuffer();let t=Date.now();if(t-this._context.initialTimestamp>this._options.maxReplayDuration+3e4)throw Error("Session is too long, not sending replay");let r=this._popEventContext(),n=this.session.segmentId++;this._maybeSaveSession();let s=await this.eventBuffer.finish();await rP({replayId:e,recordingData:s,segmentId:n,eventContext:r,session:this.session,timestamp:t,onError:e=>this.handleException(e)})}catch(t){this.handleException(t),this.stop({reason:"sendReplay"});let e=(0,S.KU)();e&&e.recordDroppedEvent(t instanceof rF?"ratelimit_backoff":"send_error","replay")}}}__init5(){this._flush=async({force:e=!1}={})=>{if(!this._isEnabled&&!e)return;if(!this.checkAndHandleExpiredSession()){tC&&tN.error("Attempting to finish replay event after session expired.");return}if(!this.session)return;let t=this.session.started,r=Date.now()-t;this._debouncedFlush.cancel();let n=r<this._options.minReplayDuration,s=r>this._options.maxReplayDuration+5e3;if(n||s){tC&&tN.info(`Session duration (${Math.floor(r/1e3)}s) is too ${n?"short":"long"}, not sending replay.`),n&&this._debouncedFlush();return}let a=this.eventBuffer;a&&0===this.session.segmentId&&!a.hasCheckout&&tC&&tN.info("Flushing initial segment without checkout.");let o=!!this._flushLock;this._flushLock||(this._flushLock=this._runFlush());try{await this._flushLock}catch(e){this.handleException(e)}finally{this._flushLock=void 0,o&&this._debouncedFlush()}}}_maybeSaveSession(){this.session&&this._options.stickySession&&re(this.session)}__init6(){this._onMutationHandler=e=>{let t=e.length,r=this._options.mutationLimit,n=this._options.mutationBreadcrumbLimit,s=r&&t>r;if(t>n||s){let e=tW({category:"replay.mutations",data:{count:t,limit:s}});this._createCustomBreadcrumb(e)}return!s||(this.stop({reason:"mutationLimit",forceFlush:"session"===this.recordingMode}),!1)}}}function r$(e,t){return[...e,...t].join(",")}let rU='img,image,svg,video,object,picture,embed,map,audio,link[rel="icon"],link[rel="apple-touch-icon"]',rB=["content-length","content-type","accept"],rW=!1,rH=e=>new rV(e);class rV{static __initStatic(){this.id="Replay"}constructor({flushMinDelay:e=5e3,flushMaxDelay:t=5500,minReplayDuration:r=4999,maxReplayDuration:n=36e5,stickySession:s=!0,useCompression:a=!0,workerUrl:o,_experiments:i={},maskAllText:l=!0,maskAllInputs:c=!0,blockAllMedia:u=!0,mutationBreadcrumbLimit:m=750,mutationLimit:d=1e4,slowClickTimeout:p=7e3,slowClickIgnoreSelectors:h=[],networkDetailAllowUrls:f=[],networkDetailDenyUrls:g=[],networkCaptureBodies:y=!0,networkRequestHeaders:b=[],networkResponseHeaders:k=[],mask:v=[],maskAttributes:_=["title","placeholder"],unmask:w=[],block:x=[],unblock:S=[],ignore:E=[],maskFn:j,beforeAddRecordingEvent:T,beforeErrorSampling:A}={}){this.name=rV.id;let C=function({mask:e,unmask:t,block:r,unblock:n,ignore:s}){return{maskTextSelector:r$(e,[".sentry-mask","[data-sentry-mask]"]),unmaskTextSelector:r$(t,[]),blockSelector:r$(r,[".sentry-block","[data-sentry-block]",'base[href="/"]']),unblockSelector:r$(n,[]),ignoreSelector:r$(s,[".sentry-ignore","[data-sentry-ignore]",'input[type="file"]'])}}({mask:v,unmask:w,block:x,unblock:S,ignore:E});if(this._recordingOptions={maskAllInputs:c,maskAllText:l,maskInputOptions:{password:!0},maskTextFn:j,maskInputFn:j,maskAttributeFn:(e,t,r)=>(function({el:e,key:t,maskAttributes:r,maskAllText:n,privacyOptions:s,value:a}){return!n||s.unmaskTextSelector&&e.matches(s.unmaskTextSelector)?a:r.includes(t)||"value"===t&&"INPUT"===e.tagName&&["submit","button"].includes(e.getAttribute("type")||"")?a.replace(/[\S]/g,"*"):a})({maskAttributes:_,maskAllText:l,privacyOptions:C,key:e,value:t,el:r}),...C,slimDOMOptions:"all",inlineStylesheet:!0,inlineImages:!1,collectFonts:!0,errorHandler:e=>{try{e.__rrweb__=!0}catch(e){}}},this._initialOptions={flushMinDelay:e,flushMaxDelay:t,minReplayDuration:Math.min(r,15e3),maxReplayDuration:Math.min(n,36e5),stickySession:s,useCompression:a,workerUrl:o,blockAllMedia:u,maskAllInputs:c,maskAllText:l,mutationBreadcrumbLimit:m,mutationLimit:d,slowClickTimeout:p,slowClickIgnoreSelectors:h,networkDetailAllowUrls:f,networkDetailDenyUrls:g,networkCaptureBodies:y,networkRequestHeaders:rY(b),networkResponseHeaders:rY(k),beforeAddRecordingEvent:T,beforeErrorSampling:A,_experiments:i},this._initialOptions.blockAllMedia&&(this._recordingOptions.blockSelector=this._recordingOptions.blockSelector?`${this._recordingOptions.blockSelector},${rU}`:rU),this._isInitialized&&(0,M.B)())throw Error("Multiple Sentry Session Replay instances are not supported");this._isInitialized=!0}get _isInitialized(){return rW}set _isInitialized(e){rW=e}afterAllSetup(e){(0,M.B)()&&!this._replay&&(this._setup(e),this._initialize(e))}start(){this._replay&&this._replay.start()}startBuffering(){this._replay&&this._replay.startBuffering()}stop(){return this._replay?this._replay.stop({forceFlush:"session"===this._replay.recordingMode}):Promise.resolve()}flush(e){return this._replay?this._replay.isEnabled()?this._replay.sendBufferedReplayOrFlush(e):(this._replay.start(),Promise.resolve()):Promise.resolve()}getReplayId(){if(this._replay&&this._replay.isEnabled())return this._replay.getSessionId()}_initialize(e){this._replay&&(this._maybeLoadFromReplayCanvasIntegration(e),this._replay.initializeSampling())}_setup(e){let t=function(e,t){let r=t.getOptions(),n={sessionSampleRate:0,errorSampleRate:0,...(0,L.Ce)(e)},s=(0,A.i)(r.replaysSessionSampleRate),a=(0,A.i)(r.replaysOnErrorSampleRate);return null==s&&null==a&&(0,N.pq)(()=>{console.warn("Replay is disabled because neither `replaysSessionSampleRate` nor `replaysOnErrorSampleRate` are set.")}),null!=s&&(n.sessionSampleRate=s),null!=a&&(n.errorSampleRate=a),n}(this._initialOptions,e);this._replay=new rz({options:t,recordingOptions:this._recordingOptions})}_maybeLoadFromReplayCanvasIntegration(e){try{let t=e.getIntegrationByName("ReplayCanvas");if(!t)return;this._replay._canvas=t.getOptions()}catch(e){}}}function rY(e){return[...rB,...e.map(e=>e.toLowerCase())]}function rG(){let e=(0,S.KU)();return e&&e.getIntegrationByName("Replay")}rV.__initStatic()},117529(e,t,r){"use strict";r.d(t,{D:()=>g});var s=r(834529),a=r(812863),o=r(933190),i=r(608119),l=r(834028),c=r(107842),u=r(97407),m=r(37853),d=r(756025),p=r(932294),h=r(858586),f=r(259463);function g(){let e,t,r=0;if(!function(){try{return(0,s.z)([PerformanceObserver,"access",e=>e.supportedEntryTypes,"optionalAccess",e=>e.includes,"call",e=>e("layout-shift")])}catch(e){return!1}}())return;let g=!1;function y(){g||(g=!0,t&&function(e,t,r){d.T&&c.vF.log(`Sending CLS span (${e})`);let n=(0,h.rv)((m.k3||0)+((0,s.z)([t,"optionalAccess",e=>e.startTime])||0)),i=(0,o.o5)().getScopeData().transactionName,p=t?(0,l.Hd)((0,s.z)([t,"access",e=>e.sources,"access",e=>e[0],"optionalAccess",e=>e.node])):"Layout shift",f=(0,u.Ce)({[a.JD]:"auto.http.browser.cls",[a.uT]:"ui.webvital.cls",[a.jG]:(0,s.z)([t,"optionalAccess",e=>e.duration])||0,"sentry.pageload.span_id":r}),g=(0,h.kD)({name:p,transaction:i,attributes:f,startTime:n});(0,s.z)([g,"optionalAccess",e=>e.addEvent,"call",t=>t("cls",{[a.Sn]:"",[a.xc]:e})]),(0,s.z)([g,"optionalAccess",e=>e.end,"call",e=>e(n)])}(r,e,t),b())}let b=(0,p.a9)(({metric:t})=>{let n=t.entries[t.entries.length-1];n&&(r=t.value,e=n)},!0);(0,f.Q)(()=>{y()}),n(()=>{let e=(0,o.KU)(),r=(0,s.z)([e,"optionalAccess",e=>e.on,"call",e=>e("startNavigationSpan",()=>{y(),r&&r()})]),n=(0,i.Bk)(),a=n&&(0,i.zU)(n),l=a&&(0,i.et)(a);l&&"pageload"===l.op&&(t=a.spanContext().spanId)},0)}},123628(e,t,r){"use strict";r.d(t,{A:()=>o});for(var n=r(951545),s=[],a=0;a<256;++a)s.push((a+256).toString(16).substr(1));let o=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,r=(s[e[t+0]]+s[e[t+1]]+s[e[t+2]]+s[e[t+3]]+"-"+s[e[t+4]]+s[e[t+5]]+"-"+s[e[t+6]]+s[e[t+7]]+"-"+s[e[t+8]]+s[e[t+9]]+"-"+s[e[t+10]]+s[e[t+11]]+s[e[t+12]]+s[e[t+13]]+s[e[t+14]]+s[e[t+15]]).toLowerCase();if(!(0,n.A)(r))throw TypeError("Stringified UUID is invalid");return r}},125617(e,t,r){"use strict";r.d(t,{j:()=>function e(t,r,i,l=0){return new a.T2((a,c)=>{let u=t[l];if(null===r||"function"!=typeof u)a(r);else{let m=u({...r},i);o.T&&u.id&&null===m&&s.vF.log(`Event processor "${u.id}" dropped event`),(0,n.Qg)(m)?m.then(r=>e(t,r,i,l+1).then(a)).then(null,c):e(t,m,i,l+1).then(a).then(null,c)}})}});var n=r(397718),s=r(107842),a=r(586312),o=r(67904)},130760(e,t,r){"use strict";r.d(t,{M:()=>a});var n=r(290264),s=r(845226);let a=(0,n._C)(()=>({name:"HttpContext",preprocessEvent(e){if(!s.jf.navigator&&!s.jf.location&&!s.jf.document)return;let t=e.request&&e.request.url||s.jf.location&&s.jf.location.href,{referrer:r}=s.jf.document||{},{userAgent:n}=s.jf.navigator||{},a={...e.request&&e.request.headers,...r&&{Referer:r},...n&&{"User-Agent":n}},o={...e.request,...t&&{url:t},headers:a};e.request=o}}))},132002(e,t,r){"use strict";r.d(t,{DW:()=>o,_K:()=>i,el:()=>c});var n=r(447519),s=r(812805),a=r(584553);function o(e,t="Unspecified error message. This is a bug, please report it."){if(Number.isInteger(e)){var r;let t=e.toString();if((0,s.i5)(a.z,t))return a.z[t].message;if((r=e)>=-32099&&r<=-32e3)return"Unspecified server error."}return t}function i(e){return Array.isArray(e)?e.map(e=>(0,n.jU)(e)?e:(0,s.Gv)(e)?l(e):null):(0,s.Gv)(e)?l(e):(0,n.jU)(e)?e:null}function l(e){return Object.getOwnPropertyNames(e).reduce((t,r)=>{let s=e[r];return(0,n.jU)(s)&&(t[r]=s),t},{})}function c(e){return(0,s.Gv)(e)&&(0,s.i5)(e,"cause")&&(0,s.Gv)(e.cause)}o(a.f.rpc.internal)},132076(e,t,r){"use strict";r.d(t,{N:()=>o});var n=r(12796);let s=-1,a=e=>{"hidden"===n.j.document.visibilityState&&s>-1&&(s="visibilitychange"===e.type?e.timeStamp:0,removeEventListener("visibilitychange",a,!0),removeEventListener("prerenderingchange",a,!0))},o=()=>(n.j.document&&s<0&&(s="hidden"!==n.j.document.visibilityState||n.j.document.prerendering?1/0:0,addEventListener("visibilitychange",a,!0),addEventListener("prerenderingchange",a,!0)),{get firstHiddenTime(){return s}})},133481(e,t,r){"use strict";let n,a,o;r.d(t,{i:()=>m});var i=r(25605),l=r(696294),c=r(97407),u=r(12796);function m(e){(0,i.s5)("dom",e),(0,i.AS)("dom",d)}function d(){if(!u.j.document)return;let e=i.aj.bind(null,"dom"),t=p(e,!0);u.j.document.addEventListener("click",t,!1),u.j.document.addEventListener("keypress",t,!1),["EventTarget","Node"].forEach(t=>{let r=u.j[t]&&u.j[t].prototype;r&&r.hasOwnProperty&&r.hasOwnProperty("addEventListener")&&((0,c.GS)(r,"addEventListener",function(t){return function(r,n,s){if("click"===r||"keypress"==r)try{let n=this.__sentry_instrumentation_handlers__=this.__sentry_instrumentation_handlers__||{},a=n[r]=n[r]||{refCount:0};if(!a.handler){let n=p(e);a.handler=n,t.call(this,r,n,s)}a.refCount++}catch(e){}return t.call(this,r,n,s)}}),(0,c.GS)(r,"removeEventListener",function(e){return function(t,r,n){if("click"===t||"keypress"==t)try{let r=this.__sentry_instrumentation_handlers__||{},s=r[t];s&&(s.refCount--,s.refCount<=0&&(e.call(this,t,s.handler,n),s.handler=void 0,delete r[t]),0===Object.keys(r).length&&delete this.__sentry_instrumentation_handlers__)}catch(e){}return e.call(this,t,r,n)}}))})}function p(e,t=!1){return r=>{var i;if(!r||r._sentryCaptured)return;let m=function(e){try{return e.target}catch(e){return null}}(r);if(i=r.type,"keypress"===i&&(!m||!m.tagName||"INPUT"!==m.tagName&&"TEXTAREA"!==m.tagName&&!m.isContentEditable&&1))return;(0,c.my)(r,"_sentryCaptured",!0),m&&!m._sentryId&&(0,c.my)(m,"_sentryId",(0,l.eJ)());let d="keypress"===r.type?"input":r.type;!function(e){if(e.type!==a)return!1;try{if(!e.target||e.target._sentryId!==o)return!1}catch(e){}return!0}(r)&&(e({event:r,name:d,global:t}),a=r.type,o=m?m._sentryId:void 0),s(n),n=u.j.setTimeout(()=>{o=void 0,a=void 0},1e3)}}},136244(e,t,r){"use strict";r.d(t,{o:()=>u});var n=r(16786),s=r(107842),a=r(766221),o=r(586312),i=r(85182),l=r(425535),c=r(67904);function u(e,t,r=(0,a.C)(e.bufferSize||64)){let d={};return{send:function(a){let u=[];if((0,i.yH)(a,(t,r)=>{let n=(0,i.zk)(r);if((0,l.Jz)(d,n)){let s=m(t,r);e.recordDroppedEvent("ratelimit_backoff",n,s)}else u.push(t)}),0===u.length)return(0,o.XW)({});let p=(0,i.h4)(a[0],u),h=t=>{(0,i.yH)(p,(r,n)=>{let s=m(r,n);e.recordDroppedEvent(t,(0,i.zk)(n),s)})};return r.add(()=>t({body:(0,i.bN)(p)}).then(e=>(void 0!==e.statusCode&&(e.statusCode<200||e.statusCode>=300)&&c.T&&s.vF.warn(`Sentry responded with status code ${e.statusCode} to sent event.`),d=(0,l.wq)(d,e),e),e=>{throw h("network_error"),e})).then(e=>e,e=>{if(e instanceof n.U)return c.T&&s.vF.error("Skipped sending event because buffer is full."),h("queue_overflow"),(0,o.XW)({});throw e})},flush:e=>r.drain(e)}}function m(e,t){if("event"===t||"transaction"===t)return Array.isArray(e)?e[1]:void 0}},137891(e,t,r){"use strict";r.d(t,{bD:()=>n,co:()=>s,fN:()=>a,vR:()=>o,yQ:()=>i});let n="c",s="g",a="s",o="d",i=5e3},138706(e,t,r){"use strict";r.d(t,{Z:()=>s});var n=r(37853);let s=(0,r(290264)._C)(()=>{let e=1e3*(0,n.zf)();return{name:"SessionTiming",processEvent(t){let r=1e3*(0,n.zf)();return{...t,extra:{...t.extra,"session:start":e,"session:duration":r-e,"session:end":r}}}}})},140722(e,t,r){"use strict";r.d(t,{w:()=>a});var n=r(696294),s=r(608119);class a{constructor(e={}){this._traceId=e.traceId||(0,n.eJ)(),this._spanId=e.spanId||(0,n.eJ)().substring(16)}spanContext(){return{spanId:this._spanId,traceId:this._traceId,traceFlags:s.CC}}end(e){}setAttribute(e,t){return this}setAttributes(e){return this}setStatus(e){return this}updateName(e){return this}isRecording(){return!1}addEvent(e,t,r){return this}addLink(e){return this}addLinks(e){return this}recordException(e,t){}}},145834(e,t,r){"use strict";r.d(t,{Z:()=>i});var n=r(107842),s=r(67904),a=r(777217),o=r(768881);function i(e,t){let r;if(!(0,a.w)(e))return[!1];r="function"==typeof e.tracesSampler?e.tracesSampler(t):void 0!==t.parentSampled?t.parentSampled:void 0!==e.tracesSampleRate?e.tracesSampleRate:1;let i=(0,o.i)(r);return void 0===i?(s.T&&n.vF.warn("[Tracing] Discarding transaction because of invalid sample rate."),[!1]):i?Math.random()<i?[!0,i]:(s.T&&n.vF.log(`[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = ${Number(r)})`),[!1,i]):(s.T&&n.vF.log(`[Tracing] Discarding transaction because ${"function"==typeof e.tracesSampler?"tracesSampler returned 0 or false":"a negative sampling decision was inherited or tracesSampleRate is set to 0"}`),[!1,i])}},153839(e,t,r){"use strict";r.d(t,{wz:()=>a});var n=r(137891),s=r(837971);let a={[n.bD]:class{constructor(e){this._value=e}get weight(){return 1}add(e){this._value+=e}toString(){return`${this._value}`}},[n.co]:class{constructor(e){this._last=e,this._min=e,this._max=e,this._sum=e,this._count=1}get weight(){return 5}add(e){this._last=e,e<this._min&&(this._min=e),e>this._max&&(this._max=e),this._sum+=e,this._count++}toString(){return`${this._last}:${this._min}:${this._max}:${this._sum}:${this._count}`}},[n.vR]:class{constructor(e){this._value=[e]}get weight(){return this._value.length}add(e){this._value.push(e)}toString(){return this._value.join(":")}},[n.fN]:class{constructor(e){this.first=e,this._value=new Set([e])}get weight(){return this._value.size}add(e){this._value.add(e)}toString(){return Array.from(this._value).map(e=>"string"==typeof e?(0,s.tx)(e):e).join(":")}}}},155682(e,t,r){"use strict";r.d(t,{B:()=>i,J:()=>o});var n=r(107842),s=r(933190),a=r(67904);function o(e,t){!0===t.debug&&(a.T?n.vF.enable():(0,n.pq)(()=>{console.warn("[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.")})),(0,s.o5)().update(t.initialScope);let r=new e(t);return i(r),r.init(),r}function i(e){(0,s.o5)().setClient(e)}},157392(e,t,r){"use strict";r.d(t,{Tl:()=>l,Wu:()=>i,Z6:()=>s});var n,s,a=r(290266),o=r(545203);(n=s||(s={})).Copyable="copyable",n.Divider="divider",n.Heading="heading",n.Panel="panel",n.Spinner="spinner",n.Text="text",n.Image="image",n.Row="row",n.Address="address",n.Button="button",n.Input="input",n.Form="form";let i=(0,a.Ik)({type:(0,a.Yj)()}),l=(0,o.kp)(i,(0,a.Ik)({value:(0,a.L5)()}))},159167(e,t,r){"use strict";r.d(t,{J:()=>a});var n=r(652825),s=r(290266);function a(){return(0,n.YP)((0,s.Yj)(),"SVG",e=>!!e.includes("<svg")||"Value is not a valid SVG.")}},173177(e,t,r){"use strict";r.d(t,{$:()=>o,X:()=>a});var n=r(812863),s=r(608119);function a(e,t,r,o=(0,s.Bk)()){let i=o&&(0,s.zU)(o);i&&i.addEvent(e,{[n.xc]:t,[n.Sn]:r})}function o(e){if(!e||0===e.length)return;let t={};return e.forEach(e=>{let r=e.attributes||{},s=r[n.Sn],a=r[n.xc];"string"==typeof s&&"number"==typeof a&&(t[e.name]={value:a,unit:s})}),t}},179184(e,t,r){"use strict";r.d(t,{LE:()=>i,V7:()=>l,lu:()=>c});var n=r(895315),s=r(85182),a=r(836164),o=r(608119);function i(e,t,r,a){let o=(0,s.Cj)(r),i={sent_at:new Date().toISOString(),...o&&{sdk:o},...!!a&&t&&{dsn:(0,n.SB)(t)}},l="aggregates"in e?[{type:"sessions"},e]:[{type:"session"},e.toJSON()];return(0,s.h4)(i,[l])}function l(e,t,r,n){var a;let o=(0,s.Cj)(r),i=e.type&&"replay_event"!==e.type?e.type:"event";(a=r&&r.sdk)&&(e.sdk=e.sdk||{},e.sdk.name=e.sdk.name||a.name,e.sdk.version=e.sdk.version||a.version,e.sdk.integrations=[...e.sdk.integrations||[],...a.integrations||[]],e.sdk.packages=[...e.sdk.packages||[],...a.packages||[]]);let l=(0,s.n2)(e,o,n,t);delete e.sdkProcessingMetadata;let c=[{type:i},e];return(0,s.h4)(l,[c])}function c(e,t){let r=(0,a.k1)(e[0]),i=t&&t.getDsn(),l=t&&t.getOptions().tunnel,c={sent_at:new Date().toISOString(),...!!r.trace_id&&!!r.public_key&&{trace:r},...!!l&&i&&{dsn:(0,n.SB)(i)}},u=t&&t.getOptions().beforeSendSpan,m=u?e=>u((0,o.et)(e)):e=>(0,o.et)(e),d=[];for(let t of e){let e=m(t);e&&d.push((0,s.y5)(e))}return(0,s.h4)(c,d)}},179329(e,t,r){"use strict";function n(e){if(void 0!==e)return e>=400&&e<500?"warning":e>=500?"error":void 0}r.d(t,{X:()=>n})},184748(e,t,r){"use strict";r.d(t,{b:()=>s});var n=r(303818);let s=()=>{let e=(0,n.z)();return e&&e.activationStart||0}},185335(e,t,r){"use strict";r.d(t,{C:()=>d});var s=r(12796),a=r(956742),o=r(184748),i=r(303818),l=r(495242),c=r(681747);let u=[800,1800],m=e=>{s.j.document&&s.j.document.prerendering?(0,c.I)(()=>m(e)):s.j.document&&"complete"!==s.j.document.readyState?addEventListener("load",()=>m(e),!0):n(e,0)},d=(e,t={})=>{let r=(0,l.X)("TTFB"),n=(0,a.R)(e,r,u,t.reportAllChanges);m(()=>{let e=(0,i.z)();if(e){let t=e.responseStart;if(t<=0||t>performance.now())return;r.value=Math.max(t-(0,o.b)(),0),r.entries=[e],n(!0)}})}},185746(e,t,r){"use strict";r.d(t,{B:()=>g,Z:()=>h});var n=r(834529),s=r(812863),a=r(933190),o=r(608119),i=r(834028),l=r(97407),c=r(37853),u=r(932294),m=r(858586);let d=[],p=new Map;function h(){if((0,m.D)()&&c.k3){let e=(0,u.hT)(({metric:e})=>{if(void 0==e.value)return;let t=e.entries.find(t=>t.duration===e.value&&f[t.name]);if(!t)return;let{interactionId:r}=t,u=f[t.name],d=(0,m.rv)(c.k3+t.startTime),h=(0,m.rv)(e.value),g=(0,o.Bk)(),y=g?(0,o.zU)(g):void 0,b=(null!=r?p.get(r):void 0)||y,k=b?(0,o.et)(b).description:(0,a.o5)().getScopeData().transactionName,v=(0,i.Hd)(t.target),_=(0,l.Ce)({[s.JD]:"auto.http.browser.inp",[s.uT]:`ui.interaction.${u}`,[s.jG]:t.duration}),w=(0,m.kD)({name:v,transaction:k,attributes:_,startTime:d});(0,n.z)([w,"optionalAccess",e=>e.addEvent,"call",t=>t("inp",{[s.Sn]:"millisecond",[s.xc]:e.value})]),(0,n.z)([w,"optionalAccess",e=>e.end,"call",e=>e(d+h)])});return()=>{e()}}return()=>void 0}let f={click:"click",pointerdown:"click",pointerup:"click",mousedown:"click",mouseup:"click",touchstart:"click",touchend:"click",mouseover:"hover",mouseout:"hover",mouseenter:"hover",mouseleave:"hover",pointerover:"hover",pointerout:"hover",pointerenter:"hover",pointerleave:"hover",dragstart:"drag",dragend:"drag",drag:"drag",dragenter:"drag",dragleave:"drag",dragover:"drag",drop:"drag",keydown:"press",keyup:"press",keypress:"press",input:"press"};function g(e){let t=({entries:e})=>{let t=(0,o.Bk)(),r=t&&(0,o.zU)(t);e.forEach(e=>{if(!(0,u.tC)(e)||!r)return;let t=e.interactionId;if(null!=t&&!p.has(t)){if(d.length>10){let e=d.shift();p.delete(e)}d.push(t),p.set(t,r)}})};(0,u.wv)("event",t),(0,u.wv)("first-input",t)}},187763(e,t,r){"use strict";function n(e,...t){let r=new String(String.raw(e,...t));return r.__sentry_template_string__=e.join("\0").replace(/%/g,"%%").replace(/\0/g,"%s"),r.__sentry_template_values__=t,r}r.d(t,{y:()=>n})},191895(e,t,r){"use strict";r.d(t,{Gr:()=>o,KT:()=>i});var n=r(230337);let s=new Map,a=new Set;function o(e,t){try{t.exception.values.forEach(t=>{if(t.stacktrace)for(let r of t.stacktrace.frames||[]){if(!r.filename||r.module_metadata)continue;let t=function(e,t){if(n.O._sentryModuleMetadata)for(let t of Object.keys(n.O._sentryModuleMetadata)){let r=n.O._sentryModuleMetadata[t];if(!a.has(t)){for(let n of(a.add(t),e(t).reverse()))if(n.filename){s.set(n.filename,r);break}}}return s.get(t)}(e,r.filename);t&&(r.module_metadata=t)}})}catch(e){}}function i(e){try{e.exception.values.forEach(e=>{if(e.stacktrace)for(let t of e.stacktrace.frames||[])delete t.module_metadata})}catch(e){}}},192279(e,t,r){"use strict";r.d(t,{K:()=>s});var n=r(538600);function s(e,t,r=[t],a="npm"){let o=e._metadata||{};o.sdk||(o.sdk={name:`sentry.javascript.${t}`,packages:r.map(e=>({name:`${a}:@sentry/${e}`,version:n.M})),version:n.M}),e._metadata=o}},197434(e,t,r){"use strict";r.r(t);var n=r(482903);globalThis.stateHooks=globalThis.stateHooks||{},globalThis.sentry=(0,n.Ay)()},198066(e,t,r){"use strict";r.d(t,{q:()=>o,r:()=>a});var n=r(230337),s=r(973234);function a(){return(0,n.B)("defaultCurrentScope",()=>new s.H)}function o(){return(0,n.B)("defaultIsolationScope",()=>new s.H)}},208570(e,t,r){"use strict";r.d(t,{Ci:()=>l,DJ:()=>y,US:()=>o,fw:()=>v,mx:()=>u,qH:()=>f,s$:()=>s,s7:()=>i,tz:()=>g,us:()=>m,xS:()=>k,zH:()=>b}),r(951906),r(316244);let n=["January","February","March","April","May","June","July","August","September","October","November","December"],s=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],a=["J","F","M","A","M","J","J","A","S","O","N","D"];function o(e){switch(e){case"narrow":return[...a];case"short":return[...s];case"long":return[...n];case"numeric":return["1","2","3","4","5","6","7","8","9","10","11","12"];case"2-digit":return["01","02","03","04","05","06","07","08","09","10","11","12"];default:return null}}let i=["Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"],l=["Mon","Tue","Wed","Thu","Fri","Sat","Sun"],c=["M","T","W","T","F","S","S"];function u(e){switch(e){case"narrow":return[...c];case"short":return[...l];case"long":return[...i];case"numeric":return["1","2","3","4","5","6","7"];default:return null}}let m=["AM","PM"],d=["Before Christ","Anno Domini"],p=["BC","AD"],h=["B","A"];function f(e){switch(e){case"narrow":return[...h];case"short":return[...p];case"long":return[...d];default:return null}}function g(e){return m[e.hour<12?0:1]}function y(e,t){return u(t)[e.weekday-1]}function b(e,t){return o(t)[e.month-1]}function k(e,t){return f(t)[e.year<0?0:1]}function v(e,t,r="always",n=!1){let s={years:["year","yr."],quarters:["quarter","qtr."],months:["month","mo."],weeks:["week","wk."],days:["day","day","days"],hours:["hour","hr."],minutes:["minute","min."],seconds:["second","sec."]},a=-1===["hours","minutes","seconds"].indexOf(e);if("auto"===r&&a){let r="days"===e;switch(t){case 1:return r?"tomorrow":`next ${s[e][0]}`;case -1:return r?"yesterday":`last ${s[e][0]}`;case 0:return r?"today":`this ${s[e][0]}`}}let o=Object.is(t,-0)||t<0,i=Math.abs(t),l=1===i,c=s[e],u=n?l?c[1]:c[2]||c[1]:l?s[e][0]:e;return o?`${i} ${u} ago`:`in ${i} ${u}`}},208835(e){var t,r,a,o=e.exports={};function i(){throw Error("setTimeout has not been defined")}function l(){throw Error("clearTimeout has not been defined")}try{t="function"==typeof n?n:i}catch(e){t=i}try{r="function"==typeof s?s:l}catch(e){r=l}function c(e){if(t===n)return n(e,0);if((t===i||!t)&&n)return t=n,n(e,0);try{return t(e,0)}catch(r){try{return t.call(null,e,0)}catch(r){return t.call(this,e,0)}}}var u=[],m=!1,d=-1;function p(){m&&a&&(m=!1,a.length?u=a.concat(u):d=-1,u.length&&h())}function h(){if(!m){var e=c(p);m=!0;for(var t=u.length;t;){for(a=u,u=[];++d<t;)a&&a[d].run();d=-1,t=u.length}a=null,m=!1,function(e){if(r===s)return s(e);if((r===l||!r)&&s)return r=s,s(e);try{r(e)}catch(t){try{return r.call(null,e)}catch(t){return r.call(this,e)}}}(e)}}function f(e,t){this.fun=e,this.array=t}function g(){}o.nextTick=function(e){var t=Array(arguments.length-1);if(arguments.length>1)for(var r=1;r<arguments.length;r++)t[r-1]=arguments[r];u.push(new f(e,t)),1!==u.length||m||c(h)},f.prototype.run=function(){this.fun.apply(null,this.array)},o.title="browser",o.browser=!0,o.env={},o.argv=[],o.version="",o.versions={},o.on=g,o.addListener=g,o.once=g,o.off=g,o.removeListener=g,o.removeAllListeners=g,o.emit=g,o.prependListener=g,o.prependOnceListener=g,o.listeners=function(e){return[]},o.binding=function(e){throw Error("process.binding is not supported")},o.cwd=function(){return"/"},o.chdir=function(e){throw Error("process.chdir is not supported")},o.umask=function(){return 0}},216295(e,t,r){"use strict";r.d(t,{z9:()=>c});var n=r(903226),s=r(85182),a=r(47810);function o(e){return new Promise((t,r)=>{e.oncomplete=e.onsuccess=()=>t(e.result),e.onabort=e.onerror=()=>r(e.error)})}function i(e){return o(e.getAllKeys())}function l(e){let t;function r(){return void 0==t&&(t=function(e,t){let r=indexedDB.open(e);r.onupgradeneeded=()=>r.result.createObjectStore(t);let n=o(r);return e=>n.then(r=>e(r.transaction(t,"readwrite").objectStore(t)))}(e.dbName||"sentry-offline",e.storeName||"queue")),t}return{push:async t=>{try{var n,a;let l=await (0,s.bN)(t);await (n=r(),a=e.maxQueueSize||30,n(e=>i(e).then(t=>{if(!(t.length>=a))return e.put(l,Math.max(...t,0)+1),o(e.transaction)})))}catch(e){}},unshift:async t=>{try{var n,a;let l=await (0,s.bN)(t);await (n=r(),a=e.maxQueueSize||30,n(e=>i(e).then(t=>{if(!(t.length>=a))return e.put(l,Math.min(...t,0)-1),o(e.transaction)})))}catch(e){}},shift:async()=>{try{let e=await r()(e=>i(e).then(t=>{let r=t[0];if(null!=r)return o(e.get(r)).then(t=>(e.delete(r),o(e.transaction).then(()=>t)))}));if(e)return(0,s.mE)(e)}catch(e){}}}}function c(e=a._){var t;return t=(0,n.BP)(e),e=>t({...e,createStore:l})}},217768(e,t,r){"use strict";r.d(t,{dI:()=>a});var n=r(434878),s=r(530953);let a={ADMIN:"admin",DEVELOPMENT:"development",NORMAL:"normal",SIDELOAD:"sideload",OTHER:"other",UNKNOWN:"unknown"},o={ADD_ETHEREUM_CHAIN:"wallet_addEthereumChain",ETH_ACCOUNTS:s.wq.eth_accounts,ETH_DECRYPT:"eth_decrypt",ETH_CHAIN_ID:"eth_chainId",ETH_GET_ENCRYPTION_PUBLIC_KEY:"eth_getEncryptionPublicKey",ETH_GET_BLOCK_BY_NUMBER:"eth_getBlockByNumber",ETH_REQUEST_ACCOUNTS:"eth_requestAccounts",ETH_SEND_TRANSACTION:"eth_sendTransaction",ETH_SEND_RAW_TRANSACTION:"eth_sendRawTransaction",ETH_SIGN_TRANSACTION:"eth_signTransaction",ETH_SIGN_TYPED_DATA:"eth_signTypedData",ETH_SIGN_TYPED_DATA_V1:"eth_signTypedData_v1",ETH_SIGN_TYPED_DATA_V3:"eth_signTypedData_v3",ETH_SIGN_TYPED_DATA_V4:"eth_signTypedData_v4",GET_PROVIDER_STATE:"metamask_getProviderState",LOG_WEB3_SHIM_USAGE:"metamask_logWeb3ShimUsage",PERSONAL_SIGN:"personal_sign",SEND_METADATA:"metamask_sendDomainMetadata",SWITCH_ETHEREUM_CHAIN:"wallet_switchEthereumChain",TRANSACTION:"transaction",WALLET_CREATE_SESSION:"wallet_createSession",WALLET_GET_CALLS_STATUS:"wallet_getCallsStatus",WALLET_GET_CAPABILITIES:"wallet_getCapabilities",WALLET_GET_SESSION:"wallet_getSession",WALLET_INVOKE_METHOD:"wallet_invokeMethod",WALLET_REQUEST_PERMISSIONS:"wallet_requestPermissions",WALLET_REVOKE_SESSION:"wallet_revokeSession",WALLET_SEND_CALLS:"wallet_sendCalls",WALLET_SESSION_CHANGED:"wallet_sessionChanged",WALLET_REQUEST_EXECUTION_PERMISSIONS:"wallet_requestExecutionPermissions",WALLET_GET_SUPPORTED_EXECUTION_PERMISSIONS:"wallet_getSupportedExecutionPermissions",WALLET_GET_GRANTED_EXECUTION_PERMISSIONS:"wallet_getGrantedExecutionPermissions",WATCH_ASSET:"wallet_watchAsset",WATCH_ASSET_LEGACY:"metamask_watchAsset",SNAP_DIALOG_ALERT:n.rW.alert,SNAP_DIALOG_CONFIRMATION:n.rW.confirmation,SNAP_DIALOG_PROMPT:n.rW.prompt,SNAP_DIALOG_DEFAULT:n.rW.default,HYPERLIQUID_REFERRAL_CONSENT:"hyperliquid_referral_consent",ASTERDEX_REFERRAL_CONSENT:"asterdex_referral_consent",GMX_REFERRAL_CONSENT:"gmx_referral_consent"};o.HYPERLIQUID_REFERRAL_CONSENT,o.ASTERDEX_REFERRAL_CONSENT,o.GMX_REFERRAL_CONSENT,o.ETH_SIGN_TYPED_DATA,o.ETH_SIGN_TYPED_DATA_V1,o.ETH_SIGN_TYPED_DATA_V3,o.ETH_SIGN_TYPED_DATA_V4,o.PERSONAL_SIGN},224245(e,t,r){"use strict";r.d(t,{X:()=>a});var n=r(666012),s=r(360023);let a=(0,n.aD)({lazyLoadIntegration:s.b,getModalIntegration:()=>n.j0,getScreenshotIntegration:()=>n.U$})},225669(e,t,r){"use strict";let n;r.d(t,{_:()=>l});var s=r(25605),a=r(97407),o=r(648017),i=r(12796);function l(e){let t="history";(0,s.s5)(t,e),(0,s.AS)(t,c)}function c(){if(!(0,o.N)())return;let e=i.j.onpopstate;function t(e){return function(...t){let r=t.length>2?t[2]:void 0;if(r){let e=n,t=String(r);n=t,(0,s.aj)("history",{from:e,to:t})}return e.apply(this,t)}}i.j.onpopstate=function(...t){let r=i.j.location.href,a=n;if(n=r,(0,s.aj)("history",{from:a,to:r}),e)try{return e.apply(this,t)}catch(e){}},(0,a.GS)(i.j.history,"pushState",t),(0,a.GS)(i.j.history,"replaceState",t)}},230337(e,t,r){"use strict";r.d(t,{B:()=>a,O:()=>s});var n=r(538600);let s=globalThis;function a(e,t,r){let a=r||s,o=a.__SENTRY__=a.__SENTRY__||{},i=o[n.M]=o[n.M]||{};return i[e]||(i[e]=t())}},234598(e,t,r){"use strict";let n,s;r.d(t,{DI:()=>j,QU:()=>T,U$:()=>E,bk:()=>x,c8:()=>S});var a=r(16686),o=r(173177),i=r(812863),l=r(608119),c=r(834028),u=r(107842),m=r(37853),d=r(830339),p=r(756025),h=r(12796),f=r(117529),g=r(932294),y=r(858586),b=r(184748),k=r(303818),v=r(132076);let _=0,w={};function x({recordClsStandaloneSpans:e}){let t=(0,y.D)();if(t&&m.k3){t.mark&&h.j.performance.mark("sentry-tracing-init");let r=(0,g.T5)(({metric:e})=>{let t=e.entries[e.entries.length-1];if(!t)return;let r=(0,y.rv)(m.k3),n=(0,y.rv)(t.startTime);p.T&&u.vF.log("[Measurements] Adding FID"),w.fid={value:e.value,unit:"millisecond"},w["mark.fid"]={value:r+n,unit:"second"}}),a=(0,g.Pt)(({metric:e})=>{let t=e.entries[e.entries.length-1];t&&(p.T&&u.vF.log("[Measurements] Adding LCP"),w.lcp={value:e.value,unit:"millisecond"},n=t)},!0),o=(0,g.YG)(({metric:e})=>{e.entries[e.entries.length-1]&&(p.T&&u.vF.log("[Measurements] Adding TTFB"),w.ttfb={value:e.value,unit:"millisecond"})}),i=e?(0,f.D)():(0,g.a9)(({metric:e})=>{let t=e.entries[e.entries.length-1];t&&(p.T&&u.vF.log(`[Measurements] Adding CLS ${e.value}`),w.cls={value:e.value,unit:""},s=t)},!0);return()=>{r(),a(),o(),i&&i()}}return()=>void 0}function S(){(0,g.wv)("longtask",({entries:e})=>{if((0,l.Bk)())for(let t of e){let e=(0,y.rv)(m.k3+t.startTime),r=(0,y.rv)(t.duration),n=(0,a.Uk)({name:"Main UI thread blocked",op:"ui.long-task",startTime:e,attributes:{[i.JD]:"auto.ui.browser.metrics"}});n&&n.end(e+r)}})}function E(){new PerformanceObserver(e=>{if((0,l.Bk)())for(let t of e.getEntries()){if(!t.scripts[0])continue;let e=(0,y.rv)(m.k3+t.startTime),r=(0,y.rv)(t.duration),n={[i.JD]:"auto.ui.browser.metrics"},{invoker:s,invokerType:o,sourceURL:l,sourceFunctionName:c,sourceCharPosition:u}=t.scripts[0];n["browser.script.invoker"]=s,n["browser.script.invoker_type"]=o,l&&(n["code.filepath"]=l),c&&(n["code.function"]=c),-1!==u&&(n["browser.script.source_char_position"]=u);let d=(0,a.Uk)({name:"Main UI thread blocked",op:"ui.long-animation-frame",startTime:e,attributes:n});d&&d.end(e+r)}}).observe({type:"long-animation-frame",buffered:!0})}function j(){(0,g.wv)("event",({entries:e})=>{if((0,l.Bk)()){for(let t of e)if("click"===t.name){let e=(0,y.rv)(m.k3+t.startTime),r=(0,y.rv)(t.duration),n={name:(0,c.Hd)(t.target),op:`ui.interaction.${t.name}`,startTime:e,attributes:{[i.JD]:"auto.ui.browser.metrics"}},s=(0,c.xE)(t.target);s&&(n.attributes["ui.component_name"]=s);let o=(0,a.Uk)(n);o&&o.end(e+r)}}})}function T(e,t){let r=(0,y.D)();if(!r||!h.j.performance.getEntries||!m.k3)return;p.T&&u.vF.log("[Tracing] Adding & adjusting spans using Performance API");let a=(0,y.rv)(m.k3),f=r.getEntries(),{op:g,start_timestamp:x}=(0,l.et)(e);if(f.slice(_).forEach(t=>{let r=(0,y.rv)(t.startTime),n=(0,y.rv)(Math.max(0,t.duration));if("navigation"!==g||!x||!(a+r<x))switch(t.entryType){case"navigation":var s,o,l;s=e,o=t,l=a,["unloadEvent","redirect","domContentLoadedEvent","loadEvent","connect"].forEach(e=>{A(s,o,e,l)}),A(s,o,"secureConnection",l,"TLS/SSL","connectEnd"),A(s,o,"fetch",l,"cache","domainLookupStart"),A(s,o,"domainLookup",l,"DNS"),function(e,t,r){let n=r+(0,y.rv)(t.requestStart),s=r+(0,y.rv)(t.responseEnd),a=r+(0,y.rv)(t.responseStart);t.responseEnd&&((0,y.Tn)(e,n,s,{op:"browser.request",name:t.name,attributes:{[i.JD]:"auto.ui.browser.metrics"}}),(0,y.Tn)(e,a,s,{op:"browser.response",name:t.name,attributes:{[i.JD]:"auto.ui.browser.metrics"}}))}(s,o,l);break;case"mark":case"paint":case"measure":{var c=e,m=t,f=r,b=n,_=a;let s=(0,k.z)(),o=_+Math.max(f,(0,y.rv)(s?s.requestStart:0)),l=_+f,d={[i.JD]:"auto.resource.browser.metrics"};o!==l&&(d["sentry.browser.measure_happened_before_request"]=!0,d["sentry.browser.measure_start_time"]=o),(0,y.Tn)(c,o,l+b,{name:m.name,op:m.entryType,attributes:d});let h=(0,v.N)(),g=t.startTime<h.firstHiddenTime;"first-paint"===t.name&&g&&(p.T&&u.vF.log("[Measurements] Adding FP"),w.fp={value:t.startTime,unit:"millisecond"}),"first-contentful-paint"===t.name&&g&&(p.T&&u.vF.log("[Measurements] Adding FCP"),w.fcp={value:t.startTime,unit:"millisecond"});break}case"resource":!function(e,t,r,n,s,a){if("xmlhttprequest"===t.initiatorType||"fetch"===t.initiatorType)return;let o=(0,d.Dl)(r),l={[i.JD]:"auto.resource.browser.metrics"};C(l,t,"transferSize","http.response_transfer_size"),C(l,t,"encodedBodySize","http.response_content_length"),C(l,t,"decodedBodySize","http.decoded_response_content_length"),"renderBlockingStatus"in t&&(l["resource.render_blocking_status"]=t.renderBlockingStatus),o.protocol&&(l["url.scheme"]=o.protocol.split(":").pop()),o.host&&(l["server.address"]=o.host),l["url.same_origin"]=r.includes(h.j.location.origin);let c=a+n;(0,y.Tn)(e,c,c+s,{name:r.replace(h.j.location.origin,""),op:t.initiatorType?`resource.${t.initiatorType}`:"resource.other",attributes:l})}(e,t,t.name,r,n,a)}}),_=Math.max(f.length-1,0),function(e){let t=h.j.navigator;if(!t)return;let r=t.connection;r&&(r.effectiveType&&e.setAttribute("effectiveConnectionType",r.effectiveType),r.type&&e.setAttribute("connectionType",r.type),(0,y.Kk)(r.rtt)&&(w["connection.rtt"]={value:r.rtt,unit:"millisecond"})),(0,y.Kk)(t.deviceMemory)&&e.setAttribute("deviceMemory",`${t.deviceMemory} GB`),(0,y.Kk)(t.hardwareConcurrency)&&e.setAttribute("hardwareConcurrency",String(t.hardwareConcurrency))}(e),"pageload"===g){var S;!function(e){let t=(0,k.z)();if(!t)return;let{responseStart:r,requestStart:n}=t;n<=r&&(p.T&&u.vF.log("[Measurements] Adding TTFB Request Time"),e["ttfb.requestTime"]={value:r-n,unit:"millisecond"})}(w);let r=w["mark.fid"];r&&w.fid&&((0,y.Tn)(e,r.value,r.value+(0,y.rv)(w.fid.value),{name:"first input delay",op:"ui.action",attributes:{[i.JD]:"auto.ui.browser.metrics"}}),delete w["mark.fid"]),"fcp"in w&&t.recordClsOnPageloadSpan||delete w.cls,Object.entries(w).forEach(([e,t])=>{(0,o.X)(e,t.value,t.unit)}),e.setAttribute("performance.timeOrigin",a),e.setAttribute("performance.activationStart",(0,b.b)()),S=e,n&&(p.T&&u.vF.log("[Measurements] Adding LCP Data"),n.element&&S.setAttribute("lcp.element",(0,c.Hd)(n.element)),n.id&&S.setAttribute("lcp.id",n.id),n.url&&S.setAttribute("lcp.url",n.url.trim().slice(0,200)),S.setAttribute("lcp.size",n.size)),s&&s.sources&&(p.T&&u.vF.log("[Measurements] Adding CLS Data"),s.sources.forEach((e,t)=>S.setAttribute(`cls.source.${t+1}`,(0,c.Hd)(e.node))))}n=void 0,s=void 0,w={}}function A(e,t,r,n,s,a){let o=a?t[a]:t[`${r}End`],l=t[`${r}Start`];l&&o&&(0,y.Tn)(e,n+(0,y.rv)(l),n+(0,y.rv)(o),{op:`browser.${s||r}`,name:t.name,attributes:{[i.JD]:"auto.ui.browser.metrics"}})}function C(e,t,r,n){let s=t[r];null!=s&&s<0x7fffffff&&(e[n]=s)}},254660(e){function t(e,t,r,n){return Math.round(e/r)+" "+n+(t>=1.5*r?"s":"")}e.exports=function(e,r){r=r||{};var n,s,a,o,i=typeof e;if("string"===i&&e.length>0){var l=e;if(!((l=String(l)).length>100)){var c=/^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(l);if(c){var u=parseFloat(c[1]);switch((c[2]||"ms").toLowerCase()){case"years":case"year":case"yrs":case"yr":case"y":return 315576e5*u;case"weeks":case"week":case"w":return 6048e5*u;case"days":case"day":case"d":return 864e5*u;case"hours":case"hour":case"hrs":case"hr":case"h":return 36e5*u;case"minutes":case"minute":case"mins":case"min":case"m":return 6e4*u;case"seconds":case"second":case"secs":case"sec":case"s":return 1e3*u;case"milliseconds":case"millisecond":case"msecs":case"msec":case"ms":return u;default:break}}}return}if("number"===i&&isFinite(e)){return r.long?(s=Math.abs(n=e))>=864e5?t(n,s,864e5,"day"):s>=36e5?t(n,s,36e5,"hour"):s>=6e4?t(n,s,6e4,"minute"):s>=1e3?t(n,s,1e3,"second"):n+" ms":(o=Math.abs(a=e))>=864e5?Math.round(a/864e5)+"d":o>=36e5?Math.round(a/36e5)+"h":o>=6e4?Math.round(a/6e4)+"m":o>=1e3?Math.round(a/1e3)+"s":a+"ms"}throw Error("val is not a non-empty string or a valid number. val="+JSON.stringify(e))}},254759(e,t,r){"use strict";r.d(t,{s:()=>i});var n=r(107842),s=r(680985),a=r(290264),o=r(67904);let i=(0,a._C)(()=>{let e;return{name:"Dedupe",processEvent(t){if(t.type)return t;try{var r,s;if(r=t,(s=e)&&(function(e,t){let r=e.message,n=t.message;return(!!r||!!n)&&(!r||!!n)&&(!!r||!n)&&r===n&&!!c(e,t)&&!!l(e,t)&&!0}(r,s)||function(e,t){let r=u(t),n=u(e);return!!r&&!!n&&r.type===n.type&&r.value===n.value&&!!c(e,t)&&!!l(e,t)}(r,s)))return o.T&&n.vF.warn("Event dropped due to being a duplicate of previously captured event."),null}catch(e){}return e=t}}});function l(e,t){let r=(0,s.RV)(e),n=(0,s.RV)(t);if(!r&&!n)return!0;if(r&&!n||!r&&n||n.length!==r.length)return!1;for(let e=0;e<n.length;e++){let t=n[e],s=r[e];if(t.filename!==s.filename||t.lineno!==s.lineno||t.colno!==s.colno||t.function!==s.function)return!1}return!0}function c(e,t){let r=e.fingerprint,n=t.fingerprint;if(!r&&!n)return!0;if(r&&!n||!r&&n)return!1;try{return r.join("")===n.join("")}catch(e){return!1}}function u(e){return e.exception&&e.exception.values&&e.exception.values[0]}},254995(e,t,r){"use strict";r.d(t,{H:()=>l});var n=r(982944),s=r(448967),a=r(652825),o=r(290266),i=r(879516);let l=(e={})=>(0,a.YP)((0,o.Yj)(),"uri",t=>{try{let r=new URL(t),n=(0,o.NW)(e);return(0,s.vA)(r,n),!0}catch(e){if(e instanceof n.C)return(0,i.u1)(e);return`Expected URL, got "${t.toString()}"`}})},258862(e,t,r){"use strict";r.d(t,{X:()=>a,u:()=>s});let n=r(952574)("metamask");function s(e){return n.extend(e)}function a(e,t){return e.extend(t)}},259463(e,t,r){"use strict";r.d(t,{Q:()=>s});var n=r(12796);let s=e=>{let t=t=>{("pagehide"===t.type||n.j.document&&"hidden"===n.j.document.visibilityState)&&e(t)};n.j.document&&(addEventListener("visibilitychange",t,!0),addEventListener("pagehide",t,!0))}},263496(e,t,r){"use strict";r.d(t,{GR:()=>x,Z7:()=>E,np:()=>_,ws:()=>S,zb:()=>w});var n=r(316244),s=r(925752),a=r(794204),o=r(831022),i=r(347022),l=r(938102),c=r(961520);function u(e,t=e=>e){return{regex:e,deser:([e])=>t((0,l.o_)(e))}}let m=String.fromCharCode(160),d=`[ ${m}]`,p=RegExp(d,"g");function h(e){return e.replace(/\./g,"\\.?").replace(p,d)}function f(e){return e.replace(/\./g,"").replace(p," ").toLowerCase()}function g(e,t){return null===e?null:{regex:RegExp(e.map(h).join("|")),deser:([r])=>e.findIndex(e=>f(r)===f(e))+t}}function y(e,t){return{regex:e,deser:([,e,t])=>(0,n.gu)(e,t),groups:t}}function b(e){return{regex:e,deser:([e])=>e}}let k={year:{"2-digit":"yy",numeric:"yyyyy"},month:{numeric:"M","2-digit":"MM",short:"MMM",long:"MMMM"},day:{numeric:"d","2-digit":"dd"},weekday:{short:"EEE",long:"EEEE"},dayperiod:"a",dayPeriod:"a",hour12:{numeric:"h","2-digit":"hh"},hour24:{numeric:"H","2-digit":"HH"},minute:{numeric:"m","2-digit":"mm"},second:{numeric:"s","2-digit":"ss"},timeZoneName:{long:"ZZZZZ",short:"ZZZ"}},v=null;function _(e,t){return Array.prototype.concat(...e.map(e=>(function(e,t){if(e.literal)return e;let r=E(s.A.macroTokenToFormatOpts(e.val),t);return null==r||r.includes(void 0)?e:r})(e,t)))}class w{constructor(e,t){if(this.locale=e,this.format=t,this.tokens=_(s.A.parseFormat(t),e),this.units=this.tokens.map(t=>(function(e,t){let r=(0,l.dO)(t),s=(0,l.dO)(t,"{2}"),a=(0,l.dO)(t,"{3}"),o=(0,l.dO)(t,"{4}"),i=(0,l.dO)(t,"{6}"),c=(0,l.dO)(t,"{1,2}"),m=(0,l.dO)(t,"{1,3}"),d=(0,l.dO)(t,"{1,6}"),p=(0,l.dO)(t,"{1,9}"),h=(0,l.dO)(t,"{2,4}"),f=(0,l.dO)(t,"{4,6}"),k=e=>({regex:RegExp(e.val.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g,"\\$&")),deser:([e])=>e,literal:!0}),v=(l=>{if(e.literal)return k(l);switch(l.val){case"G":return g(t.eras("short"),0);case"GG":return g(t.eras("long"),0);case"y":return u(d);case"yy":case"kk":return u(h,n.fT);case"yyyy":case"kkkk":return u(o);case"yyyyy":return u(f);case"yyyyyy":return u(i);case"M":case"L":case"d":case"H":case"h":case"m":case"q":case"s":case"W":return u(c);case"MM":case"LL":case"dd":case"HH":case"hh":case"mm":case"qq":case"ss":case"WW":return u(s);case"MMM":return g(t.months("short",!0),1);case"MMMM":return g(t.months("long",!0),1);case"LLL":return g(t.months("short",!1),1);case"LLLL":return g(t.months("long",!1),1);case"o":case"S":return u(m);case"ooo":case"SSS":return u(a);case"u":return b(p);case"uu":return b(c);case"uuu":case"E":case"c":return u(r);case"a":return g(t.meridiems(),0);case"EEE":return g(t.weekdays("short",!1),1);case"EEEE":return g(t.weekdays("long",!1),1);case"ccc":return g(t.weekdays("short",!0),1);case"cccc":return g(t.weekdays("long",!0),1);case"Z":case"ZZ":return y(RegExp(`([+-]${c.source})(?::(${s.source}))?`),2);case"ZZZ":return y(RegExp(`([+-]${c.source})(${s.source})?`),2);case"z":return b(/[a-z_+-/]{1,256}?/i);case" ":return b(/[^\S\n\r]/);default:return k(l)}})(e)||{invalidReason:"missing Intl.DateTimeFormat.formatToParts support"};return v.token=e,v})(t,e)),this.disqualifyingUnit=this.units.find(e=>e.invalidReason),!this.disqualifyingUnit){let[e,t]=function(e){let t=e.map(e=>e.regex).reduce((e,t)=>`${e}(${t.source})`,"");return[`^${t}$`,e]}(this.units);this.regex=RegExp(e,"i"),this.handlers=t}}explainFromTokens(e){if(!this.isValid)return{input:e,tokens:this.tokens,invalidReason:this.invalidReason};{let t,r,[s,i]=function(e,t,r){let s=e.match(t);if(!s)return[s,{}];{let e={},t=1;for(let a in r)if((0,n.mQ)(r,a)){let n=r[a],o=n.groups?n.groups+1:1;!n.literal&&n.token&&(e[n.token.val[0]]=n.deser(s.slice(t,t+o))),t+=o}return[s,e]}}(e,this.regex,this.handlers),[l,u,m]=i?(r=null,(0,n.b0)(i.z)||(r=o.A.create(i.z)),(0,n.b0)(i.Z)||(r||(r=new a.A(i.Z)),t=i.Z),(0,n.b0)(i.q)||(i.M=(i.q-1)*3+1),(0,n.b0)(i.h)||(i.h<12&&1===i.a?i.h+=12:12===i.h&&0===i.a&&(i.h=0)),0===i.G&&i.y&&(i.y=-i.y),(0,n.b0)(i.u)||(i.S=(0,n.m3)(i.u)),[Object.keys(i).reduce((e,t)=>{let r=(e=>{switch(e){case"S":return"millisecond";case"s":return"second";case"m":return"minute";case"h":case"H":return"hour";case"d":return"day";case"o":return"ordinal";case"L":case"M":return"month";case"y":return"year";case"E":case"c":return"weekday";case"W":return"weekNumber";case"k":return"weekYear";case"q":return"quarter";default:return null}})(t);return r&&(e[r]=i[t]),e},{}),r,t]):[null,null,void 0];if((0,n.mQ)(i,"a")&&(0,n.mQ)(i,"H"))throw new c.gN("Can't include meridiem when specifying 24-hour format");return{input:e,tokens:this.tokens,regex:this.regex,rawMatches:s,matches:i,result:l,zone:u,specificOffset:m}}}get isValid(){return!this.disqualifyingUnit}get invalidReason(){return this.disqualifyingUnit?this.disqualifyingUnit.invalidReason:null}}function x(e,t,r){return new w(e,r).explainFromTokens(t)}function S(e,t,r){let{result:n,zone:s,specificOffset:a,invalidReason:o}=x(e,t,r);return[n,s,a,o]}function E(e,t){if(!e)return null;let r=s.A.create(t,e).dtFormatter((v||(v=i.A.fromMillis(0x16a2e5618e3)),v)),n=r.formatToParts(),a=r.resolvedOptions();return n.map(t=>(function(e,t,r){let{type:n,value:s}=e;if("literal"===n){let e=/^\s+$/.test(s);return{literal:!e,val:e?" ":s}}let a=t[n],o=n;"hour"===n&&(o=null!=t.hour12?t.hour12?"hour12":"hour24":null!=t.hourCycle?"h11"===t.hourCycle||"h12"===t.hourCycle?"hour12":"hour24":r.hour12?"hour12":"hour24");let i=k[o];if("object"==typeof i&&(i=i[a]),i)return{literal:!1,val:i}})(t,e,a))}},266615(e,t,r){"use strict";r.d(t,{L:()=>f});var n=r(793111),s=r(933190),a=r(290264),o=r(834028),i=r(988217),l=r(471265),c=r(397718),u=r(107842),m=r(680985),d=r(902419),p=r(943544),h=r(845226);let f=(0,a._C)((e={})=>{let t={onerror:!0,onunhandledrejection:!0,...e};return{name:"GlobalHandlers",setupOnce(){Error.stackTraceLimit=50},setup(e){var r,a;t.onerror&&(r=e,(0,i.L)(e=>{let{stackParser:t,attachStacktrace:a}=y();if((0,s.KU)()!==r||(0,h.jN)())return;let{msg:i,url:l,line:u,column:d,error:f}=e,g=function(e,t,r,n){let s=e.exception=e.exception||{},a=s.values=s.values||[],i=a[0]=a[0]||{},l=i.stacktrace=i.stacktrace||{},u=l.frames=l.frames||[],d=isNaN(parseInt(n,10))?void 0:n,p=isNaN(parseInt(r,10))?void 0:r,h=(0,c.Kg)(t)&&t.length>0?t:(0,o.$N)();return 0===u.length&&u.push({colno:d,filename:h,function:m.yF,in_app:!0,lineno:p}),e}((0,p.H7)(t,f||i,void 0,a,!1),l,u,d);g.level="error",(0,n.r)(g,{originalException:f,mechanism:{handled:!1,type:"onerror"}})}),g("onerror")),t.onunhandledrejection&&(a=e,(0,l.r)(e=>{var t;let{stackParser:r,attachStacktrace:o}=y();if((0,s.KU)()!==a||(0,h.jN)())return;let i=function(e){if((0,c.sO)(e))return e;try{if("reason"in e)return e.reason;if("detail"in e&&"reason"in e.detail)return e.detail.reason}catch(e){}return e}(e),l=(0,c.sO)(i)?(t=i,{exception:{values:[{type:"UnhandledRejection",value:`Non-Error promise rejection captured with value: ${String(t)}`}]}}):(0,p.H7)(r,i,void 0,o,!0);l.level="error",(0,n.r)(l,{originalException:i,mechanism:{handled:!1,type:"onunhandledrejection"}})}),g("onunhandledrejection"))}}});function g(e){d.T&&u.vF.log(`Global Handler attached: ${e}`)}function y(){let e=(0,s.KU)();return e&&e.getOptions()||{stackParser:()=>[],attachStacktrace:!1}}},267276(e,t,r){"use strict";r.d(t,{x:()=>s});var n=r(397718);function s(e,t,r=()=>{}){var a,o,i;let l;try{l=e()}catch(e){throw t(e),r(),e}return a=l,o=t,i=r,(0,n.Qg)(a)?a.then(e=>(i(),e),e=>{throw o(e),i(),e}):(i(),a)}},273521(e,t,r){"use strict";r.d(t,{L:()=>a});var n=r(895315),s=r(85182);function a(e,{metadata:t,tunnel:r,dsn:a}){let o={event_id:e.event_id,sent_at:new Date().toISOString(),...t&&t.sdk&&{sdk:{name:t.sdk.name,version:t.sdk.version}},...!!r&&!!a&&{dsn:(0,n.SB)(a)}},i=[{type:"user_report"},e];return(0,s.h4)(o,[i])}},276277(e,t,r){"use strict";r.d(t,{U:()=>n});let n="production"},283707(e,t,r){"use strict";r.d(t,{A:()=>s});var n=r(961520);class s{get type(){throw new n.jP}get name(){throw new n.jP}get ianaName(){return this.name}get isUniversal(){throw new n.jP}offsetName(e,t){throw new n.jP}formatOffset(e,t){throw new n.jP}offset(e){throw new n.jP}equals(e){throw new n.jP}get isValid(){throw new n.jP}}},290264(e,t,r){"use strict";r.d(t,{P$:()=>c,Q8:()=>d,_C:()=>p,lc:()=>u,mH:()=>l,qm:()=>m});var n=r(107842),s=r(696294),a=r(933190),o=r(67904);let i=[];function l(e){let t=e.defaultIntegrations||[],r=e.integrations;t.forEach(e=>{e.isDefaultInstance=!0});let n=function(e){let t={};return e.forEach(e=>{let{name:r}=e,n=t[r];n&&!n.isDefaultInstance&&e.isDefaultInstance||(t[r]=e)}),Object.values(t)}(Array.isArray(r)?[...t,...r]:"function"==typeof r?(0,s.k9)(r(t)):t),a=n.findIndex(e=>"Debug"===e.name);if(a>-1){let[e]=n.splice(a,1);n.push(e)}return n}function c(e,t){let r={};return t.forEach(t=>{t&&m(e,t,r)}),r}function u(e,t){for(let r of t)r&&r.afterAllSetup&&r.afterAllSetup(e)}function m(e,t,r){if(r[t.name]){o.T&&n.vF.log(`Integration skipped because it was already installed: ${t.name}`);return}if(r[t.name]=t,-1===i.indexOf(t.name)&&"function"==typeof t.setupOnce&&(t.setupOnce(),i.push(t.name)),t.setup&&"function"==typeof t.setup&&t.setup(e),"function"==typeof t.preprocessEvent){let r=t.preprocessEvent.bind(t);e.on("preprocessEvent",(t,n)=>r(t,n,e))}if("function"==typeof t.processEvent){let r=t.processEvent.bind(t),n=Object.assign((t,n)=>r(t,n,e),{id:t.name});e.addEventProcessor(n)}o.T&&n.vF.log(`Integration installed: ${t.name}`)}function d(e){let t=(0,a.KU)();if(!t){o.T&&n.vF.warn(`Cannot add integration "${e.name}" because no SDK Client is available.`);return}t.addIntegration(e)}function p(e){return e}},290266(e,t,r){"use strict";r.d(t,{Ik:()=>h,KC:()=>v,L5:()=>_,NW:()=>k,PV:()=>b,YO:()=>i,Yj:()=>y,ai:()=>p,bz:()=>o,eu:()=>u,g1:()=>g,lq:()=>f,me:()=>d,nd:()=>c,zM:()=>l});var n=r(448967),s=r(612815),a=r(545203);function o(){return(0,a.E8)("any",()=>!0)}function i(e){return new n._k({type:"array",schema:e,*entries(t){if(e&&Array.isArray(t))for(let[r,n]of t.entries())yield[r,n,e]},coercer:e=>Array.isArray(e)?e.slice():e,validator:e=>Array.isArray(e)||`Expected an array value, but received: ${(0,s.yy)(e)}`})}function l(){return(0,a.E8)("boolean",e=>"boolean"==typeof e)}function c(){return(0,a.E8)("integer",e=>"number"==typeof e&&!isNaN(e)&&Number.isInteger(e)||`Expected an integer, but received: ${(0,s.yy)(e)}`)}function u(e){let t=(0,s.yy)(e),r=typeof e;return new n._k({type:"literal",schema:"string"===r||"number"===r||"boolean"===r?e:null,validator:r=>r===e||`Expected the literal \`${t}\`, but received: ${(0,s.yy)(r)}`})}function m(){return(0,a.E8)("never",()=>!1)}function d(e){return new n._k({...e,validator:(t,r)=>null===t||e.validator(t,r),refiner:(t,r)=>null===t||e.refiner(t,r)})}function p(){return(0,a.E8)("number",e=>"number"==typeof e&&!isNaN(e)||`Expected a number, but received: ${(0,s.yy)(e)}`)}function h(e){let t=e?Object.keys(e):[],r=m();return new n._k({type:"object",schema:e??null,*entries(a){if(e&&(0,s.Gv)(a)){let s=new Set(Object.keys(a));for(let r of t){s.delete(r);let t=e[r];(!n.P$.isExactOptional(t)||Object.prototype.hasOwnProperty.call(a,r))&&(yield[r,a[r],e[r]])}for(let e of s)yield[e,a[e],r]}},validator:e=>(0,s.Gv)(e)||`Expected an object, but received: ${(0,s.yy)(e)}`,coercer:e=>(0,s.Gv)(e)?{...e}:e})}function f(e){return new n._k({...e,validator:(t,r)=>void 0===t||e.validator(t,r),refiner:(t,r)=>void 0===t||e.refiner(t,r)})}function g(e,t){return new n._k({type:"record",schema:null,*entries(r){if((0,s.Gv)(r))for(let n in r){let s=r[n];yield[n,n,e],yield[n,s,t]}},validator:e=>(0,s.Gv)(e)||`Expected an object, but received: ${(0,s.yy)(e)}`})}function y(){return(0,a.E8)("string",e=>"string"==typeof e||`Expected a string, but received: ${(0,s.yy)(e)}`)}function b(e){let t=m();return new n._k({type:"tuple",schema:null,*entries(r){if(Array.isArray(r)){let n=Math.max(e.length,r.length);for(let s=0;s<n;s++)yield[s,r[s],e[s]||t]}},validator:e=>Array.isArray(e)||`Expected an array, but received: ${(0,s.yy)(e)}`})}function k(e){let t=Object.keys(e);return new n._k({type:"type",schema:e,*entries(r){if((0,s.Gv)(r))for(let s of t)(!n.P$.isExactOptional(e[s])||Object.prototype.hasOwnProperty.call(r,s))&&(yield[s,r[s],e[s]])},validator:e=>(0,s.Gv)(e)||`Expected an object, but received: ${(0,s.yy)(e)}`,coercer:e=>(0,s.Gv)(e)?{...e}:e})}function v(e){let t=e.map(e=>e.type).join(" | ");return new n._k({type:"union",schema:null,coercer(t){for(let r of e){let[e,n]=r.validate(t,{coerce:!0});if(!e)return n}return t},validator(r,n){let a=[];for(let t of e){let[...e]=(0,s.eF)(r,t,n),[o]=e;if(!o?.[0])return[];for(let[t]of e)t&&a.push(t)}return[`Expected the value to satisfy a union of \`${t}\`, but received: ${(0,s.yy)(r)}`,...a]}})}function _(){return(0,a.E8)("unknown",()=>!0)}},293889(e,t,r){"use strict";r.d(t,{w:()=>l});var n,s,a=r(950515),o=function(e,t,r,n,s){if("m"===n)throw TypeError("Private method is not writable");if("a"===n&&!s)throw TypeError("Private accessor was defined without a setter");if("function"==typeof t?e!==t||!s:!t.has(e))throw TypeError("Cannot write private member to an object whose class did not declare it");return"a"===n?s.call(e,r):s?s.value=r:t.set(e,r),r},i=function(e,t,r,n){if("a"===r&&!n)throw TypeError("Private accessor was defined without a getter");if("function"==typeof t?e!==t||!n:!t.has(e))throw TypeError("Cannot read private member from an object whose class did not declare it");return"m"===r?n:"a"===r?n.call(e):n?n.value:t.get(e)};(0,a.YT)();class l{constructor({messenger:e,metadata:t,name:r,state:l}){n.set(this,void 0),s.set(this,void 0),o(this,s,e,"f"),this.messenger=e,this.name=r,o(this,n,(0,a.CN)(l,!0),"f"),this.metadata=t,i(this,s,"f").registerActionHandler(`${r}:getState`,()=>this.state),i(this,s,"f").registerInitialEventPayload({eventType:`${r}:stateChange`,getPayload:()=>[this.state,[]]}),i(this,s,"f").registerInitialEventPayload({eventType:`${r}:stateChanged`,getPayload:()=>[this.state,[]]})}get state(){return i(this,n,"f")}set state(e){throw Error("Controller state cannot be directly mutated; use 'update' method instead.")}update(e){let[t,r,l]=(0,a.vI)(i(this,n,"f"),e);return r.length>0&&(o(this,n,t,"f"),i(this,s,"f").publish(`${this.name}:stateChange`,t,r),i(this,s,"f").publish(`${this.name}:stateChanged`,t,r)),{nextState:t,patches:r,inversePatches:l}}applyPatches(e){let t=(0,a.$i)(i(this,n,"f"),e);o(this,n,t,"f"),i(this,s,"f").publish(`${this.name}:stateChange`,t,e),i(this,s,"f").publish(`${this.name}:stateChanged`,t,e)}destroy(){this.messenger.clearEventSubscriptions(`${this.name}:stateChange`),this.messenger.clearEventSubscriptions(`${this.name}:stateChanged`)}}n=new WeakMap,s=new WeakMap},297564(e,t,r){"use strict";r.d(t,{Dz:()=>p,FX:()=>u,Ts:()=>h,dg:()=>c,jx:()=>m,rW:()=>d,wV:()=>s});var n,s,a=r(818337);let o=/^(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32})$/u,i=/^(?<chainId>(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32})):(?<accountAddress>[-.%a-zA-Z0-9]{1,128})$/u,l=/^(?<chainId>(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32}))\/(?<assetNamespace>[-a-z0-9]{3,8}):(?<assetReference>[-.%a-zA-Z0-9]{1,128})$/u,c=(0,a.s)("CaipChainId",o);(0,a.s)("CaipNamespace",/^[-a-z0-9]{3,8}$/u),(0,a.s)("CaipReference",/^[-_a-zA-Z0-9]{1,32}$/u);let u=(0,a.s)("CaipAccountId",i);(0,a.s)("CaipAccountAddress",/^[-.%a-zA-Z0-9]{1,128}$/u),(0,a.s)("CaipAssetNamespace",/^[-a-z0-9]{3,8}$/u),(0,a.s)("CaipAssetReference",/^[-.%a-zA-Z0-9]{1,128}$/u),(0,a.s)("CaipTokenId",/^[-.%a-zA-Z0-9]{1,78}$/u);let m=(0,a.s)("CaipAssetType",l);function d(e){let t=o.exec(e);if(!t?.groups)throw Error("Invalid CAIP chain ID.");return{namespace:t.groups.namespace,reference:t.groups.reference}}function p(e){let t=i.exec(e);if(!t?.groups)throw Error("Invalid CAIP account ID.");return{address:t.groups.accountAddress,chainId:t.groups.chainId,chain:{namespace:t.groups.namespace,reference:t.groups.reference}}}function h(e){let t=l.exec(e);if(!t?.groups)throw Error("Invalid CAIP asset type.");return{assetNamespace:t.groups.assetNamespace,assetReference:t.groups.assetReference,chainId:t.groups.chainId,chain:{namespace:t.groups.namespace,reference:t.groups.reference}}}(0,a.s)("CaipAssetId",/^(?<chainId>(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32}))\/(?<assetNamespace>[-a-z0-9]{3,8}):(?<assetReference>[-.%a-zA-Z0-9]{1,128})\/(?<tokenId>[-.%a-zA-Z0-9]{1,78})$/u),(0,a.s)("CaipAssetTypeOrId",/^(?<chainId>(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32}))\/(?<assetNamespace>[-a-z0-9]{3,8}):(?<assetReference>[-.%a-zA-Z0-9]{1,128})(\/(?<tokenId>[-.%a-zA-Z0-9]{1,78}))?$/u),(n=s=s||(s={})).Bip122="bip122",n.Solana="solana",n.Stellar="stellar",n.Tron="tron",n.Eip155="eip155",n.Wallet="wallet"},300005(e,t,r){"use strict";function n(e){return t=>{let{key:r=null,...n}=t;return{type:e,props:Object.fromEntries(Object.entries(n).filter(([,e])=>void 0!==e)),key:r}}}r.d(t,{K:()=>n})},300652(e,t,r){"use strict";r.d(t,{I:()=>o,K:()=>i});var n=r(392248),s=r.n(n);let a=r(217768).dI.UNKNOWN,o=async()=>{try{let e=await s().management.getSelf();e.installType&&(a=e.installType)}catch(e){console.error("Error getting extension installType",e)}return a},i=()=>a},303818(e,t,r){"use strict";r.d(t,{z:()=>s});var n=r(12796);let s=()=>n.j.performance&&performance.getEntriesByType&&performance.getEntriesByType("navigation")[0]},316244(e,t,r){"use strict";r.d(t,{$P:()=>u,B9:()=>R,CF:()=>b,El:()=>p,Et:()=>i,Fl:()=>N,Fq:()=>l,GB:()=>w,Iw:()=>h,JZ:()=>j,Kg:()=>c,Ki:()=>S,L3:()=>E,U_:()=>x,_v:()=>g,ac:()=>A,b0:()=>o,cG:()=>k,f8:()=>y,fT:()=>C,gu:()=>O,h3:()=>m,i:()=>M,jv:()=>d,m3:()=>_,mQ:()=>f,mp:()=>v,wG:()=>I,xS:()=>D});var n=r(961520),s=r(392134),a=r(821213);function o(e){return void 0===e}function i(e){return"number"==typeof e}function l(e){return"number"==typeof e&&e%1==0}function c(e){return"string"==typeof e}function u(e){return"[object Date]"===Object.prototype.toString.call(e)}function m(){try{return"undefined"!=typeof Intl&&!!Intl.RelativeTimeFormat}catch(e){return!1}}function d(){try{return"undefined"!=typeof Intl&&!!Intl.Locale&&("weekInfo"in Intl.Locale.prototype||"getWeekInfo"in Intl.Locale.prototype)}catch(e){return!1}}function p(e){return Array.isArray(e)?e:[e]}function h(e,t,r){if(0!==e.length)return e.reduce((e,n)=>{let s=[t(n),n];return e&&r(e[0],s[0])===e[0]?e:s},null)[1]}function f(e,t){return Object.prototype.hasOwnProperty.call(e,t)}function g(e){if(null==e)return null;if("object"!=typeof e)throw new n.Di("Week settings must be an object");if(!y(e.firstDay,1,7)||!y(e.minimalDays,1,7)||!Array.isArray(e.weekend)||e.weekend.some(e=>!y(e,1,7)))throw new n.Di("Invalid week settings");return{firstDay:e.firstDay,minimalDays:e.minimalDays,weekend:Array.from(e.weekend)}}function y(e,t,r){return l(e)&&e>=t&&e<=r}function b(e,t=2){return e<0?"-"+(""+-e).padStart(t,"0"):(""+e).padStart(t,"0")}function k(e){if(!o(e)&&null!==e&&""!==e)return parseInt(e,10)}function v(e){if(!o(e)&&null!==e&&""!==e)return parseFloat(e)}function _(e){if(!o(e)&&null!==e&&""!==e)return Math.floor(1e3*parseFloat("0."+e))}function w(e,t,r=!1){let n=10**t;return(r?Math.trunc:Math.round)(e*n)/n}function x(e){return e%4==0&&(e%100!=0||e%400==0)}function S(e){return x(e)?366:365}function E(e,t){var r;let n=(r=t-1)-12*Math.floor(r/12)+1;return 2===n?x(e+(t-n)/12)?29:28:[31,null,31,30,31,30,31,31,30,31,30,31][n-1]}function j(e){let t=Date.UTC(e.year,e.month-1,e.day,e.hour,e.minute,e.second,e.millisecond);return e.year<100&&e.year>=0&&(t=new Date(t)).setUTCFullYear(e.year,e.month-1,e.day),+t}function T(e,t,r){return-(0,a.ui)((0,a.mK)(e,1,t),r)+t-1}function A(e,t=4,r=1){let n=T(e,t,r),s=T(e+1,t,r);return(S(e)-n+s)/7}function C(e){return e>99?e:e>s.A.twoDigitCutoffYear?1900+e:2e3+e}function I(e,t,r,n=null){let s=new Date(e),a={hourCycle:"h23",year:"numeric",month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit"};n&&(a.timeZone=n);let o={timeZoneName:t,...a},i=new Intl.DateTimeFormat(r,o).formatToParts(s).find(e=>"timezonename"===e.type.toLowerCase());return i?i.value:null}function O(e,t){let r=parseInt(e,10);Number.isNaN(r)&&(r=0);let n=parseInt(t,10)||0,s=r<0||Object.is(r,-0)?-n:n;return 60*r+s}function M(e){let t=Number(e);if("boolean"==typeof e||""===e||Number.isNaN(t))throw new n.Di(`Invalid unit value ${e}`);return t}function N(e,t){let r={};for(let n in e)if(f(e,n)){let s=e[n];if(null==s)continue;r[t(n)]=M(s)}return r}function D(e,t){let r=Math.trunc(Math.abs(e/60)),n=Math.trunc(Math.abs(e%60)),s=e>=0?"+":"-";switch(t){case"short":return`${s}${b(r,2)}:${b(n,2)}`;case"narrow":return`${s}${r}${n>0?`:${n}`:""}`;case"techie":return`${s}${b(r,2)}${b(n,2)}`;default:throw RangeError(`Value format ${t} is out of range for property format`)}}function R(e){return["hour","minute","second","millisecond"].reduce((t,r)=>(t[r]=e[r],t),{})}},327140(e,t,r){"use strict";r.d(t,{z:()=>u});var n=r(956742),s=r(184748),a=r(132076),o=r(495242),i=r(898026),l=r(681747);let c=[1800,3e3],u=(e,t={})=>{(0,l.I)(()=>{let r,l=(0,a.N)(),u=(0,o.X)("FCP"),m=(0,i.l)("paint",e=>{e.forEach(e=>{"first-contentful-paint"===e.name&&(m.disconnect(),e.startTime<l.firstHiddenTime&&(u.value=Math.max(e.startTime-(0,s.b)(),0),u.entries.push(e),r(!0)))})});m&&(r=(0,n.R)(e,u,c,t.reportAllChanges))})}},327566(e,t,r){"use strict";r.d(t,{H:()=>m});var n=r(933190),s=r(608119),a=r(107842),o=r(696294),i=r(37853),l=r(902419),c=r(845226),u=r(553205);function m(e){let t;(0,u.c4)(e)&&(t=1e3*(0,i.zf)());let r=(0,u.Dg)();if(!r)return;l.T&&a.vF.log(`[Profiling] started profiling span: ${(0,s.et)(e).description}`);let m=(0,o.eJ)();async function d(){if(e&&r)return r.stop().then(t=>{if(p&&(c.jf.clearTimeout(p),p=void 0),l.T&&a.vF.log(`[Profiling] stopped profiling of span: ${(0,s.et)(e).description}`),!t){l.T&&a.vF.log(`[Profiling] profiler returned null profile for: ${(0,s.et)(e).description}`,"this may indicate an overlapping span or a call to stopProfiling with a profile title that was never started");return}(0,u.DE)(m,t)}).catch(e=>{l.T&&a.vF.log("[Profiling] error while stopping profiler:",e)})}(0,n.o5)().setContext("profile",{profile_id:m,start_timestamp:t});let p=c.jf.setTimeout(()=>{l.T&&a.vF.log("[Profiling] max profile duration elapsed, stopping profiling for:",(0,s.et)(e).description),d()},u.TD),h=e.end.bind(e);e.end=function(){return e?(d().then(()=>{h()},()=>{h()}),e):h()}}},347022(e,t,r){"use strict";let n;r.d(t,{A:()=>W,R:()=>H});var s=r(360569),a=r(352134),o=r(392134),i=r(442525),l=r(925752),c=r(794204),u=r(640846),m=r(316244),d=r(419186),p=r(85013),h=r(731318),f=r(263496),g=r(821213),y=r(951906),b=r(961520),k=r(446655);let v="Invalid DateTime";function _(e){return new k.A("unsupported zone",`the zone "${e.name}" is not supported`)}function w(e){return null===e.weekData&&(e.weekData=(0,g.C9)(e.c)),e.weekData}function x(e){return null===e.localWeekData&&(e.localWeekData=(0,g.C9)(e.c,e.loc.getMinDaysInFirstWeek(),e.loc.getStartOfWeek())),e.localWeekData}function S(e,t){let r={ts:e.ts,zone:e.zone,c:e.c,o:e.o,loc:e.loc,invalid:e.invalid};return new W({...r,...t,old:r})}function E(e,t,r){let n=e-60*t*1e3,s=r.offset(n);if(t===s)return[n,t];n-=(s-t)*6e4;let a=r.offset(n);return s===a?[n,s]:[e-60*Math.min(s,a)*1e3,Math.max(s,a)]}function j(e,t){let r=new Date(e+=60*t*1e3);return{year:r.getUTCFullYear(),month:r.getUTCMonth()+1,day:r.getUTCDate(),hour:r.getUTCHours(),minute:r.getUTCMinutes(),second:r.getUTCSeconds(),millisecond:r.getUTCMilliseconds()}}function T(e,t,r){return E((0,m.JZ)(e),t,r)}function A(e,t){let r=e.o,n=e.c.year+Math.trunc(t.years),a=e.c.month+Math.trunc(t.months)+3*Math.trunc(t.quarters),o={...e.c,year:n,month:a,day:Math.min(e.c.day,(0,m.L3)(n,a))+Math.trunc(t.days)+7*Math.trunc(t.weeks)},i=s.Ay.fromObject({years:t.years-Math.trunc(t.years),quarters:t.quarters-Math.trunc(t.quarters),months:t.months-Math.trunc(t.months),weeks:t.weeks-Math.trunc(t.weeks),days:t.days-Math.trunc(t.days),hours:t.hours,minutes:t.minutes,seconds:t.seconds,milliseconds:t.milliseconds}).as("milliseconds"),[l,c]=E((0,m.JZ)(o),r,e.zone);return 0!==i&&(l+=i,c=e.zone.offset(l)),{ts:l,o:c}}function C(e,t,r,n,s,a){let{setZone:o,zone:i}=r;if((!e||0===Object.keys(e).length)&&!t)return W.invalid(new k.A("unparsable",`the input "${s}" can't be parsed as ${n}`));{let n=W.fromObject(e,{...r,zone:t||i,specificOffset:a});return o?n:n.setZone(i)}}function I(e,t,r=!0){return e.isValid?l.A.create(u.A.create("en-US"),{allowZ:r,forceSimple:!0}).formatDateTimeFromString(e,t):null}function O(e,t){let r=e.c.year>9999||e.c.year<0,n="";return r&&e.c.year>=0&&(n+="+"),n+=(0,m.CF)(e.c.year,r?6:4),t?(n+="-",n+=(0,m.CF)(e.c.month),n+="-"):n+=(0,m.CF)(e.c.month),n+=(0,m.CF)(e.c.day)}function M(e,t,r,n,s,a){let o=(0,m.CF)(e.c.hour);return t?(o+=":",o+=(0,m.CF)(e.c.minute),0===e.c.millisecond&&0===e.c.second&&r||(o+=":")):o+=(0,m.CF)(e.c.minute),(0!==e.c.millisecond||0!==e.c.second||!r)&&(o+=(0,m.CF)(e.c.second),0===e.c.millisecond&&n||(o+=".",o+=(0,m.CF)(e.c.millisecond,3))),s&&(e.isOffsetFixed&&0===e.offset&&!a?o+="Z":e.o<0?(o+="-",o+=(0,m.CF)(Math.trunc(-e.o/60)),o+=":",o+=(0,m.CF)(Math.trunc(-e.o%60))):(o+="+",o+=(0,m.CF)(Math.trunc(e.o/60)),o+=":",o+=(0,m.CF)(Math.trunc(e.o%60)))),a&&(o+="["+e.zone.ianaName+"]"),o}let N={month:1,day:1,hour:0,minute:0,second:0,millisecond:0},D={weekNumber:1,weekday:1,hour:0,minute:0,second:0,millisecond:0},R={ordinal:1,hour:0,minute:0,second:0,millisecond:0},L=["year","month","day","hour","minute","second","millisecond"],F=["weekYear","weekNumber","weekday","hour","minute","second","millisecond"],P=["year","ordinal","hour","minute","second","millisecond"];function q(e){switch(e.toLowerCase()){case"localweekday":case"localweekdays":return"localWeekday";case"localweeknumber":case"localweeknumbers":return"localWeekNumber";case"localweekyear":case"localweekyears":return"localWeekYear";default:let t={year:"year",years:"year",month:"month",months:"month",day:"day",days:"day",hour:"hour",hours:"hour",minute:"minute",minutes:"minute",quarter:"quarter",quarters:"quarter",second:"second",seconds:"second",millisecond:"millisecond",milliseconds:"millisecond",weekday:"weekday",weekdays:"weekday",weeknumber:"weekNumber",weeksnumber:"weekNumber",weeknumbers:"weekNumber",weekyear:"weekYear",weekyears:"weekYear",ordinal:"ordinal"}[e.toLowerCase()];if(!t)throw new b.iq(e);return t}}function z(e,t){let r,s,a=(0,d.q)(t.zone,o.A.defaultZone);if(!a.isValid)return W.invalid(_(a));let i=u.A.fromObject(t);if((0,m.b0)(e.year))r=o.A.now();else{for(let t of L)(0,m.b0)(e[t])&&(e[t]=N[t]);let t=(0,g.EG)(e)||(0,g.nM)(e);if(t)return W.invalid(t);let i=(B[a]||(void 0===n&&(n=o.A.now()),B[a]=a.offset(n)),B[a]);[r,s]=T(e,i,a)}return new W({ts:r,zone:a,loc:i,o:s})}function $(e,t,r){let n=!!(0,m.b0)(r.round)||r.round,s=(e,s)=>(e=(0,m.GB)(e,n||r.calendary?0:2,!0),t.loc.clone(r).relFormatter(r).format(e,s)),a=n=>r.calendary?t.hasSame(e,n)?0:t.startOf(n).diff(e.startOf(n),n).get(n):t.diff(e,n).get(n);if(r.unit)return s(a(r.unit),r.unit);for(let e of r.units){let t=a(e);if(Math.abs(t)>=1)return s(t,e)}return s(e>t?-0:0,r.units[r.units.length-1])}function U(e){let t={},r;return e.length>0&&"object"==typeof e[e.length-1]?(t=e[e.length-1],r=Array.from(e).slice(0,e.length-1)):r=Array.from(e),[t,r]}let B={};class W{constructor(e){let t=e.zone||o.A.defaultZone,r=e.invalid||(Number.isNaN(e.ts)?new k.A("invalid input"):null)||(t.isValid?null:_(t));this.ts=(0,m.b0)(e.ts)?o.A.now():e.ts;let n=null,s=null;if(!r)if(e.old&&e.old.ts===this.ts&&e.old.zone.equals(t))[n,s]=[e.old.c,e.old.o];else{let a=(0,m.Et)(e.o)&&!e.old?e.o:t.offset(this.ts);n=(r=Number.isNaN((n=j(this.ts,a)).year)?new k.A("invalid input"):null)?null:n,s=r?null:a}this._zone=t,this.loc=e.loc||u.A.create(),this.invalid=r,this.weekData=null,this.localWeekData=null,this.c=n,this.o=s,this.isLuxonDateTime=!0}static now(){return new W({})}static local(){let[e,t]=U(arguments),[r,n,s,a,o,i,l]=t;return z({year:r,month:n,day:s,hour:a,minute:o,second:i,millisecond:l},e)}static utc(){let[e,t]=U(arguments),[r,n,s,a,o,i,l]=t;return e.zone=c.A.utcInstance,z({year:r,month:n,day:s,hour:a,minute:o,second:i,millisecond:l},e)}static fromJSDate(e,t={}){let r=(0,m.$P)(e)?e.valueOf():NaN;if(Number.isNaN(r))return W.invalid("invalid input");let n=(0,d.q)(t.zone,o.A.defaultZone);return n.isValid?new W({ts:r,zone:n,loc:u.A.fromObject(t)}):W.invalid(_(n))}static fromMillis(e,t={}){if((0,m.Et)(e))if(e<-864e13||e>864e13)return W.invalid("Timestamp out of range");else return new W({ts:e,zone:(0,d.q)(t.zone,o.A.defaultZone),loc:u.A.fromObject(t)});throw new b.Di(`fromMillis requires a numerical input, but received a ${typeof e} with value ${e}`)}static fromSeconds(e,t={}){if((0,m.Et)(e))return new W({ts:1e3*e,zone:(0,d.q)(t.zone,o.A.defaultZone),loc:u.A.fromObject(t)});throw new b.Di("fromSeconds requires a numerical input")}static fromObject(e,t={}){e=e||{};let r=(0,d.q)(t.zone,o.A.defaultZone);if(!r.isValid)return W.invalid(_(r));let n=u.A.fromObject(t),s=(0,m.Fl)(e,q),{minDaysInFirstWeek:a,startOfWeek:i}=(0,g._3)(s,n),l=o.A.now(),c=(0,m.b0)(t.specificOffset)?r.offset(l):t.specificOffset,p=!(0,m.b0)(s.ordinal),h=!(0,m.b0)(s.year),f=!(0,m.b0)(s.month)||!(0,m.b0)(s.day),y=h||f,k=s.weekYear||s.weekNumber;if((y||p)&&k)throw new b.gN("Can't mix weekYear/weekNumber units with year/month/day or ordinals");if(f&&p)throw new b.gN("Can't mix ordinal dates with month/day");let v=k||s.weekday&&!y,w,x,S=j(l,c);v?(w=F,x=D,S=(0,g.C9)(S,a,i)):p?(w=P,x=R,S=(0,g.d3)(S)):(w=L,x=N);let E=!1;for(let e of w){let t=s[e];(0,m.b0)(t)?E?s[e]=x[e]:s[e]=S[e]:E=!0}let A=(v?(0,g.WF)(s,a,i):p?(0,g.De)(s):(0,g.EG)(s))||(0,g.nM)(s);if(A)return W.invalid(A);let[C,I]=T(v?(0,g.WO)(s,a,i):p?(0,g.fZ)(s):s,c,r),O=new W({ts:C,zone:r,o:I,loc:n});return s.weekday&&y&&e.weekday!==O.weekday?W.invalid("mismatched weekday",`you can't specify both a weekday of ${s.weekday} and a date of ${O.toISO()}`):O.isValid?O:W.invalid(O.invalid)}static fromISO(e,t={}){let[r,n]=(0,h.lA)(e);return C(r,n,t,"ISO 8601",e)}static fromRFC2822(e,t={}){let[r,n]=(0,h.J5)(e);return C(r,n,t,"RFC 2822",e)}static fromHTTP(e,t={}){let[r,n]=(0,h.a8)(e);return C(r,n,t,"HTTP",t)}static fromFormat(e,t,r={}){if((0,m.b0)(e)||(0,m.b0)(t))throw new b.Di("fromFormat requires an input string and a format");let{locale:n=null,numberingSystem:s=null}=r,a=u.A.fromOpts({locale:n,numberingSystem:s,defaultToEN:!0}),[o,i,l,c]=(0,f.ws)(a,e,t);return c?W.invalid(c):C(o,i,r,`format ${t}`,e,l)}static fromString(e,t,r={}){return W.fromFormat(e,t,r)}static fromSQL(e,t={}){let[r,n]=(0,h._E)(e);return C(r,n,t,"SQL",e)}static invalid(e,t=null){if(!e)throw new b.Di("need to specify a reason the DateTime is invalid");let r=e instanceof k.A?e:new k.A(e,t);if(!o.A.throwOnInvalid)return new W({invalid:r});throw new b.t(r)}static isDateTime(e){return e&&e.isLuxonDateTime||!1}static parseFormatForOpts(e,t={}){let r=(0,f.Z7)(e,u.A.fromObject(t));return r?r.map(e=>e?e.val:null).join(""):null}static expandFormat(e,t={}){return(0,f.np)(l.A.parseFormat(e),u.A.fromObject(t)).map(e=>e.val).join("")}static resetCache(){n=void 0,B={}}get(e){return this[e]}get isValid(){return null===this.invalid}get invalidReason(){return this.invalid?this.invalid.reason:null}get invalidExplanation(){return this.invalid?this.invalid.explanation:null}get locale(){return this.isValid?this.loc.locale:null}get numberingSystem(){return this.isValid?this.loc.numberingSystem:null}get outputCalendar(){return this.isValid?this.loc.outputCalendar:null}get zone(){return this._zone}get zoneName(){return this.isValid?this.zone.name:null}get year(){return this.isValid?this.c.year:NaN}get quarter(){return this.isValid?Math.ceil(this.c.month/3):NaN}get month(){return this.isValid?this.c.month:NaN}get day(){return this.isValid?this.c.day:NaN}get hour(){return this.isValid?this.c.hour:NaN}get minute(){return this.isValid?this.c.minute:NaN}get second(){return this.isValid?this.c.second:NaN}get millisecond(){return this.isValid?this.c.millisecond:NaN}get weekYear(){return this.isValid?w(this).weekYear:NaN}get weekNumber(){return this.isValid?w(this).weekNumber:NaN}get weekday(){return this.isValid?w(this).weekday:NaN}get isWeekend(){return this.isValid&&this.loc.getWeekendDays().includes(this.weekday)}get localWeekday(){return this.isValid?x(this).weekday:NaN}get localWeekNumber(){return this.isValid?x(this).weekNumber:NaN}get localWeekYear(){return this.isValid?x(this).weekYear:NaN}get ordinal(){return this.isValid?(0,g.d3)(this.c).ordinal:NaN}get monthShort(){return this.isValid?i.A.months("short",{locObj:this.loc})[this.month-1]:null}get monthLong(){return this.isValid?i.A.months("long",{locObj:this.loc})[this.month-1]:null}get weekdayShort(){return this.isValid?i.A.weekdays("short",{locObj:this.loc})[this.weekday-1]:null}get weekdayLong(){return this.isValid?i.A.weekdays("long",{locObj:this.loc})[this.weekday-1]:null}get offset(){return this.isValid?+this.o:NaN}get offsetNameShort(){return this.isValid?this.zone.offsetName(this.ts,{format:"short",locale:this.locale}):null}get offsetNameLong(){return this.isValid?this.zone.offsetName(this.ts,{format:"long",locale:this.locale}):null}get isOffsetFixed(){return this.isValid?this.zone.isUniversal:null}get isInDST(){return!this.isOffsetFixed&&(this.offset>this.set({month:1,day:1}).offset||this.offset>this.set({month:5}).offset)}getPossibleOffsets(){if(!this.isValid||this.isOffsetFixed)return[this];let e=(0,m.JZ)(this.c),t=this.zone.offset(e-864e5),r=this.zone.offset(e+864e5),n=this.zone.offset(e-6e4*t),s=this.zone.offset(e-6e4*r);if(n===s)return[this];let a=e-6e4*n,o=e-6e4*s,i=j(a,n),l=j(o,s);return i.hour===l.hour&&i.minute===l.minute&&i.second===l.second&&i.millisecond===l.millisecond?[S(this,{ts:a}),S(this,{ts:o})]:[this]}get isInLeapYear(){return(0,m.U_)(this.year)}get daysInMonth(){return(0,m.L3)(this.year,this.month)}get daysInYear(){return this.isValid?(0,m.Ki)(this.year):NaN}get weeksInWeekYear(){return this.isValid?(0,m.ac)(this.weekYear):NaN}get weeksInLocalWeekYear(){return this.isValid?(0,m.ac)(this.localWeekYear,this.loc.getMinDaysInFirstWeek(),this.loc.getStartOfWeek()):NaN}resolvedLocaleOptions(e={}){let{locale:t,numberingSystem:r,calendar:n}=l.A.create(this.loc.clone(e),e).resolvedOptions(this);return{locale:t,numberingSystem:r,outputCalendar:n}}toUTC(e=0,t={}){return this.setZone(c.A.instance(e),t)}toLocal(){return this.setZone(o.A.defaultZone)}setZone(e,{keepLocalTime:t=!1,keepCalendarTime:r=!1}={}){if((e=(0,d.q)(e,o.A.defaultZone)).equals(this.zone))return this;{if(!e.isValid)return W.invalid(_(e));let n=this.ts;if(t||r){let t=e.offset(this.ts),r=this.toObject();[n]=T(r,t,e)}return S(this,{ts:n,zone:e})}}reconfigure({locale:e,numberingSystem:t,outputCalendar:r}={}){return S(this,{loc:this.loc.clone({locale:e,numberingSystem:t,outputCalendar:r})})}setLocale(e){return this.reconfigure({locale:e})}set(e){let t;if(!this.isValid)return this;let r=(0,m.Fl)(e,q),{minDaysInFirstWeek:n,startOfWeek:s}=(0,g._3)(r,this.loc),a=!(0,m.b0)(r.weekYear)||!(0,m.b0)(r.weekNumber)||!(0,m.b0)(r.weekday),o=!(0,m.b0)(r.ordinal),i=!(0,m.b0)(r.year),l=!(0,m.b0)(r.month)||!(0,m.b0)(r.day),c=r.weekYear||r.weekNumber;if((i||l||o)&&c)throw new b.gN("Can't mix weekYear/weekNumber units with year/month/day or ordinals");if(l&&o)throw new b.gN("Can't mix ordinal dates with month/day");a?t=(0,g.WO)({...(0,g.C9)(this.c,n,s),...r},n,s):(0,m.b0)(r.ordinal)?(t={...this.toObject(),...r},(0,m.b0)(r.day)&&(t.day=Math.min((0,m.L3)(t.year,t.month),t.day))):t=(0,g.fZ)({...(0,g.d3)(this.c),...r});let[u,d]=T(t,this.o,this.zone);return S(this,{ts:u,o:d})}plus(e){return this.isValid?S(this,A(this,s.Ay.fromDurationLike(e))):this}minus(e){return this.isValid?S(this,A(this,s.Ay.fromDurationLike(e).negate())):this}startOf(e,{useLocaleWeeks:t=!1}={}){if(!this.isValid)return this;let r={},n=s.Ay.normalizeUnit(e);switch(n){case"years":r.month=1;case"quarters":case"months":r.day=1;case"weeks":case"days":r.hour=0;case"hours":r.minute=0;case"minutes":r.second=0;case"seconds":r.millisecond=0}if("weeks"===n)if(t){let e=this.loc.getStartOfWeek(),{weekday:t}=this;t<e&&(r.weekNumber=this.weekNumber-1),r.weekday=e}else r.weekday=1;return"quarters"===n&&(r.month=(Math.ceil(this.month/3)-1)*3+1),this.set(r)}endOf(e,t){return this.isValid?this.plus({[e]:1}).startOf(e,t).minus(1):this}toFormat(e,t={}){return this.isValid?l.A.create(this.loc.redefaultToEN(t)).formatDateTimeFromString(this,e):v}toLocaleString(e=y.aY,t={}){return this.isValid?l.A.create(this.loc.clone(t),e).formatDateTime(this):v}toLocaleParts(e={}){return this.isValid?l.A.create(this.loc.clone(e),e).formatDateTimeParts(this):[]}toISO({format:e="extended",suppressSeconds:t=!1,suppressMilliseconds:r=!1,includeOffset:n=!0,extendedZone:s=!1}={}){if(!this.isValid)return null;let a="extended"===e,o=O(this,a);return o+="T",o+=M(this,a,t,r,n,s)}toISODate({format:e="extended"}={}){return this.isValid?O(this,"extended"===e):null}toISOWeekDate(){return I(this,"kkkk-'W'WW-c")}toISOTime({suppressMilliseconds:e=!1,suppressSeconds:t=!1,includeOffset:r=!0,includePrefix:n=!1,extendedZone:s=!1,format:a="extended"}={}){return this.isValid?(n?"T":"")+M(this,"extended"===a,t,e,r,s):null}toRFC2822(){return I(this,"EEE, dd LLL yyyy HH:mm:ss ZZZ",!1)}toHTTP(){return I(this.toUTC(),"EEE, dd LLL yyyy HH:mm:ss 'GMT'")}toSQLDate(){return this.isValid?O(this,!0):null}toSQLTime({includeOffset:e=!0,includeZone:t=!1,includeOffsetSpace:r=!0}={}){let n="HH:mm:ss.SSS";return(t||e)&&(r&&(n+=" "),t?n+="z":e&&(n+="ZZ")),I(this,n,!0)}toSQL(e={}){return this.isValid?`${this.toSQLDate()} ${this.toSQLTime(e)}`:null}toString(){return this.isValid?this.toISO():v}[Symbol.for("nodejs.util.inspect.custom")](){return this.isValid?`DateTime { ts: ${this.toISO()}, zone: ${this.zone.name}, locale: ${this.locale} }`:`DateTime { Invalid, reason: ${this.invalidReason} }`}valueOf(){return this.toMillis()}toMillis(){return this.isValid?this.ts:NaN}toSeconds(){return this.isValid?this.ts/1e3:NaN}toUnixInteger(){return this.isValid?Math.floor(this.ts/1e3):NaN}toJSON(){return this.toISO()}toBSON(){return this.toJSDate()}toObject(e={}){if(!this.isValid)return{};let t={...this.c};return e.includeConfig&&(t.outputCalendar=this.outputCalendar,t.numberingSystem=this.loc.numberingSystem,t.locale=this.loc.locale),t}toJSDate(){return new Date(this.isValid?this.ts:NaN)}diff(e,t="milliseconds",r={}){if(!this.isValid||!e.isValid)return s.Ay.invalid("created by diffing an invalid DateTime");let n={locale:this.locale,numberingSystem:this.numberingSystem,...r},a=(0,m.El)(t).map(s.Ay.normalizeUnit),o=e.valueOf()>this.valueOf(),i=o?this:e,l=o?e:this,c=(0,p.A)(i,l,a,n);return o?c.negate():c}diffNow(e="milliseconds",t={}){return this.diff(W.now(),e,t)}until(e){return this.isValid?a.A.fromDateTimes(this,e):this}hasSame(e,t,r){if(!this.isValid)return!1;let n=e.valueOf(),s=this.setZone(e.zone,{keepLocalTime:!0});return s.startOf(t,r)<=n&&n<=s.endOf(t,r)}equals(e){return this.isValid&&e.isValid&&this.valueOf()===e.valueOf()&&this.zone.equals(e.zone)&&this.loc.equals(e.loc)}toRelative(e={}){if(!this.isValid)return null;let t=e.base||W.fromObject({},{zone:this.zone}),r=e.padding?this<t?-e.padding:e.padding:0,n=["years","months","days","hours","minutes","seconds"],s=e.unit;return Array.isArray(e.unit)&&(n=e.unit,s=void 0),$(t,this.plus(r),{...e,numeric:"always",units:n,unit:s})}toRelativeCalendar(e={}){return this.isValid?$(e.base||W.fromObject({},{zone:this.zone}),this,{...e,numeric:"auto",units:["years","months","days"],calendary:!0}):null}static min(...e){if(!e.every(W.isDateTime))throw new b.Di("min requires all arguments be DateTimes");return(0,m.Iw)(e,e=>e.valueOf(),Math.min)}static max(...e){if(!e.every(W.isDateTime))throw new b.Di("max requires all arguments be DateTimes");return(0,m.Iw)(e,e=>e.valueOf(),Math.max)}static fromFormatExplain(e,t,r={}){let{locale:n=null,numberingSystem:s=null}=r,a=u.A.fromOpts({locale:n,numberingSystem:s,defaultToEN:!0});return(0,f.GR)(a,e,t)}static fromStringExplain(e,t,r={}){return W.fromFormatExplain(e,t,r)}static buildFormatParser(e,t={}){let{locale:r=null,numberingSystem:n=null}=t,s=u.A.fromOpts({locale:r,numberingSystem:n,defaultToEN:!0});return new f.zb(s,e)}static fromFormatParser(e,t,r={}){if((0,m.b0)(e)||(0,m.b0)(t))throw new b.Di("fromFormatParser requires an input string and a format parser");let{locale:n=null,numberingSystem:s=null}=r,a=u.A.fromOpts({locale:n,numberingSystem:s,defaultToEN:!0});if(!a.equals(t.locale))throw new b.Di(`fromFormatParser called with a locale of ${a}, but the format parser was created for ${t.locale}`);let{result:o,zone:i,specificOffset:l,invalidReason:c}=t.explainFromTokens(e);return c?W.invalid(c):C(o,i,r,`format ${t.format}`,e,l)}static get DATE_SHORT(){return y.aY}static get DATE_MED(){return y.g5}static get DATE_MED_WITH_WEEKDAY(){return y.M$}static get DATE_FULL(){return y.Rb}static get DATE_HUGE(){return y.d6}static get TIME_SIMPLE(){return y.dz}static get TIME_WITH_SECONDS(){return y.hF}static get TIME_WITH_SHORT_OFFSET(){return y.oq}static get TIME_WITH_LONG_OFFSET(){return y.o}static get TIME_24_SIMPLE(){return y.My}static get TIME_24_WITH_SECONDS(){return y.cE}static get TIME_24_WITH_SHORT_OFFSET(){return y.dO}static get TIME_24_WITH_LONG_OFFSET(){return y.FX}static get DATETIME_SHORT(){return y.DN}static get DATETIME_SHORT_WITH_SECONDS(){return y.h0}static get DATETIME_MED(){return y.pM}static get DATETIME_MED_WITH_SECONDS(){return y.AX}static get DATETIME_MED_WITH_WEEKDAY(){return y.fO}static get DATETIME_FULL(){return y.Al}static get DATETIME_FULL_WITH_SECONDS(){return y.h3}static get DATETIME_HUGE(){return y.MC}static get DATETIME_HUGE_WITH_SECONDS(){return y.nt}}function H(e){if(W.isDateTime(e))return e;if(e&&e.valueOf&&(0,m.Et)(e.valueOf()))return W.fromJSDate(e);if(e&&"object"==typeof e)return W.fromObject(e);throw new b.Di(`Unknown datetime argument: ${e}, of type ${typeof e}`)}},352134(e,t,r){"use strict";r.d(t,{A:()=>m});var n=r(347022),s=r(360569),a=r(392134),o=r(961520),i=r(446655),l=r(925752),c=r(951906);let u="Invalid Interval";class m{constructor(e){this.s=e.start,this.e=e.end,this.invalid=e.invalid||null,this.isLuxonInterval=!0}static invalid(e,t=null){if(!e)throw new o.Di("need to specify a reason the Interval is invalid");let r=e instanceof i.A?e:new i.A(e,t);if(!a.A.throwOnInvalid)return new m({invalid:r});throw new o.hq(r)}static fromDateTimes(e,t){var r,s;let a=(0,n.R)(e),o=(0,n.R)(t),i=(r=a,s=o,r&&r.isValid?s&&s.isValid?s<r?m.invalid("end before start",`The end of an interval must be after its start, but you had start=${r.toISO()} and end=${s.toISO()}`):null:m.invalid("missing or invalid end"):m.invalid("missing or invalid start"));return null==i?new m({start:a,end:o}):i}static after(e,t){let r=s.Ay.fromDurationLike(t),a=(0,n.R)(e);return m.fromDateTimes(a,a.plus(r))}static before(e,t){let r=s.Ay.fromDurationLike(t),a=(0,n.R)(e);return m.fromDateTimes(a.minus(r),a)}static fromISO(e,t){let[r,a]=(e||"").split("/",2);if(r&&a){let e,o,i,l;try{o=(e=n.A.fromISO(r,t)).isValid}catch(e){o=!1}try{l=(i=n.A.fromISO(a,t)).isValid}catch(e){l=!1}if(o&&l)return m.fromDateTimes(e,i);if(o){let r=s.Ay.fromISO(a,t);if(r.isValid)return m.after(e,r)}else if(l){let e=s.Ay.fromISO(r,t);if(e.isValid)return m.before(i,e)}}return m.invalid("unparsable",`the input "${e}" can't be parsed as ISO 8601`)}static isInterval(e){return e&&e.isLuxonInterval||!1}get start(){return this.isValid?this.s:null}get end(){return this.isValid?this.e:null}get isValid(){return null===this.invalidReason}get invalidReason(){return this.invalid?this.invalid.reason:null}get invalidExplanation(){return this.invalid?this.invalid.explanation:null}length(e="milliseconds"){return this.isValid?this.toDuration(e).get(e):NaN}count(e="milliseconds",t){let r;if(!this.isValid)return NaN;let n=this.start.startOf(e,t);return Math.floor((r=(r=t?.useLocaleWeeks?this.end.reconfigure({locale:n.locale}):this.end).startOf(e,t)).diff(n,e).get(e))+(r.valueOf()!==this.end.valueOf())}hasSame(e){return!!this.isValid&&(this.isEmpty()||this.e.minus(1).hasSame(this.s,e))}isEmpty(){return this.s.valueOf()===this.e.valueOf()}isAfter(e){return!!this.isValid&&this.s>e}isBefore(e){return!!this.isValid&&this.e<=e}contains(e){return!!this.isValid&&this.s<=e&&this.e>e}set({start:e,end:t}={}){return this.isValid?m.fromDateTimes(e||this.s,t||this.e):this}splitAt(...e){if(!this.isValid)return[];let t=e.map(n.R).filter(e=>this.contains(e)).sort((e,t)=>e.toMillis()-t.toMillis()),r=[],{s}=this,a=0;for(;s<this.e;){let e=t[a]||this.e,n=+e>+this.e?this.e:e;r.push(m.fromDateTimes(s,n)),s=n,a+=1}return r}splitBy(e){let t=s.Ay.fromDurationLike(e);if(!this.isValid||!t.isValid||0===t.as("milliseconds"))return[];let{s:r}=this,n=1,a,o=[];for(;r<this.e;){let e=this.start.plus(t.mapUnits(e=>e*n));a=+e>+this.e?this.e:e,o.push(m.fromDateTimes(r,a)),r=a,n+=1}return o}divideEqually(e){return this.isValid?this.splitBy(this.length()/e).slice(0,e):[]}overlaps(e){return this.e>e.s&&this.s<e.e}abutsStart(e){return!!this.isValid&&+this.e==+e.s}abutsEnd(e){return!!this.isValid&&+e.e==+this.s}engulfs(e){return!!this.isValid&&this.s<=e.s&&this.e>=e.e}equals(e){return!!this.isValid&&!!e.isValid&&this.s.equals(e.s)&&this.e.equals(e.e)}intersection(e){if(!this.isValid)return this;let t=this.s>e.s?this.s:e.s,r=this.e<e.e?this.e:e.e;return t>=r?null:m.fromDateTimes(t,r)}union(e){if(!this.isValid)return this;let t=this.s<e.s?this.s:e.s,r=this.e>e.e?this.e:e.e;return m.fromDateTimes(t,r)}static merge(e){let[t,r]=e.sort((e,t)=>e.s-t.s).reduce(([e,t],r)=>t?t.overlaps(r)||t.abutsStart(r)?[e,t.union(r)]:[e.concat([t]),r]:[e,r],[[],null]);return r&&t.push(r),t}static xor(e){let t=null,r=0,n=[],s=e.map(e=>[{time:e.s,type:"s"},{time:e.e,type:"e"}]);for(let e of Array.prototype.concat(...s).sort((e,t)=>e.time-t.time))1===(r+="s"===e.type?1:-1)?t=e.time:(t&&+t!=+e.time&&n.push(m.fromDateTimes(t,e.time)),t=null);return m.merge(n)}difference(...e){return m.xor([this].concat(e)).map(e=>this.intersection(e)).filter(e=>e&&!e.isEmpty())}toString(){return this.isValid?`[${this.s.toISO()} – ${this.e.toISO()})`:u}[Symbol.for("nodejs.util.inspect.custom")](){return this.isValid?`Interval { start: ${this.s.toISO()}, end: ${this.e.toISO()} }`:`Interval { Invalid, reason: ${this.invalidReason} }`}toLocaleString(e=c.aY,t={}){return this.isValid?l.A.create(this.s.loc.clone(t),e).formatInterval(this):u}toISO(e){return this.isValid?`${this.s.toISO(e)}/${this.e.toISO(e)}`:u}toISODate(){return this.isValid?`${this.s.toISODate()}/${this.e.toISODate()}`:u}toISOTime(e){return this.isValid?`${this.s.toISOTime(e)}/${this.e.toISOTime(e)}`:u}toFormat(e,{separator:t=" – "}={}){return this.isValid?`${this.s.toFormat(e)}${t}${this.e.toFormat(e)}`:u}toDuration(e,t){return this.isValid?this.e.diff(this.s,e,t):s.Ay.invalid(this.invalidReason)}mapEndpoints(e){return m.fromDateTimes(e(this.s),e(this.e))}}},353959(e,t,r){"use strict";r.d(t,{B:()=>l,G:()=>i});var n=r(812805),s=r(101292),a=r(132002);let o=s?.__esModule?s.default:s;class i extends Error{constructor(e,t,r){if(!Number.isInteger(e))throw Error('"code" must be an integer.');if(!t||"string"!=typeof t)throw Error('"message" must be a non-empty string.');(0,a.el)(r)?(super(t,{cause:r.cause}),(0,n.i5)(this,"cause")||Object.assign(this,{cause:r.cause})):super(t),void 0!==r&&(this.data=r),this.code=e}serialize(){let e={code:this.code,message:this.message};return void 0!==this.data&&(e.data=this.data,(0,n.Qd)(this.data)&&(e.data.cause=(0,a._K)(this.data.cause))),this.stack&&(e.stack=this.stack),e}toString(){return o(this.serialize(),c,2)}}class l extends i{constructor(e,t,r){if(!function(e){return Number.isInteger(e)&&e>=1e3&&e<=4999}(e))throw Error('"code" must be an integer such that: 1000 <= code <= 4999');super(e,t,r)}}function c(e,t){if("[Circular]"!==t)return t}},360023(e,t,r){"use strict";async function n(e,t){throw Error("Use of @sentry/browser's lazyLoadIntegration function is not supported by MetaMask Extension")}r.d(t,{b:()=>n})},360569(e,t,r){"use strict";r.d(t,{Ay:()=>v});var n=r(961520),s=r(925752),a=r(446655),o=r(640846),i=r(731318),l=r(316244),c=r(392134),u=r(347022);let m="Invalid Duration",d={weeks:{days:7,hours:168,minutes:10080,seconds:604800,milliseconds:6048e5},days:{hours:24,minutes:1440,seconds:86400,milliseconds:864e5},hours:{minutes:60,seconds:3600,milliseconds:36e5},minutes:{seconds:60,milliseconds:6e4},seconds:{milliseconds:1e3}},p={years:{quarters:4,months:12,weeks:52,days:365,hours:8760,minutes:525600,seconds:31536e3,milliseconds:31536e6},quarters:{months:3,weeks:13,days:91,hours:2184,minutes:131040,seconds:7862400,milliseconds:78624e5},months:{weeks:4,days:30,hours:720,minutes:43200,seconds:2592e3,milliseconds:2592e6},...d},h={years:{quarters:4,months:12,weeks:52.1775,days:365.2425,hours:8765.82,minutes:525949.2,seconds:0x1e18558,milliseconds:31556952e3},quarters:{months:3,weeks:13.044375,days:91.310625,hours:2191.455,minutes:131487.3,seconds:7889238,milliseconds:7889238e3},months:{weeks:30.436875/7,days:30.436875,hours:730.485,minutes:43829.1,seconds:2629746,milliseconds:2629746e3},...d},f=["years","quarters","months","weeks","days","hours","minutes","seconds","milliseconds"],g=f.slice(0).reverse();function y(e,t,r=!1){return new v({values:r?t.values:{...e.values,...t.values||{}},loc:e.loc.clone(t.loc),conversionAccuracy:t.conversionAccuracy||e.conversionAccuracy,matrix:t.matrix||e.matrix})}function b(e,t){let r=t.milliseconds??0;for(let n of g.slice(1))t[n]&&(r+=t[n]*e[n].milliseconds);return r}function k(e,t){let r=0>b(e,t)?-1:1;f.reduceRight((n,s)=>{if((0,l.b0)(t[s]))return n;if(n){let a=t[n]*r,o=e[s][n],i=Math.floor(a/o);t[s]+=i*r,t[n]-=i*o*r}return s},null),f.reduce((r,n)=>{if((0,l.b0)(t[n]))return r;if(r){let s=t[r]%1;t[r]-=s,t[n]+=s*e[r][n]}return n},null)}class v{constructor(e){let t="longterm"===e.conversionAccuracy,r=t?h:p;e.matrix&&(r=e.matrix),this.values=e.values,this.loc=e.loc||o.A.create(),this.conversionAccuracy=t?"longterm":"casual",this.invalid=e.invalid||null,this.matrix=r,this.isLuxonDuration=!0}static fromMillis(e,t){return v.fromObject({milliseconds:e},t)}static fromObject(e,t={}){if(null==e||"object"!=typeof e)throw new n.Di(`Duration.fromObject: argument expected to be an object, got ${null===e?"null":typeof e}`);return new v({values:(0,l.Fl)(e,v.normalizeUnit),loc:o.A.fromObject(t),conversionAccuracy:t.conversionAccuracy,matrix:t.matrix})}static fromDurationLike(e){if((0,l.Et)(e))return v.fromMillis(e);if(v.isDuration(e))return e;if("object"==typeof e)return v.fromObject(e);throw new n.Di(`Unknown duration argument ${e} of type ${typeof e}`)}static fromISO(e,t){let[r]=(0,i.rB)(e);return r?v.fromObject(r,t):v.invalid("unparsable",`the input "${e}" can't be parsed as ISO 8601`)}static fromISOTime(e,t){let[r]=(0,i.QE)(e);return r?v.fromObject(r,t):v.invalid("unparsable",`the input "${e}" can't be parsed as ISO 8601`)}static invalid(e,t=null){if(!e)throw new n.Di("need to specify a reason the Duration is invalid");let r=e instanceof a.A?e:new a.A(e,t);if(!c.A.throwOnInvalid)return new v({invalid:r});throw new n.Op(r)}static normalizeUnit(e){let t={year:"years",years:"years",quarter:"quarters",quarters:"quarters",month:"months",months:"months",week:"weeks",weeks:"weeks",day:"days",days:"days",hour:"hours",hours:"hours",minute:"minutes",minutes:"minutes",second:"seconds",seconds:"seconds",millisecond:"milliseconds",milliseconds:"milliseconds"}[e?e.toLowerCase():e];if(!t)throw new n.iq(e);return t}static isDuration(e){return e&&e.isLuxonDuration||!1}get locale(){return this.isValid?this.loc.locale:null}get numberingSystem(){return this.isValid?this.loc.numberingSystem:null}toFormat(e,t={}){let r={...t,floor:!1!==t.round&&!1!==t.floor};return this.isValid?s.A.create(this.loc,r).formatDurationFromString(this,e):m}toHuman(e={}){if(!this.isValid)return m;let t=f.map(t=>{let r=this.values[t];return(0,l.b0)(r)?null:this.loc.numberFormatter({style:"unit",unitDisplay:"long",...e,unit:t.slice(0,-1)}).format(r)}).filter(e=>e);return this.loc.listFormatter({type:"conjunction",style:e.listStyle||"narrow",...e}).format(t)}toObject(){return this.isValid?{...this.values}:{}}toISO(){if(!this.isValid)return null;let e="P";return 0!==this.years&&(e+=this.years+"Y"),(0!==this.months||0!==this.quarters)&&(e+=this.months+3*this.quarters+"M"),0!==this.weeks&&(e+=this.weeks+"W"),0!==this.days&&(e+=this.days+"D"),(0!==this.hours||0!==this.minutes||0!==this.seconds||0!==this.milliseconds)&&(e+="T"),0!==this.hours&&(e+=this.hours+"H"),0!==this.minutes&&(e+=this.minutes+"M"),(0!==this.seconds||0!==this.milliseconds)&&(e+=(0,l.GB)(this.seconds+this.milliseconds/1e3,3)+"S"),"P"===e&&(e+="T0S"),e}toISOTime(e={}){if(!this.isValid)return null;let t=this.toMillis();return t<0||t>=864e5?null:(e={suppressMilliseconds:!1,suppressSeconds:!1,includePrefix:!1,format:"extended",...e,includeOffset:!1},u.A.fromMillis(t,{zone:"UTC"}).toISOTime(e))}toJSON(){return this.toISO()}toString(){return this.toISO()}[Symbol.for("nodejs.util.inspect.custom")](){return this.isValid?`Duration { values: ${JSON.stringify(this.values)} }`:`Duration { Invalid, reason: ${this.invalidReason} }`}toMillis(){return this.isValid?b(this.matrix,this.values):NaN}valueOf(){return this.toMillis()}plus(e){if(!this.isValid)return this;let t=v.fromDurationLike(e),r={};for(let e of f)((0,l.mQ)(t.values,e)||(0,l.mQ)(this.values,e))&&(r[e]=t.get(e)+this.get(e));return y(this,{values:r},!0)}minus(e){if(!this.isValid)return this;let t=v.fromDurationLike(e);return this.plus(t.negate())}mapUnits(e){if(!this.isValid)return this;let t={};for(let r of Object.keys(this.values))t[r]=(0,l.i)(e(this.values[r],r));return y(this,{values:t},!0)}get(e){return this[v.normalizeUnit(e)]}set(e){return this.isValid?y(this,{values:{...this.values,...(0,l.Fl)(e,v.normalizeUnit)}}):this}reconfigure({locale:e,numberingSystem:t,conversionAccuracy:r,matrix:n}={}){return y(this,{loc:this.loc.clone({locale:e,numberingSystem:t}),matrix:n,conversionAccuracy:r})}as(e){return this.isValid?this.shiftTo(e).get(e):NaN}normalize(){if(!this.isValid)return this;let e=this.toObject();return k(this.matrix,e),y(this,{values:e},!0)}rescale(){return this.isValid?y(this,{values:function(e){let t={};for(let[r,n]of Object.entries(e))0!==n&&(t[r]=n);return t}(this.normalize().shiftToAll().toObject())},!0):this}shiftTo(...e){let t;if(!this.isValid||0===e.length)return this;e=e.map(e=>v.normalizeUnit(e));let r={},n={},s=this.toObject();for(let a of f)if(e.indexOf(a)>=0){t=a;let e=0;for(let t in n)e+=this.matrix[t][a]*n[t],n[t]=0;(0,l.Et)(s[a])&&(e+=s[a]);let o=Math.trunc(e);r[a]=o,n[a]=(1e3*e-1e3*o)/1e3}else(0,l.Et)(s[a])&&(n[a]=s[a]);for(let e in n)0!==n[e]&&(r[t]+=e===t?n[e]:n[e]/this.matrix[t][e]);return k(this.matrix,r),y(this,{values:r},!0)}shiftToAll(){return this.isValid?this.shiftTo("years","months","weeks","days","hours","minutes","seconds","milliseconds"):this}negate(){if(!this.isValid)return this;let e={};for(let t of Object.keys(this.values))e[t]=0===this.values[t]?0:-this.values[t];return y(this,{values:e},!0)}get years(){return this.isValid?this.values.years||0:NaN}get quarters(){return this.isValid?this.values.quarters||0:NaN}get months(){return this.isValid?this.values.months||0:NaN}get weeks(){return this.isValid?this.values.weeks||0:NaN}get days(){return this.isValid?this.values.days||0:NaN}get hours(){return this.isValid?this.values.hours||0:NaN}get minutes(){return this.isValid?this.values.minutes||0:NaN}get seconds(){return this.isValid?this.values.seconds||0:NaN}get milliseconds(){return this.isValid?this.values.milliseconds||0:NaN}get isValid(){return null===this.invalid}get invalidReason(){return this.invalid?this.invalid.reason:null}get invalidExplanation(){return this.invalid?this.invalid.explanation:null}equals(e){if(!this.isValid||!e.isValid||!this.loc.equals(e.loc))return!1;for(let n of f){var t,r;if(t=this.values[n],r=e.values[n],void 0===t||0===t?void 0!==r&&0!==r:t!==r)return!1}return!0}}},362705(e,t,r){"use strict";globalThis.stateHooks={},r(197434),r(5696)},367877(e,t,r){"use strict";r.d(t,{Q:()=>o});var n=r(85182),s=r(290264),a=r(191895);let o=(0,s._C)(()=>({name:"ModuleMetadata",setup(e){e.on("beforeEnvelope",e=>{(0,n.yH)(e,(e,t)=>{if("event"===t){let t=Array.isArray(e)?e[1]:void 0;t&&((0,a.KT)(t),e[1]=t)}})}),e.on("applyFrameMetadata",t=>{if(t.type)return;let r=e.getOptions().stackParser;(0,a.Gr)(r,t)})}}))},369735(e,t,r){"use strict";r.d(t,{i:()=>l});var n=r(96331),s=r(608119),a=r(107842),o=r(902419),i=r(845226);function l(){i.jf&&i.jf.document?i.jf.document.addEventListener("visibilitychange",()=>{let e=(0,s.Bk)();if(!e)return;let t=(0,s.zU)(e);if(i.jf.document.hidden&&t){let e="cancelled",{op:r,status:i}=(0,s.et)(t);o.T&&a.vF.log(`[Tracing] Transaction: ${e} -> since tab moved to the background, op: ${r}`),i||t.setStatus({code:n.TJ,message:e}),t.setAttribute("sentry.cancellation_reason","document.hidden"),t.end()}}):o.T&&a.vF.warn("[Tracing] Could not set up background tab detection due to lack of global document")}},384255(e,t,r){"use strict";r.d(t,{P:()=>i});var n=r(107842),s=r(97407),a=r(230337),o=r(25605);function i(e){let t="console";(0,o.s5)(t,e),(0,o.AS)(t,l)}function l(){"console"in a.O&&n.Ow.forEach(function(e){e in a.O.console&&(0,s.GS)(a.O.console,e,function(t){return n.Z9[e]=t,function(...t){(0,o.aj)("console",{args:t,level:e});let r=n.Z9[e];r&&r.apply(a.O.console,t)}})})}},388006(e,t,r){"use strict";r.d(t,{a3:()=>i,m7:()=>l,vQ:()=>c,vm:()=>o});var n=r(562298),s=r(107842);let a=r(230337).O;function o(){if(!("fetch"in a))return!1;try{return new Headers,new Request("http://www.example.com"),new Response,!0}catch(e){return!1}}function i(e){return e&&/^function\s+\w+\(\)\s+\{\s+\[native code\]\s+\}$/.test(e.toString())}function l(){if("string"==typeof EdgeRuntime)return!0;if(!o())return!1;if(i(a.fetch))return!0;let e=!1,t=a.document;if(t&&"function"==typeof t.createElement)try{let r=t.createElement("iframe");r.hidden=!0,t.head.appendChild(r),r.contentWindow&&r.contentWindow.fetch&&(e=i(r.contentWindow.fetch)),t.head.removeChild(r)}catch(e){n.T&&s.vF.warn("Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ",e)}return e}function c(){return"ReportingObserver"in a}},392134(e,t,r){"use strict";r.d(t,{A:()=>b});var n=r(493104),s=r(831022),a=r(640846),o=r(347022),i=r(419186),l=r(316244),c=r(938102);let u=()=>Date.now(),m="system",d=null,p=null,h=null,f=60,g,y=null;class b{static get now(){return u}static set now(e){u=e}static set defaultZone(e){m=e}static get defaultZone(){return(0,i.q)(m,n.A.instance)}static get defaultLocale(){return d}static set defaultLocale(e){d=e}static get defaultNumberingSystem(){return p}static set defaultNumberingSystem(e){p=e}static get defaultOutputCalendar(){return h}static set defaultOutputCalendar(e){h=e}static get defaultWeekSettings(){return y}static set defaultWeekSettings(e){y=(0,l._v)(e)}static get twoDigitCutoffYear(){return f}static set twoDigitCutoffYear(e){f=e%100}static get throwOnInvalid(){return g}static set throwOnInvalid(e){g=e}static resetCaches(){a.A.resetCache(),s.A.resetCache(),o.A.resetCache(),(0,c.wO)()}}},392248(e,t){var r,n,s;"undefined"!=typeof globalThis,s=function(e){"use strict";if("undefined"==typeof browser||Object.getPrototypeOf(browser)!==Object.prototype){if("object"!=typeof chrome||!chrome||!chrome.runtime||!chrome.runtime.id)throw Error("This script should only be loaded in a browser extension.");e.exports=(e=>{let t={alarms:{clear:{minArgs:0,maxArgs:1},clearAll:{minArgs:0,maxArgs:0},get:{minArgs:0,maxArgs:1},getAll:{minArgs:0,maxArgs:0}},bookmarks:{create:{minArgs:1,maxArgs:1},get:{minArgs:1,maxArgs:1},getChildren:{minArgs:1,maxArgs:1},getRecent:{minArgs:1,maxArgs:1},getSubTree:{minArgs:1,maxArgs:1},getTree:{minArgs:0,maxArgs:0},move:{minArgs:2,maxArgs:2},remove:{minArgs:1,maxArgs:1},removeTree:{minArgs:1,maxArgs:1},search:{minArgs:1,maxArgs:1},update:{minArgs:2,maxArgs:2}},browserAction:{disable:{minArgs:0,maxArgs:1,fallbackToNoCallback:!0},enable:{minArgs:0,maxArgs:1,fallbackToNoCallback:!0},getBadgeBackgroundColor:{minArgs:1,maxArgs:1},getBadgeText:{minArgs:1,maxArgs:1},getPopup:{minArgs:1,maxArgs:1},getTitle:{minArgs:1,maxArgs:1},openPopup:{minArgs:0,maxArgs:0},setBadgeBackgroundColor:{minArgs:1,maxArgs:1,fallbackToNoCallback:!0},setBadgeText:{minArgs:1,maxArgs:1,fallbackToNoCallback:!0},setIcon:{minArgs:1,maxArgs:1},setPopup:{minArgs:1,maxArgs:1,fallbackToNoCallback:!0},setTitle:{minArgs:1,maxArgs:1,fallbackToNoCallback:!0}},browsingData:{remove:{minArgs:2,maxArgs:2},removeCache:{minArgs:1,maxArgs:1},removeCookies:{minArgs:1,maxArgs:1},removeDownloads:{minArgs:1,maxArgs:1},removeFormData:{minArgs:1,maxArgs:1},removeHistory:{minArgs:1,maxArgs:1},removeLocalStorage:{minArgs:1,maxArgs:1},removePasswords:{minArgs:1,maxArgs:1},removePluginData:{minArgs:1,maxArgs:1},settings:{minArgs:0,maxArgs:0}},commands:{getAll:{minArgs:0,maxArgs:0}},contextMenus:{remove:{minArgs:1,maxArgs:1},removeAll:{minArgs:0,maxArgs:0},update:{minArgs:2,maxArgs:2}},cookies:{get:{minArgs:1,maxArgs:1},getAll:{minArgs:1,maxArgs:1},getAllCookieStores:{minArgs:0,maxArgs:0},remove:{minArgs:1,maxArgs:1},set:{minArgs:1,maxArgs:1}},devtools:{inspectedWindow:{eval:{minArgs:1,maxArgs:2,singleCallbackArg:!1}},panels:{create:{minArgs:3,maxArgs:3,singleCallbackArg:!0},elements:{createSidebarPane:{minArgs:1,maxArgs:1}}}},downloads:{cancel:{minArgs:1,maxArgs:1},download:{minArgs:1,maxArgs:1},erase:{minArgs:1,maxArgs:1},getFileIcon:{minArgs:1,maxArgs:2},open:{minArgs:1,maxArgs:1,fallbackToNoCallback:!0},pause:{minArgs:1,maxArgs:1},removeFile:{minArgs:1,maxArgs:1},resume:{minArgs:1,maxArgs:1},search:{minArgs:1,maxArgs:1},show:{minArgs:1,maxArgs:1,fallbackToNoCallback:!0}},extension:{isAllowedFileSchemeAccess:{minArgs:0,maxArgs:0},isAllowedIncognitoAccess:{minArgs:0,maxArgs:0}},history:{addUrl:{minArgs:1,maxArgs:1},deleteAll:{minArgs:0,maxArgs:0},deleteRange:{minArgs:1,maxArgs:1},deleteUrl:{minArgs:1,maxArgs:1},getVisits:{minArgs:1,maxArgs:1},search:{minArgs:1,maxArgs:1}},i18n:{detectLanguage:{minArgs:1,maxArgs:1},getAcceptLanguages:{minArgs:0,maxArgs:0}},identity:{launchWebAuthFlow:{minArgs:1,maxArgs:1}},idle:{queryState:{minArgs:1,maxArgs:1}},management:{get:{minArgs:1,maxArgs:1},getAll:{minArgs:0,maxArgs:0},getSelf:{minArgs:0,maxArgs:0},setEnabled:{minArgs:2,maxArgs:2},uninstallSelf:{minArgs:0,maxArgs:1}},notifications:{clear:{minArgs:1,maxArgs:1},create:{minArgs:1,maxArgs:2},getAll:{minArgs:0,maxArgs:0},getPermissionLevel:{minArgs:0,maxArgs:0},update:{minArgs:2,maxArgs:2}},pageAction:{getPopup:{minArgs:1,maxArgs:1},getTitle:{minArgs:1,maxArgs:1},hide:{minArgs:1,maxArgs:1,fallbackToNoCallback:!0},setIcon:{minArgs:1,maxArgs:1},setPopup:{minArgs:1,maxArgs:1,fallbackToNoCallback:!0},setTitle:{minArgs:1,maxArgs:1,fallbackToNoCallback:!0},show:{minArgs:1,maxArgs:1,fallbackToNoCallback:!0}},permissions:{contains:{minArgs:1,maxArgs:1},getAll:{minArgs:0,maxArgs:0},remove:{minArgs:1,maxArgs:1},request:{minArgs:1,maxArgs:1}},runtime:{getBackgroundPage:{minArgs:0,maxArgs:0},getPlatformInfo:{minArgs:0,maxArgs:0},openOptionsPage:{minArgs:0,maxArgs:0},requestUpdateCheck:{minArgs:0,maxArgs:0},sendMessage:{minArgs:1,maxArgs:3},sendNativeMessage:{minArgs:2,maxArgs:2},setUninstallURL:{minArgs:1,maxArgs:1}},sessions:{getDevices:{minArgs:0,maxArgs:1},getRecentlyClosed:{minArgs:0,maxArgs:1},restore:{minArgs:0,maxArgs:1}},storage:{local:{clear:{minArgs:0,maxArgs:0},get:{minArgs:0,maxArgs:1},getBytesInUse:{minArgs:0,maxArgs:1},remove:{minArgs:1,maxArgs:1},set:{minArgs:1,maxArgs:1}},managed:{get:{minArgs:0,maxArgs:1},getBytesInUse:{minArgs:0,maxArgs:1}},sync:{clear:{minArgs:0,maxArgs:0},get:{minArgs:0,maxArgs:1},getBytesInUse:{minArgs:0,maxArgs:1},remove:{minArgs:1,maxArgs:1},set:{minArgs:1,maxArgs:1}}},tabs:{captureVisibleTab:{minArgs:0,maxArgs:2},create:{minArgs:1,maxArgs:1},detectLanguage:{minArgs:0,maxArgs:1},discard:{minArgs:0,maxArgs:1},duplicate:{minArgs:1,maxArgs:1},executeScript:{minArgs:1,maxArgs:2},get:{minArgs:1,maxArgs:1},getCurrent:{minArgs:0,maxArgs:0},getZoom:{minArgs:0,maxArgs:1},getZoomSettings:{minArgs:0,maxArgs:1},goBack:{minArgs:0,maxArgs:1},goForward:{minArgs:0,maxArgs:1},highlight:{minArgs:1,maxArgs:1},insertCSS:{minArgs:1,maxArgs:2},move:{minArgs:2,maxArgs:2},query:{minArgs:1,maxArgs:1},reload:{minArgs:0,maxArgs:2},remove:{minArgs:1,maxArgs:1},removeCSS:{minArgs:1,maxArgs:2},sendMessage:{minArgs:2,maxArgs:3},setZoom:{minArgs:1,maxArgs:2},setZoomSettings:{minArgs:1,maxArgs:2},update:{minArgs:1,maxArgs:2}},topSites:{get:{minArgs:0,maxArgs:0}},webNavigation:{getAllFrames:{minArgs:1,maxArgs:1},getFrame:{minArgs:1,maxArgs:1}},webRequest:{handlerBehaviorChanged:{minArgs:0,maxArgs:0}},windows:{create:{minArgs:0,maxArgs:1},get:{minArgs:1,maxArgs:2},getAll:{minArgs:0,maxArgs:1},getCurrent:{minArgs:0,maxArgs:1},getLastFocused:{minArgs:0,maxArgs:1},remove:{minArgs:1,maxArgs:1},update:{minArgs:2,maxArgs:2}}};if(0===Object.keys(t).length)throw Error("api-metadata.json has not been included in browser-polyfill");class r extends WeakMap{constructor(e,t){super(t),this.createItem=e}get(e){return this.has(e)||this.set(e,this.createItem(e)),super.get(e)}}let n=(t,r)=>(...n)=>{e.runtime.lastError?t.reject(Error(e.runtime.lastError.message)):r.singleCallbackArg||n.length<=1&&!1!==r.singleCallbackArg?t.resolve(n[0]):t.resolve(n)},s=e=>1==e?"argument":"arguments",a=(e,t,r)=>new Proxy(t,{apply:(t,n,s)=>r.call(n,e,...s)}),o=Function.call.bind(Object.prototype.hasOwnProperty),i=(e,t={},r={})=>{let l=Object.create(null);return new Proxy(Object.create(e),{has:(t,r)=>r in e||r in l,get(c,u,m){if(u in l)return l[u];if(!(u in e))return;let d=e[u];if("function"==typeof d)if("function"==typeof t[u])d=a(e,e[u],t[u]);else if(o(r,u)){let t,o=(t=r[u],function(e,...r){if(r.length<t.minArgs)throw Error(`Expected at least ${t.minArgs} ${s(t.minArgs)} for ${u}(), got ${r.length}`);if(r.length>t.maxArgs)throw Error(`Expected at most ${t.maxArgs} ${s(t.maxArgs)} for ${u}(), got ${r.length}`);return new Promise((s,a)=>{if(t.fallbackToNoCallback)try{e[u](...r,n({resolve:s,reject:a},t))}catch(n){console.warn(`${u} API method doesn't seem to support the callback parameter, falling back to call it without a callback: `,n),e[u](...r),t.fallbackToNoCallback=!1,t.noCallback=!0,s()}else t.noCallback?(e[u](...r),s()):e[u](...r,n({resolve:s,reject:a},t))})});d=a(e,e[u],o)}else d=d.bind(e);else if("object"==typeof d&&null!==d&&(o(t,u)||o(r,u)))d=i(d,t[u],r[u]);else{if(!o(r,"*"))return Object.defineProperty(l,u,{configurable:!0,enumerable:!0,get:()=>e[u],set(t){e[u]=t}}),d;d=i(d,t[u],r["*"])}return l[u]=d,d},set:(t,r,n,s)=>(r in l?l[r]=n:e[r]=n,!0),defineProperty:(e,t,r)=>Reflect.defineProperty(l,t,r),deleteProperty:(e,t)=>Reflect.deleteProperty(l,t)})},l=e=>({addListener(t,r,...n){t.addListener(e.get(r),...n)},hasListener:(t,r)=>t.hasListener(e.get(r)),removeListener(t,r){t.removeListener(e.get(r))}}),c=new r(e=>"function"!=typeof e?e:function(t){e(i(t,{},{getContent:{minArgs:0,maxArgs:0}}))}),u=!1,m=new r(e=>"function"!=typeof e?e:function(t,r,n){let s,a,o,i=!1,l=new Promise(e=>{a=function(t){u||(console.warn("Returning a Promise is the preferred way to send a reply from an onMessage/onMessageExternal listener, as the sendResponse will be removed from the specs (See https://developer.mozilla.org/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage)",Error().stack),u=!0),i=!0,e(t)}});try{o=e(t,r,a)}catch(e){o=Promise.reject(e)}let c=!0!==o&&(s=o)&&"object"==typeof s&&"function"==typeof s.then;if(!0!==o&&!c&&!i)return!1;return(c?o:l).then(e=>{n(e)},e=>{n({__mozWebExtensionPolyfillReject__:!0,message:e&&(e instanceof Error||"string"==typeof e.message)?e.message:"An unexpected error occurred"})}).catch(e=>{console.error("Failed to send onMessage rejected reply",e)}),!0}),d=({reject:t,resolve:r},n)=>{e.runtime.lastError?"The message port closed before a response was received."===e.runtime.lastError.message?r():t(Error(e.runtime.lastError.message)):n&&n.__mozWebExtensionPolyfillReject__?t(Error(n.message)):r(n)},p=(e,t,r,...n)=>{if(n.length<t.minArgs)throw Error(`Expected at least ${t.minArgs} ${s(t.minArgs)} for ${e}(), got ${n.length}`);if(n.length>t.maxArgs)throw Error(`Expected at most ${t.maxArgs} ${s(t.maxArgs)} for ${e}(), got ${n.length}`);return new Promise((e,t)=>{let s=d.bind(null,{resolve:e,reject:t});n.push(s),r.sendMessage(...n)})},h={devtools:{network:{onRequestFinished:l(c)}},runtime:{onMessage:l(m),onMessageExternal:l(m),sendMessage:p.bind(null,"sendMessage",{minArgs:1,maxArgs:3})},tabs:{sendMessage:p.bind(null,"sendMessage",{minArgs:2,maxArgs:3})}},f={clear:{minArgs:1,maxArgs:1},get:{minArgs:1,maxArgs:1},set:{minArgs:1,maxArgs:1}};return t.privacy={network:{"*":f},services:{"*":f},websites:{"*":f}},i(e,h,t)})(chrome)}else e.exports=browser},r=[e],void 0===(n=s.apply(t,r))||(e.exports=n)},392788(e,t,r){"use strict";r.d(t,{c:()=>h});var n=r(714599),s=r(793111),a=r(933190),o=r(290264),i=r(719509),l=r(230337),c=r(821016),u=r(107842),m=r(696294),d=r(388006),p=r(902419);let h=(0,o._C)((e={})=>{let t={failedRequestStatusCodes:[[500,599]],failedRequestTargets:[/.*/],...e};return{name:"HttpClient",setup(e){var r,o,i,m;r=e,o=t,(0,d.m7)()&&(0,c.ur)(e=>{if((0,a.KU)()!==r)return;let{response:t,args:n}=e,[i,l]=n;t&&function(e,t,r,n){if(y(e,r.status,r.url)){var a,o;let e,i,l,c,u=(a=t,!(o=n)&&a instanceof Request||a instanceof Request&&a.bodyUsed?a:new Request(a,o));k()&&([e,l]=f("Cookie",u),[i,c]=f("Set-Cookie",r));let m=b({url:u.url,method:u.method,status:r.status,requestHeaders:e,responseHeaders:i,requestCookies:l,responseCookies:c});(0,s.r)(m)}}(o,i,t,l)}),i=e,m=t,"XMLHttpRequest"in l.O&&(0,n.Mn)(e=>{if((0,a.KU)()!==i)return;let t=e.xhr,r=t[n.Er];if(!r)return;let{method:o,request_headers:l}=r;try{!function(e,t,r,n){if(y(e,t.status,t.responseURL)){let e,a,o;if(k()){try{let e=t.getResponseHeader("Set-Cookie")||t.getResponseHeader("set-cookie")||void 0;e&&(a=g(e))}catch(e){p.T&&u.vF.log("Could not extract cookies from response headers")}try{o=function(e){let t=e.getAllResponseHeaders();return t?t.split(`\r
`).reduce((e,t)=>{let[r,n]=t.split(": ");return r&&n&&(e[r]=n),e},{}):{}}(t)}catch(e){p.T&&u.vF.log("Could not extract headers from response")}e=n}let i=b({url:t.responseURL,method:r,status:t.status,requestHeaders:e,responseHeaders:o,responseCookies:a});(0,s.r)(i)}}(m,t,o,l)}catch(e){p.T&&u.vF.warn("Error while extracting response event form XHR response",e)}})}}});function f(e,t){let r,n=function(e){let t={};return e.forEach((e,r)=>{t[r]=e}),t}(t.headers);try{let t=n[e]||n[e.toLowerCase()]||void 0;t&&(r=g(t))}catch(t){p.T&&u.vF.log(`Could not extract cookies from header ${e}`)}return[n,r]}function g(e){return e.split("; ").reduce((e,t)=>{let[r,n]=t.split("=");return r&&n&&(e[r]=n),e},{})}function y(e,t,r){var n,s;return n=e.failedRequestStatusCodes,n.some(e=>"number"==typeof e?e===t:t>=e[0]&&t<=e[1])&&(s=e.failedRequestTargets,s.some(e=>"string"==typeof e?r.includes(e):e.test(r)))&&!(0,i.A)(r,(0,a.KU)())}function b(e){let t=`HTTP Client Error with status code: ${e.status}`,r={message:t,exception:{values:[{type:"Error",value:t}]},request:{url:e.url,method:e.method,headers:e.requestHeaders,cookies:e.requestCookies},contexts:{response:{status_code:e.status,headers:e.responseHeaders,cookies:e.responseCookies,body_size:function(e){if(e){let t=e["Content-Length"]||e["content-length"];if(t)return parseInt(t,10)}}(e.responseHeaders)}}};return(0,m.M6)(r,{type:"http.client",handled:!1}),r}function k(){let e=(0,a.KU)();return!!e&&!!e.getOptions().sendDefaultPii}},397718(e,t,r){"use strict";r.d(t,{BD:()=>i,Kg:()=>c,L2:()=>k,NF:()=>u,Qd:()=>d,Qg:()=>g,T2:()=>o,W6:()=>l,bJ:()=>s,gd:()=>f,mE:()=>y,sO:()=>m,tH:()=>b,vq:()=>h,xH:()=>p});let n=Object.prototype.toString;function s(e){switch(n.call(e)){case"[object Error]":case"[object Exception]":case"[object DOMException]":return!0;default:return b(e,Error)}}function a(e,t){return n.call(e)===`[object ${t}]`}function o(e){return a(e,"ErrorEvent")}function i(e){return a(e,"DOMError")}function l(e){return a(e,"DOMException")}function c(e){return a(e,"String")}function u(e){return"object"==typeof e&&null!==e&&"__sentry_template_string__"in e&&"__sentry_template_values__"in e}function m(e){return null===e||u(e)||"object"!=typeof e&&"function"!=typeof e}function d(e){return a(e,"Object")}function p(e){return"undefined"!=typeof Event&&b(e,Event)}function h(e){return"undefined"!=typeof Element&&b(e,Element)}function f(e){return a(e,"RegExp")}function g(e){return!!(e&&e.then&&"function"==typeof e.then)}function y(e){return d(e)&&"nativeEvent"in e&&"preventDefault"in e&&"stopPropagation"in e}function b(e,t){try{return e instanceof t}catch(e){return!1}}function k(e){return!!("object"==typeof e&&null!==e&&(e.__isVue||e._isVue))}},405971(e,t,r){"use strict";r.d(t,{y:()=>i});var n=r(680985),s=r(85182),a=r(290264),o=r(191895);let i=(0,a._C)(e=>({name:"ThirdPartyErrorsFilter",setup(e){e.on("beforeEnvelope",e=>{(0,s.yH)(e,(e,t)=>{if("event"===t){let t=Array.isArray(e)?e[1]:void 0;t&&((0,o.KT)(t),e[1]=t)}})}),e.on("applyFrameMetadata",t=>{if(t.type)return;let r=e.getOptions().stackParser;(0,o.Gr)(r,t)})},processEvent(t){let r=function(e){let t=(0,n.RV)(e);if(t)return t.filter(e=>!!e.filename).map(e=>e.module_metadata?Object.keys(e.module_metadata).filter(e=>e.startsWith(l)).map(e=>e.slice(l.length)):[])}(t);if(r&&r["drop-error-if-contains-third-party-frames"===e.behaviour||"apply-tag-if-contains-third-party-frames"===e.behaviour?"some":"every"](t=>!t.some(t=>e.filterKeys.includes(t)))){if("drop-error-if-contains-third-party-frames"===e.behaviour||"drop-error-if-exclusively-contains-third-party-frames"===e.behaviour)return null;t.tags={...t.tags,third_party_code:!0}}return t}})),l="_sentryBundlerPluginAppKey:"},406097(e,t,r){"use strict";r.d(t,{l:()=>m});var n=r(956742),s=r(132076),a=r(495242),o=r(898026),i=r(259463),l=r(533858),c=r(681747);let u=[100,300],m=(e,t={})=>{(0,c.I)(()=>{let r,c=(0,s.N)(),m=(0,a.X)("FID"),d=e=>{e.startTime<c.firstHiddenTime&&(m.value=e.processingStart-e.startTime,m.entries.push(e),r(!0))},p=e=>{e.forEach(d)},h=(0,o.l)("first-input",p);r=(0,n.R)(e,m,u,t.reportAllChanges),h&&(0,i.Q)((0,l.J)(()=>{p(h.takeRecords()),h.disconnect()}))})}},411554(e,t,r){"use strict";r.d(t,{au:()=>s});var n=r(448967);function s(e,t,r){return new n._k({...e,coercer:(s,a)=>(0,n.is)(s,t)?e.coercer(r(s,a),a):e.coercer(s,a)})}},414221(e,t,r){"use strict";r.d(t,{z:()=>i});var n=r(290266),s=r(545203),a=r(728195),o=r(157392);let i=(0,s.kp)(o.Wu,(0,n.Ik)({type:(0,a.eu)(o.Z6.Divider)}))},417860(e,t,r){"use strict";r.d(t,{I:()=>m});var s=r(956742),a=r(495242),o=r(898026),i=r(259463),l=r(533858),c=r(327140);let u=[.1,.25],m=(e,t={})=>{(0,c.z)((0,l.J)(()=>{let r,l=(0,a.X)("CLS",0),c=0,m=[],d=e=>{e.forEach(e=>{if(!e.hadRecentInput){let t=m[0],r=m[m.length-1];c&&t&&r&&e.startTime-r.startTime<1e3&&e.startTime-t.startTime<5e3?(c+=e.value,m.push(e)):(c=e.value,m=[e])}}),c>l.value&&(l.value=c,l.entries=m,r())},p=(0,o.l)("layout-shift",d);p&&(r=(0,s.R)(e,l,u,t.reportAllChanges),(0,i.Q)(()=>{d(p.takeRecords()),r(!0)}),n(r,0))}))}},418920(e,t,r){"use strict";r.d(t,{w:()=>n.w});var n=r(293889)},419186(e,t,r){"use strict";r.d(t,{q:()=>c});var n=r(283707),s=r(831022),a=r(794204),o=r(451798),i=r(316244),l=r(493104);function c(e,t){if((0,i.b0)(e)||null===e)return t;if(e instanceof n.A)return e;if((0,i.Kg)(e)){let r=e.toLowerCase();return"default"===r?t:"local"===r||"system"===r?l.A.instance:"utc"===r||"gmt"===r?a.A.utcInstance:a.A.parseSpecifier(r)||s.A.create(e)}if((0,i.Et)(e))return a.A.instance(e);if("object"==typeof e&&"offset"in e&&"function"==typeof e.offset)return e;else return new o.A(e)}},424264(e,t,r){"use strict";r.d(t,{B:()=>a});var n=r(851338),s=r(230337);function a(){return"undefined"!=typeof window&&(!(0,n.wD)()||void 0!==s.O.process&&"renderer"===s.O.process.type)}},425535(e,t,r){"use strict";function n(e,t=Date.now()){let r=parseInt(`${e}`,10);if(!isNaN(r))return 1e3*r;let s=Date.parse(`${e}`);return isNaN(s)?6e4:s-t}function s(e,t,r=Date.now()){return(e[t]||e.all||0)>r}function a(e,{statusCode:t,headers:r},s=Date.now()){let o={...e},i=r&&r["x-sentry-rate-limits"],l=r&&r["retry-after"];if(i)for(let e of i.trim().split(",")){let[t,r,,,n]=e.split(":",5),a=parseInt(t,10),i=(isNaN(a)?60:a)*1e3;if(r)for(let e of r.split(";"))"metric_bucket"===e?(!n||n.split(";").includes("custom"))&&(o[e]=s+i):o[e]=s+i;else o.all=s+i}else l?o.all=s+n(l,s):429===t&&(o.all=s+6e4);return o}r.d(t,{FA:()=>n,Jz:()=>s,wq:()=>a})},434322(e,t,r){"use strict";r.d(t,{$:()=>s});var n,s,a=r(300005);(n=s||(s={})).Accessibility="accessibility",n.Activity="activity",n.AddCard="add-card",n.AddCircle="add-circle",n.AddSquare="add-square",n.Add="add",n.Ai="ai",n.AlternateEmail="alternate-email",n.Apple="apple",n.Apps="apps",n.Arrow2Down="arrow-2-down",n.Arrow2Left="arrow-2-left",n.Arrow2Right="arrow-2-right",n.Arrow2UpRight="arrow-2-up-right",n.Arrow2Up="arrow-2-up",n.ArrowCircleDown="arrow-circle-down",n.ArrowCircleUp="arrow-circle-up",n.ArrowDoubleLeft="arrow-double-left",n.ArrowDoubleRight="arrow-double-right",n.ArrowDown="arrow-down",n.ArrowDropDownCircle="arrow-drop-down-circle",n.ArrowLeft="arrow-left",n.ArrowRight="arrow-right",n.ArrowUp="arrow-up",n.Attachment="attachment",n.Ban="ban",n.BankAssured="bank-assured",n.Bank="bank",n.Bold="bold",n.Book="book",n.Bookmark="bookmark",n.Bridge="bridge",n.Briefcase="briefcase",n.Bulb="bulb",n.BuySell="buy-sell",n.Cake="cake",n.Calculator="calculator",n.Calendar="calendar",n.Call="call",n.Camera="camera",n.Campaign="campaign",n.CardPos="card-pos",n.Card="card",n.Cash="cash",n.Category="category",n.Chart="chart",n.CheckBold="check-bold",n.Check="check",n.CircleX="circle-x",n.ClockFilled="clock-filled",n.Clock="clock",n.Close="close",n.CloudDownload="cloud-download",n.CloudUpload="cloud-upload",n.Cloud="cloud",n.CodeCircle="code-circle",n.Code="code",n.Coin="coin",n.Collapse="collapse",n.Confirmation="confirmation",n.Connect="connect",n.CopySuccess="copy-success",n.Copy="copy",n.CreditCheck="credit-check",n.CurrencyFranc="currency-franc",n.CurrencyLira="currency-lira",n.CurrencyPound="currency-pound",n.CurrencyYuan="currency-yuan",n.Customize="customize",n.Danger="danger",n.DarkFilled="dark-filled",n.Dark="dark",n.Data="data",n.Description="description",n.Details="details",n.Diagram="diagram",n.DocumentCode="document-code",n.Download="download",n.Draft="draft",n.EcoLeaf="eco-leaf",n.EditSquare="edit-square",n.Edit="edit",n.EncryptedAdd="encrypted-add",n.Eraser="eraser",n.Error="error",n.Ethereum="ethereum",n.Exchange="exchange",n.ExpandVertical="expand-vertical",n.Expand="expand",n.ExploreFilled="explore-filled",n.Explore="explore",n.Export="export",n.Extension="extension",n.EyeSlash="eye-slash",n.Eye="eye",n.FaceId="face-id",n.Feedback="feedback",n.File="file",n.Filter="filter",n.Fingerprint="fingerprint",n.Fire="fire",n.FirstPage="first-page",n.Flag="flag",n.FlashSlash="flash-slash",n.Flash="flash",n.Flask="flask",n.Flower="flower",n.Folder="folder",n.Forest="forest",n.FullCircle="full-circle",n.Gas="gas",n.Gift="gift",n.GlobalSearch="global-search",n.Global="global",n.Graph="graph",n.Hardware="hardware",n.HashTag="hash-tag",n.HeartFilled="heart-filled",n.Heart="heart",n.Hierarchy="hierarchy",n.HomeFilled="home-filled",n.Home="home",n.Image="image",n.Info="info",n.Inventory="inventory",n.Joystick="joystick",n.KeepFilled="keep-filled",n.Keep="keep",n.Key="key",n.LastPage="last-page",n.LightFilled="light-filled",n.Light="light",n.Link="link",n.Loading="loading",n.Location="location",n.LockSlash="lock-slash",n.Lock="lock",n.LockedFilled="locked-filled",n.Login="login",n.Logout="logout",n.Mail="mail",n.Map="map",n.Menu="menu",n.MessageQuestion="message-question",n.Messages="messages",n.Mic="mic",n.MinusBold="minus-bold",n.MinusSquare="minus-square",n.Minus="minus",n.Mobile="mobile",n.MoneyBag="money-bag",n.Money="money",n.Monitor="monitor",n.MoreHorizontal="more-horizontal",n.MoreVertical="more-vertical",n.MountainFlag="mountain-flag",n.MusicNote="music-note",n.Notification="notification",n.PageInfo="page-info",n.Palette="palette",n.PasswordCheck="password-check",n.Pending="pending",n.People="people",n.PersonCancel="person-cancel",n.Pin="pin",n.Plant="plant",n.Plug="plug",n.PlusAndMinus="plus-and-minus",n.PolicyAlert="policy-alert",n.Print="print",n.PriorityHigh="priority-high",n.PrivacyTip="privacy-tip",n.ProgrammingArrows="programming-arrows",n.Publish="publish",n.QrCode="qr-code",n.Question="question",n.Receive="receive",n.Received="received",n.Refresh="refresh",n.RemoveMinus="remove-minus",n.Report="report",n.Rocket="rocket",n.SaveFilled="save-filled",n.Save="save",n.Saving="saving",n.ScanBarcode="scan-barcode",n.ScanFocus="scan-focus",n.Scan="scan",n.Search="search",n.SecurityAlert="security-alert",n.SecurityCross="security-cross",n.SecurityKey="security-key",n.SecuritySearch="security-search",n.SecuritySlash="security-slash",n.SecurityTick="security-tick",n.SecurityTime="security-time",n.SecurityUser="security-user",n.Security="security",n.Send="send",n.SentimentDissatisfied="sentiment-dissatisfied",n.SentimentNeutral="sentiment-neutral",n.SentimentSatisfied="sentiment-satisfied",n.SentimentVerySatisfied="sentiment-very-satisfied",n.SettingFilled="setting-filled",n.Setting="setting",n.Share="share",n.ShieldLock="shield-lock",n.ShoppingBag="shopping-bag",n.ShoppingCart="shopping-cart",n.SignalCellular="signal-cellular",n.Slash="slash",n.Sms="sms",n.SnapsMobile="snaps-mobile",n.SnapsPlus="snaps-plus",n.SnapsRound="snaps-round",n.Snaps="snaps",n.SortByAlpha="sort-by-alpha",n.Sort="sort",n.Sparkle="sparkle",n.Speed="speed",n.Speedometer="speedometer",n.Square="square",n.Stake="stake",n.StarFilled="star-filled",n.Star="star",n.Start="start",n.Storefront="storefront",n.Student="student",n.SwapHorizontal="swap-horizontal",n.SwapVertical="swap-vertical",n.TabClose="tab-close",n.TableRow="table-row",n.Tablet="tablet",n.Tag="tag",n.ThumbDownFilled="thumb-down-filled",n.ThumbDown="thumb-down",n.ThumbUpFilled="thumb-up-filled",n.ThumbUp="thumb-up",n.Tint="tint",n.Tooltip="tooltip",n.Translate="translate",n.Trash="trash",n.TrendDown="trend-down",n.TrendUp="trend-up",n.TriangleUp="triangle-up",n.TriangleDown="triangle-down",n.Undo="undo",n.Unfold="unfold",n.UnlockedFilled="unlocked-filled",n.Unpin="unpin",n.UploadFile="upload-file",n.Upload="upload",n.Usb="usb",n.UserCheck="user-check",n.UserCircleAdd="user-circle-add",n.UserCircleRemove="user-circle-remove",n.UserCircle="user-circle",n.User="user",n.VerifiedFilled="verified-filled",n.Verified="verified",n.Videocam="videocam",n.ViewColumn="view-column",n.ViewInAr="view-in-ar",n.VolumeOff="volume-off",n.VolumeUp="volume-up",n.WalletFilled="wallet-filled",n.Wallet="wallet",n.Warning="warning",n.WebTraffic="web-traffic",n.Widgets="widgets",n.WifiOff="wifi-off",n.Wifi="wifi",n.X="x",(0,a.K)("Icon")},434878(e,t,r){"use strict";r.d(t,{rW:()=>h});var n=r(462105),s=r(441099),a=r(711210),o=r(721117),i=r(728195),l=r(78121),c=r(448967),u=r(652825),m=r(290266),d=r(812805);let p="snap_dialog",h={[o.h.Alert]:`${p}:alert`,[o.h.Confirmation]:`${p}:confirmation`,[o.h.Prompt]:`${p}:prompt`,default:p},f=(0,m.lq)((0,u.Ej)((0,m.Yj)(),1,40));Object.freeze({targetName:p,specificationBuilder:({allowedCaveats:e=null,messenger:t})=>({permissionType:n.eZ.RestrictedMethod,targetName:p,allowedCaveats:e,methodImplementation:function({messenger:e}){return async function(t){let{params:r,context:{origin:n}}=t;if(!(0,d.Gv)(r))throw a.r.invalidParams({message:"Invalid params: Expected params to be a single object."});let s=function(e){try{return(0,c.vt)(e,A)}catch(e){throw a.r.invalidParams({message:`Invalid params: ${e.message}`})}}(r),i=!function(e){return((0,d.i5)(e,"type")?e.type:void 0)===o.h.Prompt}(s)?void 0:s.placeholder,l=h[(0,d.i5)(s,"type")?s.type:"default"];if((0,d.i5)(s,"content")){let t=e.call("SnapInterfaceController:createInterface",n,s.content);return e.call("SnapInterfaceController:setInterfaceDisplayed",n,t),e.call("ApprovalController:addRequest",{id:l===h.default?t:void 0,origin:n,type:l,requestData:{id:t,placeholder:i}},!0)}return function(e,t,r){try{r.call("SnapInterfaceController:getInterface",e,t)}catch(e){throw a.r.invalidParams({message:`Invalid params: ${e.message}`})}}(n,s.id,e),e.call("SnapInterfaceController:setInterfaceDisplayed",n,s.id),e.call("ApprovalController:addRequest",{id:l===h.default?s.id:void 0,origin:n,type:l,requestData:{id:s.id,placeholder:i}},!0)}}({messenger:t}),subjectTypes:[s.P.Snap]}),actionNames:["ApprovalController:addRequest","SnapInterfaceController:createInterface","SnapInterfaceController:getInterface","SnapInterfaceController:setInterfaceDisplayed"]});let g=(0,m.Ik)({type:(0,i.$9)(o.h.Alert),content:l.Qi}),y=(0,m.Ik)({type:(0,i.$9)(o.h.Alert),id:(0,m.Yj)()}),b=(0,i.E$)(e=>(0,d.Qd)(e)&&(0,d.i5)(e,"id")?y:g),k=(0,m.Ik)({type:(0,i.$9)(o.h.Confirmation),content:l.Qi}),v=(0,m.Ik)({type:(0,i.$9)(o.h.Confirmation),id:(0,m.Yj)()}),_=(0,i.E$)(e=>(0,d.Qd)(e)&&(0,d.i5)(e,"id")?v:k),w=(0,m.Ik)({type:(0,i.$9)(o.h.Prompt),content:l.Qi,placeholder:f}),x=(0,m.Ik)({type:(0,i.$9)(o.h.Prompt),id:(0,m.Yj)(),placeholder:f}),S=(0,i.E$)(e=>(0,d.Qd)(e)&&(0,d.i5)(e,"id")?x:w),E=(0,m.Ik)({content:l.Qi}),j=(0,m.Ik)({id:(0,m.Yj)()}),T=(0,i.E$)(e=>(0,d.Qd)(e)&&(0,d.i5)(e,"id")?j:E),A=(0,i.E$)(e=>{if((0,d.Qd)(e)&&(0,d.i5)(e,"type"))switch(e.type){case o.h.Alert:return b;case o.h.Confirmation:return _;case o.h.Prompt:return S;default:throw Error(`The "type" property must be one of: ${Object.values(o.h).join(", ")}.`)}return T})},438774(e,t,r){"use strict";r.d(t,{V:()=>w});var n=r(895315),s=r(16786),a=r(397718),o=r(107842),i=r(696294),l=r(97407),c=r(586312),u=r(85182),m=r(494945),d=r(76838),p=r(933190),h=r(67904),f=r(179184),g=r(290264),y=r(597014),b=r(836164),k=r(768881),v=r(884405);let _="Not capturing exception because it's already been captured.";class w{constructor(e){if(this._options=e,this._integrations={},this._numProcessing=0,this._outcomes={},this._hooks={},this._eventProcessors=[],e.dsn?this._dsn=(0,n.AD)(e.dsn):h.T&&o.vF.warn("No DSN provided, client will not send events."),this._dsn){let t=(0,d.Z)(this._dsn,e.tunnel,e._metadata?e._metadata.sdk:void 0);this._transport=e.transport({tunnel:this._options.tunnel,recordDroppedEvent:this.recordDroppedEvent.bind(this),...e.transportOptions,url:t})}}captureException(e,t,r){let n=(0,i.eJ)();if((0,i.GR)(e))return h.T&&o.vF.log(_),n;let s={event_id:n,...t};return this._process(this.eventFromException(e,s).then(e=>this._captureEvent(e,s,r))),s.event_id}captureMessage(e,t,r,n){let s={event_id:(0,i.eJ)(),...r},o=(0,a.NF)(e)?e:String(e),l=(0,a.sO)(e)?this.eventFromMessage(o,t,s):this.eventFromException(e,s);return this._process(l.then(e=>this._captureEvent(e,s,n))),s.event_id}captureEvent(e,t,r){let n=(0,i.eJ)();if(t&&t.originalException&&(0,i.GR)(t.originalException))return h.T&&o.vF.log(_),n;let s={event_id:n,...t},a=(e.sdkProcessingMetadata||{}).capturedSpanScope;return this._process(this._captureEvent(e,s,a||r)),s.event_id}captureSession(e){"string"!=typeof e.release?h.T&&o.vF.warn("Discarded session because of missing or non-string release"):(this.sendSession(e),(0,y.qO)(e,{init:!1}))}getDsn(){return this._dsn}getOptions(){return this._options}getSdkMetadata(){return this._options._metadata}getTransport(){return this._transport}flush(e){let t=this._transport;return t?(this.emit("flush"),this._isClientDoneProcessing(e).then(r=>t.flush(e).then(e=>r&&e))):(0,c.XW)(!0)}close(e){return this.flush(e).then(e=>(this.getOptions().enabled=!1,this.emit("close"),e))}getEventProcessors(){return this._eventProcessors}addEventProcessor(e){this._eventProcessors.push(e)}init(){(this._isEnabled()||this._options.integrations.some(({name:e})=>e.startsWith("Spotlight")))&&this._setupIntegrations()}getIntegrationByName(e){return this._integrations[e]}addIntegration(e){let t=this._integrations[e.name];(0,g.qm)(this,e,this._integrations),t||(0,g.lc)(this,[e])}sendEvent(e,t={}){this.emit("beforeSendEvent",e,t);let r=(0,f.V7)(e,this._dsn,this._options._metadata,this._options.tunnel);for(let e of t.attachments||[])r=(0,u.W3)(r,(0,u.bm)(e));let n=this.sendEnvelope(r);n&&n.then(t=>this.emit("afterSendEvent",e,t),null)}sendSession(e){let t=(0,f.LE)(e,this._dsn,this._options._metadata,this._options.tunnel);this.sendEnvelope(t)}recordDroppedEvent(e,t,r){if(this._options.sendClientReports){let n="number"==typeof r?r:1,s=`${e}:${t}`;h.T&&o.vF.log(`Recording outcome: "${s}"${n>1?` (${n} times)`:""}`),this._outcomes[s]=(this._outcomes[s]||0)+n}}on(e,t){let r=this._hooks[e]=this._hooks[e]||[];return r.push(t),()=>{let e=r.indexOf(t);e>-1&&r.splice(e,1)}}emit(e,...t){let r=this._hooks[e];r&&r.forEach(e=>e(...t))}sendEnvelope(e){return(this.emit("beforeEnvelope",e),this._isEnabled()&&this._transport)?this._transport.send(e).then(null,e=>(h.T&&o.vF.error("Error while sending event:",e),e)):(h.T&&o.vF.error("Transport disabled"),(0,c.XW)({}))}_setupIntegrations(){let{integrations:e}=this._options;this._integrations=(0,g.P$)(this,e),(0,g.lc)(this,e)}_updateSessionFromEvent(e,t){let r=!1,n=!1,s=t.exception&&t.exception.values;if(s)for(let e of(n=!0,s)){let t=e.mechanism;if(t&&!1===t.handled){r=!0;break}}let a="ok"===e.status;(a&&0===e.errors||a&&r)&&((0,y.qO)(e,{...r&&{status:"crashed"},errors:e.errors||Number(n||r)}),this.captureSession(e))}_isClientDoneProcessing(e){return new c.T2(t=>{let r=0,n=setInterval(()=>{0==this._numProcessing?(clearInterval(n),t(!0)):(r+=1,e&&r>=e&&(clearInterval(n),t(!1)))},1)})}_isEnabled(){return!1!==this.getOptions().enabled&&void 0!==this._transport}_prepareEvent(e,t,r,n=(0,p.rm)()){let s=this.getOptions(),a=Object.keys(this._integrations);return!t.integrations&&a.length>0&&(t.integrations=a),this.emit("preprocessEvent",e,t),e.type||n.setLastEventId(e.event_id||t.event_id),(0,v.mG)(s,e,t,r,this,n).then(e=>{if(null===e)return e;let t={...n.getPropagationContext(),...r?r.getPropagationContext():void 0};if(!(e.contexts&&e.contexts.trace)&&t){let{traceId:r,spanId:n,parentSpanId:s,dsc:a}=t;e.contexts={trace:(0,l.Ce)({trace_id:r,span_id:n,parent_span_id:s}),...e.contexts},e.sdkProcessingMetadata={dynamicSamplingContext:a||(0,b.lF)(r,this),...e.sdkProcessingMetadata}}return e})}_captureEvent(e,t={},r){return this._processEvent(e,t,r).then(e=>e.event_id,e=>{h.T&&("log"===e.logLevel?o.vF.log(e.message):o.vF.warn(e))})}_processEvent(e,t,r){let n=this.getOptions(),{sampleRate:o}=n,i=S(e),l=x(e),u=e.type||"error",m=`before send for type \`${u}\``,d=void 0===o?void 0:(0,k.i)(o);if(l&&"number"==typeof d&&Math.random()>d)return this.recordDroppedEvent("sample_rate","error",e),(0,c.xg)(new s.U(`Discarding event because it's not included in the random sample (sampling rate = ${o})`,"log"));let p="replay_event"===u?"replay":u,h=(e.sdkProcessingMetadata||{}).capturedSpanIsolationScope;return this._prepareEvent(e,t,r,h).then(r=>{if(null===r)throw this.recordDroppedEvent("event_processor",p,e),new s.U("An event processor returned `null`, will not send event.","log");return t.data&&!0===t.data.__sentry__?r:function(e,t){let r=`${t} must return \`null\` or a valid event.`;if((0,a.Qg)(e))return e.then(e=>{if(!(0,a.Qd)(e)&&null!==e)throw new s.U(r);return e},e=>{throw new s.U(`${t} rejected with ${e}`)});if(!(0,a.Qd)(e)&&null!==e)throw new s.U(r);return e}(function(e,t,r,n){let{beforeSend:s,beforeSendTransaction:a,beforeSendSpan:o}=t;if(x(r)&&s)return s(r,n);if(S(r)){if(r.spans&&o){let t=[];for(let n of r.spans){let r=o(n);r?t.push(r):e.recordDroppedEvent("before_send","span")}r.spans=t}if(a){if(r.spans){let e=r.spans.length;r.sdkProcessingMetadata={...r.sdkProcessingMetadata,spanCountBeforeProcessing:e}}return a(r,n)}}return r}(this,n,r,t),m)}).then(n=>{if(null===n){if(this.recordDroppedEvent("before_send",p,e),i){let t=1+(e.spans||[]).length;this.recordDroppedEvent("before_send","span",t)}throw new s.U(`${m} returned \`null\`, will not send event.`,"log")}let a=r&&r.getSession();if(!i&&a&&this._updateSessionFromEvent(a,n),i){let e=(n.sdkProcessingMetadata&&n.sdkProcessingMetadata.spanCountBeforeProcessing||0)-(n.spans?n.spans.length:0);e>0&&this.recordDroppedEvent("before_send","span",e)}let o=n.transaction_info;return i&&o&&n.transaction!==e.transaction&&(n.transaction_info={...o,source:"custom"}),this.sendEvent(n,t),n}).then(null,e=>{if(e instanceof s.U)throw e;throw this.captureException(e,{data:{__sentry__:!0},originalException:e}),new s.U(`Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.
Reason: ${e}`)})}_process(e){this._numProcessing++,e.then(e=>(this._numProcessing--,e),e=>(this._numProcessing--,e))}_clearOutcomes(){let e=this._outcomes;return this._outcomes={},Object.entries(e).map(([e,t])=>{let[r,n]=e.split(":");return{reason:r,category:n,quantity:t}})}_flushOutcomes(){h.T&&o.vF.log("Flushing outcomes...");let e=this._clearOutcomes();if(0===e.length){h.T&&o.vF.log("No outcomes to send");return}if(!this._dsn){h.T&&o.vF.log("No dsn provided, will not send outcomes");return}h.T&&o.vF.log("Sending outcomes:",e);let t=(0,m.m)(e,this._options.tunnel&&(0,n.SB)(this._dsn));this.sendEnvelope(t)}}function x(e){return void 0===e.type}function S(e){return"transaction"===e.type}},441099(e,t,r){"use strict";r.d(t,{P:()=>c});var n,s,a,o,i,l,c,u=r(418920),m=function(e,t,r,n){if("a"===r&&!n)throw TypeError("Private accessor was defined without a getter");if("function"==typeof t?e!==t||!n:!t.has(e))throw TypeError("Cannot read private member from an object whose class did not declare it");return"m"===r?n:"a"===r?n.call(e):n?n.value:t.get(e)},d=function(e,t,r,n,s){if("m"===n)throw TypeError("Private method is not writable");if("a"===n&&!s)throw TypeError("Private accessor was defined without a setter");if("function"==typeof t?e!==t||!s:!t.has(e))throw TypeError("Cannot write private member to an object whose class did not declare it");return"a"===n?s.call(e,r):s?s.value=r:t.set(e,r),r};let p=["clearState","addSubjectMetadata","getSubjectMetadata","trimMetadataState"];(n=c||(c={})).Extension="extension",n.Internal="internal",n.Unknown="unknown",n.Website="website",n.Snap="snap";let h={subjectMetadata:{includeInStateLogs:!0,persist:!0,includeInDebugSnapshot:!1,usedInUi:!0}},f={subjectMetadata:{}};class g extends u.w{constructor({messenger:e,subjectCacheLimit:t,state:r={}}){if(!Number.isInteger(t)||t<1)throw Error(`subjectCacheLimit must be a positive integer. Received: "${t}"`);let n=t=>e.call("PermissionController:hasPermissions",t);super({name:"SubjectMetadataController",metadata:h,messenger:e,state:{...m(s,s,"m",l).call(s,r,n)}}),a.set(this,void 0),o.set(this,void 0),i.set(this,void 0),d(this,i,n,"f"),d(this,a,t,"f"),d(this,o,new Set,"f"),this.messenger.registerMethodActionHandlers(this,p)}clearState(){m(this,o,"f").clear(),this.update(e=>({...f}))}addSubjectMetadata(e){let{origin:t}=e,r={...e,extensionId:e.extensionId??null,iconUrl:e.iconUrl??null,name:e.name??null,subjectType:e.subjectType??null},n=null;if(m(this,o,"f").size>=m(this,a,"f")){let e=m(this,o,"f").values().next().value;m(this,o,"f").delete(e),m(this,i,"f").call(this,e)||(n=e)}m(this,o,"f").add(t),this.update(e=>{e.subjectMetadata[t]=r,"string"==typeof n&&delete e.subjectMetadata[n]})}getSubjectMetadata(e){return this.state.subjectMetadata[e]}trimMetadataState(){this.update(()=>m(s,s,"m",l).call(s,this.state,m(this,i,"f")))}}s=g,a=new WeakMap,o=new WeakMap,i=new WeakMap,l=function(e,t){let{subjectMetadata:r={}}=e;return{subjectMetadata:Object.keys(r).reduce((e,n)=>(t(n)&&(e[n]=r[n]),e),{})}}},441227(e,t,r){"use strict";r.d(t,{C:()=>g,D:()=>y});var a=r(107842),o=r(37853),i=r(933190),l=r(67904),c=r(812863),u=r(777217),m=r(71409),d=r(608119),p=r(140722),h=r(96331),f=r(16686);let g={idleTimeout:1e3,finalTimeout:3e4,childSpanTimeout:15e3};function y(e,t={}){let r,b=new Map,k=!1,v="externalFinish",_=!t.disableAutoFinish,w=[],{idleTimeout:x=g.idleTimeout,finalTimeout:S=g.finalTimeout,childSpanTimeout:E=g.childSpanTimeout,beforeSpanEnd:j}=t,T=(0,i.KU)();if(!T||!(0,u.w)())return new p.w;let A=(0,i.o5)(),C=(0,d.Bk)(),I=function(e){let t=(0,f.Uk)(e);return(0,m.r)((0,i.o5)(),t),l.T&&a.vF.log("[Tracing] Started span is an idle span"),t}(e);function O(){r&&(s(r),r=void 0)}function M(e){O(),r=n(()=>{!k&&0===b.size&&_&&(v="idleTimeout",I.end(e))},x)}function N(e){r=n(()=>{!k&&_&&(v="heartbeatFailed",I.end(e))},E)}function D(e){k=!0,b.clear(),w.forEach(e=>e()),(0,m.r)(A,C);let t=(0,d.et)(I),{start_timestamp:r}=t;if(!r)return;(t.data||{})[c.fs]||I.setAttribute(c.fs,v),a.vF.log(`[Tracing] Idle span "${t.op}" finished`);let n=(0,d.xO)(I).filter(e=>e!==I),s=0;n.forEach(t=>{t.isRecording()&&(t.setStatus({code:h.TJ,message:"cancelled"}),t.end(e),l.T&&a.vF.log("[Tracing] Cancelling span since span ended early",JSON.stringify(t,void 0,2)));let{timestamp:r=0,start_timestamp:n=0}=(0,d.et)(t),o=n<=e,i=r-n<=(S+x)/1e3;if(l.T){let e=JSON.stringify(t,void 0,2);o?i||a.vF.log("[Tracing] Discarding span since it finished after idle span final timeout",e):a.vF.log("[Tracing] Discarding span since it happened after idle span was finished",e)}(!i||!o)&&((0,d.VS)(I,t),s++)}),s>0&&I.setAttribute("sentry.idle_span_discarded_spans",s)}return I.end=new Proxy(I.end,{apply(e,t,r){j&&j(I);let[n,...s]=r,a=n||(0,o.zf)(),i=(0,d.cI)(a),l=(0,d.xO)(I).filter(e=>e!==I);if(!l.length)return D(i),Reflect.apply(e,t,[i,...s]);let c=l.map(e=>(0,d.et)(e).timestamp).filter(e=>!!e),u=c.length?Math.max(...c):void 0,m=(0,d.et)(I).start_timestamp,p=Math.min(m?m+S/1e3:1/0,Math.max(m||-1/0,Math.min(i,u||1/0)));return D(p),Reflect.apply(e,t,[p,...s])}}),w.push(T.on("spanStart",e=>{var t;k||e===I||(0,d.et)(e).timestamp||(0,d.xO)(I).includes(e)&&(t=e.spanContext().spanId,O(),b.set(t,!0),N((0,o.zf)()+E/1e3))})),w.push(T.on("spanEnd",e=>{if(!k){var t;t=e.spanContext().spanId,b.has(t)&&b.delete(t),0===b.size&&M((0,o.zf)()+x/1e3)}})),w.push(T.on("idleSpanEnableAutoFinish",e=>{e===I&&(_=!0,M(),b.size&&N())})),t.disableAutoFinish||M(),n(()=>{k||(I.setStatus({code:h.TJ,message:"deadline_exceeded"}),v="finalTimeout",I.end())},S),I}},442525(e,t,r){"use strict";r.d(t,{A:()=>c});var n=r(347022),s=r(392134),a=r(640846),o=r(831022),i=r(419186),l=r(316244);class c{static hasDST(e=s.A.defaultZone){let t=n.A.now().setZone(e).set({month:12});return!e.isUniversal&&t.offset!==t.set({month:6}).offset}static isValidIANAZone(e){return o.A.isValidZone(e)}static normalizeZone(e){return(0,i.q)(e,s.A.defaultZone)}static getStartOfWeek({locale:e=null,locObj:t=null}={}){return(t||a.A.create(e)).getStartOfWeek()}static getMinimumDaysInFirstWeek({locale:e=null,locObj:t=null}={}){return(t||a.A.create(e)).getMinDaysInFirstWeek()}static getWeekendWeekdays({locale:e=null,locObj:t=null}={}){return(t||a.A.create(e)).getWeekendDays().slice()}static months(e="long",{locale:t=null,numberingSystem:r=null,locObj:n=null,outputCalendar:s="gregory"}={}){return(n||a.A.create(t,r,s)).months(e)}static monthsFormat(e="long",{locale:t=null,numberingSystem:r=null,locObj:n=null,outputCalendar:s="gregory"}={}){return(n||a.A.create(t,r,s)).months(e,!0)}static weekdays(e="long",{locale:t=null,numberingSystem:r=null,locObj:n=null}={}){return(n||a.A.create(t,r,null)).weekdays(e)}static weekdaysFormat(e="long",{locale:t=null,numberingSystem:r=null,locObj:n=null}={}){return(n||a.A.create(t,r,null)).weekdays(e,!0)}static meridiems({locale:e=null}={}){return a.A.create(e).meridiems()}static eras(e="short",{locale:t=null}={}){return a.A.create(t,null,"gregory").eras(e)}static features(){return{relative:(0,l.h3)(),localeWeek:(0,l.jv)()}}}},443227(e,t,r){"use strict";r.d(t,{F:()=>v});var n=r(133481),s=r(225669),a=r(714599),o=r(933190),i=r(290264),l=r(92376),c=r(179329),u=r(834028),m=r(384255),d=r(821016),p=r(107842),h=r(696294),f=r(837075),g=r(40209),y=r(830339),b=r(902419),k=r(845226);let v=(0,i._C)((e={})=>{let t={console:!0,dom:!0,fetch:!0,history:!0,sentry:!0,xhr:!0,...e};return{name:"Breadcrumbs",setup(e){var r,i,v,_,w,x,S;t.console&&(0,m.P)((r=e,function(e){if((0,o.KU)()!==r)return;let t={category:"console",data:{arguments:e.args,logger:"console"},level:(0,f.t)(e.level),message:(0,g.gt)(e.args," ")};if("assert"===e.level)if(!1!==e.args[0])return;else t.message=`Assertion failed: ${(0,g.gt)(e.args.slice(1)," ")||"console.assert"}`,t.data.arguments=e.args.slice(1);(0,l.Z)(t,{input:e.args,level:e.level})})),t.dom&&(0,n.i)((i=e,v=t.dom,function(e){let t,r;if((0,o.KU)()!==i)return;let n="object"==typeof v?v.serializeAttribute:void 0,s="object"==typeof v&&"number"==typeof v.maxStringLength?v.maxStringLength:void 0;s&&s>1024&&(b.T&&p.vF.warn(`\`dom.maxStringLength\` cannot exceed 1024, but a value of ${s} was configured. Sentry will use 1024 instead.`),s=1024),"string"==typeof n&&(n=[n]);try{var a;let o=e.event,i=(a=o)&&a.target?o.target:o;t=(0,u.Hd)(i,{keyAttrs:n,maxStringLength:s}),r=(0,u.xE)(i)}catch(e){t="<unknown>"}if(0===t.length)return;let c={category:`ui.${e.name}`,message:t};r&&(c.data={"ui.component_name":r}),(0,l.Z)(c,{event:e.event,name:e.name,global:e.global})})),t.xhr&&(0,a.Mn)((_=e,function(e){if((0,o.KU)()!==_)return;let{startTimestamp:t,endTimestamp:r}=e,n=e.xhr[a.Er];if(!t||!r||!n)return;let{method:s,url:i,status_code:u,body:m}=n,d={xhr:e.xhr,input:m,startTimestamp:t,endTimestamp:r},p=(0,c.X)(u);(0,l.Z)({category:"xhr",data:{method:s,url:i,status_code:u},type:"http",level:p},d)})),t.fetch&&(0,d.ur)((w=e,function(e){if((0,o.KU)()!==w)return;let{startTimestamp:t,endTimestamp:r}=e;if(r&&(!e.fetchData.url.match(/sentry_key/)||"POST"!==e.fetchData.method))if(e.error){let n=e.fetchData,s={data:e.error,input:e.args,startTimestamp:t,endTimestamp:r};(0,l.Z)({category:"fetch",data:n,level:"error",type:"http"},s)}else{let n=e.response,s={...e.fetchData,status_code:n&&n.status},a={input:e.args,response:n,startTimestamp:t,endTimestamp:r},o=(0,c.X)(s.status_code);(0,l.Z)({category:"fetch",data:s,type:"http",level:o},a)}})),t.history&&(0,s._)((x=e,function(e){if((0,o.KU)()!==x)return;let t=e.from,r=e.to,n=(0,y.Dl)(k.jf.location.href),s=t?(0,y.Dl)(t):void 0,a=(0,y.Dl)(r);s&&s.path||(s=n),n.protocol===a.protocol&&n.host===a.host&&(r=a.relative),n.protocol===s.protocol&&n.host===s.host&&(t=s.relative),(0,l.Z)({category:"navigation",data:{from:t,to:r}})})),t.sentry&&e.on("beforeSendEvent",(S=e,function(e){(0,o.KU)()===S&&(0,l.Z)({category:`sentry.${"transaction"===e.type?"transaction":"event"}`,event_id:e.event_id,level:e.level,message:(0,h.$X)(e)},{event:e})}))}}})},446655(e,t,r){"use strict";r.d(t,{A:()=>n});class n{constructor(e,t){this.reason=e,this.explanation=t}toMessage(){return this.explanation?`${this.reason}: ${this.explanation}`:this.reason}}},447519(e,t,r){"use strict";r.d(t,{jU:()=>h,zC:()=>p});var n=r(448967),s=r(411554),a=r(652825),o=r(290266),i=r(545203),l=r(812805);let c=e=>(0,o.Ik)(e);function u({path:e,branch:t}){let r=e[e.length-1];return(0,l.i5)(t[t.length-2],r)}function m(e){return new n._k({...e,type:`optional ${e.type}`,validator:(t,r)=>!u(r)||e.validator(t,r),refiner:(t,r)=>!u(r)||e.refiner(t,r)})}let d=(0,i.E8)("JSON",e=>(function e(t){if(null===t||"boolean"==typeof t||"string"==typeof t||"number"==typeof t&&Number.isFinite(t))return!0;if("object"==typeof t){let r=!0;if(Array.isArray(t)){for(let n=0;n<t.length;n++)if(!e(t[n])){r=!1;break}return r}let n=Object.entries(t);for(let t=0;t<n.length;t++)if("string"!=typeof n[t][0]||!e(n[t][1])){r=!1;break}return r}return!1})(e)),p=(0,s.au)(d,(0,a.YP)((0,o.bz)(),"JSON",e=>(0,n.is)(e,d)),e=>JSON.parse(JSON.stringify(e,(e,t)=>{if("__proto__"!==e&&"constructor"!==e)return t})));function h(e){try{var t;return t=e,(0,n.vt)(t,p),!0}catch{return!1}}let f=(0,o.eu)("2.0"),g=(0,o.me)((0,o.KC)([(0,o.ai)(),(0,o.Yj)()])),y=c({code:(0,o.nd)(),message:(0,o.Yj)(),data:m(p),stack:m((0,o.Yj)())}),b=(0,o.KC)([(0,o.g1)((0,o.Yj)(),p),(0,o.YO)(p)]);c({id:g,jsonrpc:f,method:(0,o.Yj)(),params:m(b)}),c({jsonrpc:f,method:(0,o.Yj)(),params:m(b)}),(0,o.Ik)({id:g,jsonrpc:f,result:(0,o.lq)((0,o.L5)()),error:(0,o.lq)(y)});let k=c({id:g,jsonrpc:f,result:p}),v=c({id:g,jsonrpc:f,error:y});(0,o.KC)([k,v])},448967(e,t,r){"use strict";r.d(t,{P$:()=>i,_k:()=>a,is:()=>u,vA:()=>l,vt:()=>c});var n=r(982944),s=r(612815);class a{constructor(e){let{type:t,schema:r,validator:n,refiner:a,coercer:o=e=>e,entries:i=function*(){}}=e;this.type=t,this.schema=r,this.entries=i,this.coercer=o,n?this.validator=(e,t)=>{let r=n(e,t);return(0,s.RF)(r,t,this,e)}:this.validator=()=>[],a?this.refiner=(e,t)=>{let r=a(e,t);return(0,s.RF)(r,t,this,e)}:this.refiner=()=>[]}assert(e,t){return l(e,this,t)}create(e,t){return c(e,this,t)}is(e){return u(e,this)}mask(e,t){var r=e,n=this,s=t;let a=m(r,n,{coerce:!0,mask:!0,message:s});if(!a[0])return a[1];throw a[0]}validate(e,t={}){return m(e,this,t)}}let o="EXACT_OPTIONAL";class i extends a{constructor(e){super({...e,type:`exact optional ${e.type}`}),this.brand=o}static isExactOptional(e){return(0,s.Gv)(e)&&"brand"in e&&e.brand===o}}function l(e,t,r){let n=m(e,t,{message:r});if(n[0])throw n[0]}function c(e,t,r){let n=m(e,t,{coerce:!0,message:r});if(!n[0])return n[1];throw n[0]}function u(e,t){return!m(e,t)[0]}function m(e,t,r={}){let a=(0,s.eF)(e,t,r),o=(0,s.jT)(a);return o[0]?[new n.C(o[0],function*(){for(let e of a)e[0]&&(yield e[0])}),void 0]:[void 0,o[1]]}},450579(e,t,r){"use strict";r.d(t,{P8:()=>i,V8:()=>o});let n=/^(\S+:\\|\/?)([\s\S]*?)((?:\.{1,2}|[^/\\]+?|)(\.[^./\\]*|))(?:[/\\]*)$/;function s(...e){let t="",r=!1;for(let n=e.length-1;n>=-1&&!r;n--){let s=n>=0?e[n]:"/";s&&(t=`${s}/${t}`,r="/"===s.charAt(0))}return t=(function(e,t){let r=0;for(let t=e.length-1;t>=0;t--){let n=e[t];"."===n?e.splice(t,1):".."===n?(e.splice(t,1),r++):r&&(e.splice(t,1),r--)}if(t)for(;r--;)e.unshift("..");return e})(t.split("/").filter(e=>!!e),!r).join("/"),(r?"/":"")+t||"."}function a(e){let t=0;for(;t<e.length&&""===e[t];t++);let r=e.length-1;for(;r>=0&&""===e[r];r--);return t>r?[]:e.slice(t,r-t+1)}function o(e,t){e=s(e).slice(1),t=s(t).slice(1);let r=a(e.split("/")),n=a(t.split("/")),o=Math.min(r.length,n.length),i=o;for(let e=0;e<o;e++)if(r[e]!==n[e]){i=e;break}let l=[];for(let e=i;e<r.length;e++)l.push("..");return(l=l.concat(n.slice(i))).join("/")}function i(e,t){let r=function(e){let t=e.length>1024?`<truncated>${e.slice(-1024)}`:e,r=n.exec(t);return r?r.slice(1):[]}(e)[2]||"";return t&&r.slice(-1*t.length)===t&&(r=r.slice(0,r.length-t.length)),r}},451798(e,t,r){"use strict";r.d(t,{A:()=>s});var n=r(283707);class s extends n.A{constructor(e){super(),this.zoneName=e}get type(){return"invalid"}get name(){return this.zoneName}get isUniversal(){return!1}offsetName(){return null}formatOffset(){return""}offset(){return NaN}equals(){return!1}get isValid(){return!1}}},459517(e,t,r){"use strict";r.d(t,{f:()=>f});var s=r(12796),a=r(956742),o=r(184748),i=r(132076),l=r(495242),c=r(898026),u=r(259463),m=r(533858),d=r(681747);let p=[2500,4e3],h={},f=(e,t={})=>{(0,d.I)(()=>{let r,d=(0,i.N)(),f=(0,l.X)("LCP"),g=e=>{let t=e[e.length-1];t&&t.startTime<d.firstHiddenTime&&(f.value=Math.max(t.startTime-(0,o.b)(),0),f.entries=[t],r())},y=(0,c.l)("largest-contentful-paint",g);if(y){r=(0,a.R)(e,f,p,t.reportAllChanges);let o=(0,m.J)(()=>{h[f.id]||(g(y.takeRecords()),y.disconnect(),h[f.id]=!0,r(!0))});["keydown","click"].forEach(e=>{s.j.document&&addEventListener(e,()=>n(o,0),!0)}),(0,u.Q)(o)}})}},462105(e,t,r){"use strict";var n,s;r.d(t,{eZ:()=>n}),(s=n||(n={})).RestrictedMethod="RestrictedMethod",s.Endowment="Endowment"},471265(e,t,r){"use strict";r.d(t,{r:()=>o});var n=r(230337),s=r(25605);let a=null;function o(e){let t="unhandledrejection";(0,s.s5)(t,e),(0,s.AS)(t,i)}function i(){a=n.O.onunhandledrejection,n.O.onunhandledrejection=function(e){return(0,s.aj)("unhandledrejection",e),!a||!!a.__SENTRY_LOADER__||a.apply(this,arguments)},n.O.onunhandledrejection.__SENTRY_INSTRUMENTED__=!0}},482903(e,t,r){"use strict";r.d(t,{Ay:()=>A});var n=r(258862),s=r(717309),a=r(718800),o=r(550041),i=r(793111),l=(r(933190),r(591386)),c=r(254759),u=r(986746),m=(r(107842),r(859340)),d=r(392248),p=r.n(d),h=r(671054),f=r(823803),g=r(520803),y=r(869949),b=r(59555),k=r(967746),v=r(969210),_=r(871008),w=r(848896),x=r(300652);(0,n.X)(h.wQ,"internal");let S="pull-request",E=(0,y.n)(S,"13.41.0"),j="https://17e6db85bd66517e7c828d36f53e2f26@sentry.io/4510302346608640",T={CRYPTOCOMPARE:"cryptocompare.com",COINGECKO:"coingecko.com",ETHERSCAN:"etherscan.io",CODEFI:"codefi.network",SEGMENT:"segment.io"};function A(){if(!E)throw Error("Missing release");return I()?((0,h.wQ)("Initializing"),(0,x.I)(),function(){let e=function(){let e=I();return{beforeBreadcrumb:e=>{if(!_.Gu)return null;let t=(0,_.Gu)(),r=(0,_.eR)(t);return r?.completedMetaMetricsOnboarding&&r?.optedIn&&e?.category!=="ui.input"?e:null},beforeSend:e=>(function(e){try{var t,r,n,s,a;t=e,q(t,e=>{let t=(0,b.A)(e);return 0===t.indexOf("Transaction Failed: known transaction")&&(t="Transaction Failed: known transaction"),t}),r=e,q(r,e=>{let t=e;return(t.match(/(([-.+a-zA-Z]+:\/\/)|(www\.))\S+[@:.]\S+/gu)||[]).forEach(e=>{try{let{hostname:r}=new URL(e);Object.values(T).some(e=>r===e||r.endsWith(`.${e}`))||(t=t.replace(e,"**"))}catch(r){t=t.replace(e,"**")}}),t}),n=e,q(n,e=>F(e)),N(e),(s=e).extra&&(s.extra=P(s.extra)),s.contexts&&(s.contexts=P(s.contexts)),a=e,a.request?.url&&(a.request.url=z(a.request.url)),a.exception&&a.exception.values&&a.exception.values.forEach(e=>{e.stacktrace&&e.stacktrace.frames.forEach(e=>{e.filename=z(e.filename)})});let o=(0,_.Gu)();e.extra||(e.extra={}),e.tags||(e.tags={});let i=(0,x.K)();Object.assign(e.extra,{appState:o,installType:i,extensionId:p().runtime?.id}),e.tags.installType=i,e.tags.storageKind=globalThis.stateHooks?.getStorageKind?.()??"unknown"}catch(e){(0,h.wQ)("Error rewriting report",e)}return e})(C(e)),beforeSendTransaction:e=>{var t,r;let n=(N(t=C(e)),t);return Array.isArray((r=n).spans)&&(r.spans=r.spans.filter(e=>{let t=e?.description??e?.name;return!(e?.op==="mark"&&D.has(t))})),n},debug:!1,dist:f.isManifestV3?"mv3":"mv2",dsn:e,environment:S,integrations:[c.s(),u.X(),l.dp({enableLongAnimationFrame:!0,shouldCreateSpanForRequest:M}),(0,k.t)({getAnalyticsState:_.kS,log:h.wQ}),(0,v.Vu)({log:h.wQ})],release:E,...{tracePropagationTargets:v.dm},sendClientReports:!1,tracesSampleRate:function(e){if("https://fake@sentry.io/0000000"===e)return 1;let t=(0,g.P)();return t.sentry?.tracesSampleRate!==void 0?t.sentry.tracesSampleRate:t.ci?"main"===t.ci.branch?.015:.001:.005}(e),ignoreErrors:e===j?[/.*/u]:void 0,transport:w._}}(),{dsn:t,environment:r,release:n,tracesSampleRate:s}=e;globalThis.nw={},globalThis.history??={},(0,h.wQ)("Updating client",{environment:r,dsn:t,release:n,tracesSampleRate:s}),a.s(),o.Ts(e);let{ci:m}=(0,g.P)();m?.enabled&&(i.NA("ci.enabled",m.enabled),i.NA("ci.branch",m.branch),i.NA("ci.commitHash",m.commitHash),i.NA("ci.job",m.job),i.NA("ci.matrixIndex",m.matrixIndex),i.NA("ci.prNumber",m.prNumber),m.persona&&i.NA("ci.persona",m.persona),m.testTitle&&i.NA("ci.testTitle",m.testTitle))}(),{...s}):void(0,h.wQ)("Skipped initialization")}function C(e){try{return(0,m.cloneDeep)(e)}catch(t){return(0,h.wQ)("Failed to clone Sentry event, using original reference",t),e}}function I(){let e=(0,g.P)();return e.ci?.enabled&&j?j:"https://f59f3dd640d2429d9d0e2445a87ea8e1@sentry.io/273496"}function O(e){return e.match(/^(chrome-extension|moz-extension):\/\//u)?e:""}function M(e){return!(/^https?:\/\/(?:[\w\d.@-]+\.)?(?:sentry\.io|segment\.io|chainid\.network|acl\.execution\.metamask\.io)(?:\/|$)/u.test(e)||/^(?:chrome|moz)-extension:\/\/[^/]+\/(?:(?:snaps|_locales)\/|[0-9a-f]{8,}\.json$)/u.test(e))}function N(e){if(Array.isArray(e.breadcrumbs))for(let r=0;r<e.breadcrumbs.length;r++){var t;t=e.breadcrumbs[r],t?.data?.url&&(t.data.url=O(t.data.url)),t?.data?.to&&(t.data.to=O(t.data.to)),t?.data?.from&&(t.data.from=O(t.data.from)),"string"==typeof t?.message&&(t.message=F(t.message)),t?.data&&(t.data=P(t.data))}}let D=new Set(["sentry-tracing-init","mm-hero-painted"]),R=/0x[A-Fa-f0-9]{40}/gu,L=[/\bT[1-9A-HJ-NP-Za-km-z]{33}\b/gu,/\bG[A-Z2-7]{55}\b/gu,/\bbc1[02-9ac-hj-np-z]{6,87}\b/gu,/\b[13][1-9A-HJ-NP-Za-km-z]{25,34}\b/gu,/\b[1-9A-HJ-NP-Za-km-z]{32,44}\b/gu];function F(e){let t=e.replace(R,"0x**");for(let e of L)t=t.replace(e,"**");return t}function P(e,t=new WeakMap){if("string"==typeof e)return F(e);if(null===e||"object"!=typeof e)return e;if(t.has(e))return t.get(e);if(Array.isArray(e)){let r=[];t.set(e,r);for(let n=0;n<e.length;n++)r[n]=P(e[n],t);return r}let r={};for(let n of(t.set(e,r),e instanceof Error&&("string"==typeof e.message&&(r.message=F(e.message)),"string"==typeof e.stack&&(r.stack=F(e.stack))),Object.keys(e)))r[n]=P(e[n],t);return r}function q(e,t){"string"==typeof e.message&&(e.message=t(e.message)),e.exception&&e.exception.values&&e.exception.values.forEach(e=>{"string"==typeof e.value&&(e.value=t(e.value))})}function z(e){if(!globalThis.location?.origin)return e;let t=e?.split(globalThis.location.origin)[1];return t?`/metamask${t}`:e}},493104(e,t,r){"use strict";r.d(t,{A:()=>o});var n=r(316244),s=r(283707);let a=null;class o extends s.A{static get instance(){return null===a&&(a=new o),a}get type(){return"system"}get name(){return new Intl.DateTimeFormat().resolvedOptions().timeZone}get isUniversal(){return!1}offsetName(e,{format:t,locale:r}){return(0,n.wG)(e,t,r)}formatOffset(e,t){return(0,n.xS)(this.offset(e),t)}offset(e){return-new Date(e).getTimezoneOffset()}equals(e){return"system"===e.type}get isValid(){return!0}}},494688(e,t,r){"use strict";r.d(t,{y:()=>m});var n=r(438774),s=r(192279),a=r(107842),o=r(906769),i=r(902419),l=r(943544),c=r(845226),u=r(273521);class m extends n.V{constructor(e){let t={parentSpanIsAlwaysRootSpan:!0,...e},r=c.jf.SENTRY_SDK_SOURCE||(0,o.e)();(0,s.K)(t,"browser",["browser"],r),super(t),t.sendClientReports&&c.jf.document&&c.jf.document.addEventListener("visibilitychange",()=>{"hidden"===c.jf.document.visibilityState&&this._flushOutcomes()})}eventFromException(e,t){return(0,l.u)(this._options.stackParser,e,t,this._options.attachStacktrace)}eventFromMessage(e,t="info",r){return(0,l.qv)(this._options.stackParser,e,t,r,this._options.attachStacktrace)}captureUserFeedback(e){if(!this._isEnabled()){i.T&&a.vF.warn("SDK not enabled, will not capture user feedback.");return}let t=(0,u.L)(e,{metadata:this.getSdkMetadata(),dsn:this.getDsn(),tunnel:this.getOptions().tunnel});this.sendEnvelope(t)}_prepareEvent(e,t,r){return e.platform=e.platform||"javascript",super._prepareEvent(e,t,r)}}},494945(e,t,r){"use strict";r.d(t,{m:()=>a});var n=r(85182),s=r(37853);function a(e,t,r){let a=[{type:"client_report"},{timestamp:r||(0,s.lu)(),discarded_events:e}];return(0,n.h4)(t?{dsn:t}:{},[a])}},495242(e,t,r){"use strict";r.d(t,{X:()=>i});var n=r(12796),s=r(882555),a=r(184748),o=r(303818);let i=(e,t)=>{let r=(0,o.z)(),i="navigate";return r&&(n.j.document&&n.j.document.prerendering||(0,a.b)()>0?i="prerender":n.j.document&&n.j.document.wasDiscarded?i="restore":r.type&&(i=r.type.replace(/_/g,"-"))),{name:e,value:void 0===t?-1:t,rating:"good",delta:0,entries:[],id:(0,s.W)(),navigationType:i}}},503510(e,t,r){"use strict";r.d(t,{$2:()=>p,Q_:()=>f,Vv:()=>y,Yj:()=>l,c9:()=>b,dY:()=>m,lG:()=>k});var n=r(680985);function s(e,t,r,s){let a={filename:e,function:"<anonymous>"===t?n.yF:t,in_app:!0};return void 0!==r&&(a.lineno=r),void 0!==s&&(a.colno=s),a}let a=/^\s*at (\S+?)(?::(\d+))(?::(\d+))\s*$/i,o=/^\s*at (?:(.+?\)(?: \[.+\])?|.*?) ?\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i,i=/\((\S*)(?::(\d+))(?::(\d+))\)/,l=[30,e=>{let t=a.exec(e);if(t){let[,e,r,a]=t;return s(e,n.yF,+r,+a)}let r=o.exec(e);if(r){if(r[2]&&0===r[2].indexOf("eval")){let e=i.exec(r[2]);e&&(r[2]=e[1],r[3]=e[2],r[4]=e[3])}let[e,t]=v(r[1]||n.yF,r[2]);return s(t,e,r[3]?+r[3]:void 0,r[4]?+r[4]:void 0)}}],c=/^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i,u=/(\S+) line (\d+)(?: > eval line \d+)* > eval/i,m=[50,e=>{let t=c.exec(e);if(t){if(t[3]&&t[3].indexOf(" > eval")>-1){let e=u.exec(t[3]);e&&(t[1]=t[1]||"eval",t[3]=e[1],t[4]=e[2],t[5]="")}let e=t[3],r=t[1]||n.yF;return[r,e]=v(r,e),s(e,r,t[4]?+t[4]:void 0,t[5]?+t[5]:void 0)}}],d=/^\s*at (?:((?:\[object object\])?.+) )?\(?((?:[-a-z]+):.*?):(\d+)(?::(\d+))?\)?\s*$/i,p=[40,e=>{let t=d.exec(e);return t?s(t[2],t[1]||n.yF,+t[3],t[4]?+t[4]:void 0):void 0}],h=/ line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i,f=[10,e=>{let t=h.exec(e);return t?s(t[2],t[3]||n.yF,+t[1]):void 0}],g=/ line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\(.*\))? in (.*):\s*$/i,y=[20,e=>{let t=g.exec(e);return t?s(t[5],t[3]||t[4]||n.yF,+t[1],+t[2]):void 0}],b=[l,m],k=(0,n.gd)(...b),v=(e,t)=>{let r=-1!==e.indexOf("safari-extension"),s=-1!==e.indexOf("safari-web-extension");return r||s?[-1!==e.indexOf("@")?e.split("@")[0]:n.yF,r?`safari-extension:${t}`:`safari-web-extension:${t}`]:[e,t]}},520803(e,t,r){"use strict";r.d(t,{P:()=>a});var n=r(392248),s=r.n(n);function a(){return s().runtime.getManifest&&s().runtime.getManifest()._flags||{}}},525037(e,t,r){"use strict";r.d(t,{c9:()=>n.A});var n=r(347022);r(360569),r(352134),r(442525),r(283707),r(794204),r(831022),r(451798),r(493104),r(392134)},530953(e,t,r){"use strict";r.d(t,{wq:()=>n}),r(36915),Object.freeze({restrictReturnedAccounts:"restrictReturnedAccounts",restrictNetworkSwitching:"restrictNetworkSwitching"}),Object.freeze({permittedChains:"endowment:permitted-chains"}),Object.freeze({eth_accounts:"eth_accounts"});let n=Object.freeze({eth_accounts:"eth_accounts",snap_dialog:"snap_dialog",snap_notify:"snap_notify",snap_manageState:"snap_manageState",snap_getBip32PublicKey:"snap_getBip32PublicKey",snap_getBip32Entropy:"snap_getBip32Entropy",snap_getBip44Entropy:"snap_getBip44Entropy",snap_getEntropy:"snap_getEntropy",snap_getLocale:"snap_getLocale",snap_getPreferences:"snap_getPreferences",wallet_snap:"wallet_snap",snap_manageAccounts:"snap_manageAccounts"});Object.freeze({connection_permission:"connection_permission"}),Object.freeze({snapInstall:3,snapUpdateApprovedPermissions:3}),Object.freeze({eth_accounts:3,permittedChains:3,snap_dialog:4,snap_notify:4,snap_getBip32PublicKey:3,snap_getBip32Entropy:1,snap_getBip44Entropy:1,snap_getEntropy:3,snap_manageState:4,snap_getLocale:4,wallet_snap:4,endowment_networkAccess:3,endowment_assets:3,endowment_protocol:3,endowment_webassembly:4,endowment_transactionInsight:4,endowment_cronjob:4,endowment_ethereumProvider:4,endowment_multichainProvider:4,endowment_rpc:4,endowment_lifecycleHooks:4,endowment_pageHome:4,snap_manageAccounts:3,endowment_keyring:4,endowment_nameLookup:3,endowment_signatureInsight:4,connection_permission:3,unknown_permission:3})},532725(e,t,r){"use strict";r.d(t,{q:()=>a});var n=r(97407),s=r(933190);function a(e,t={},r=(0,s.o5)()){let{message:o,name:i,email:l,url:c,source:u,associatedEventId:m,tags:d}=e,p={contexts:{feedback:(0,n.Ce)({contact_email:l,name:i,message:o,url:c,source:u,associated_event_id:m})},type:"feedback",level:"info",tags:d},h=r&&r.getClient()||(0,s.KU)();return h&&h.emit("beforeSendFeedback",p,t),r.captureEvent(p,t)}},533858(e,t,r){"use strict";r.d(t,{J:()=>n});let n=e=>{let t=!1;return r=>{t||(e(r),t=!0)}}},534098(e,t,r){"use strict";r.d(t,{r:()=>o});var n=r(397718),s=r(40209);function a(e){return{...e,path:"path"in e&&Array.isArray(e.path)?e.path.join("."):void 0,keys:"keys"in e?JSON.stringify(e.keys):void 0,unionErrors:"unionErrors"in e?JSON.stringify(e.unionErrors):void 0}}let o=(0,r(290264)._C)((e={})=>{let t=e.limit||10;return{name:"ZodErrors",processEvent(e,r){var o;return e.exception&&e.exception.values&&r&&r.originalException&&(o=r.originalException,(0,n.bJ)(o)&&"ZodError"===o.name&&Array.isArray(o.errors))&&0!==r.originalException.issues.length?{...e,exception:{...e.exception,values:[{...e.exception.values[0],value:function(e){let t=new Set;for(let r of e.issues)r.path&&r.path[0]&&t.add(r.path[0]);let r=Array.from(t);return`Failed to validate keys: ${(0,s.xv)(r.join(", "),100)}`}(r.originalException)},...e.exception.values.slice(1)]},extra:{...e.extra,"zoderror.issues":r.originalException.errors.slice(0,t).map(a)}}:e}}})},537252(e,t,r){"use strict";r.d(t,{f:()=>c});var n=r(290264),s=r(608119),a=r(107842),o=r(902419),i=r(327566),l=r(553205);let c=(0,n._C)(()=>({name:"BrowserProfiling",setup(e){let t=(0,s.Bk)(),r=t&&(0,s.zU)(t);r&&(0,l.c4)(r)&&(0,l.Xu)(r)&&(0,i.H)(r),e.on("spanStart",e=>{e===(0,s.zU)(e)&&(0,l.Xu)(e)&&(0,i.H)(e)}),e.on("beforeEnvelope",e=>{if(!(0,l.ex)())return;let t=(0,l.WK)(e);if(!t.length)return;let r=[];for(let e of t){let t=e&&e.contexts,n=t&&t.profile&&t.profile.profile_id,s=t&&t.profile&&t.profile.start_timestamp;if("string"!=typeof n||!n){o.T&&a.vF.log("[Profiling] cannot find profile for a span without a profile context");continue}t&&t.profile&&delete t.profile;let i=(0,l.ws)(n);if(!i){o.T&&a.vF.log(`[Profiling] Could not retrieve profile for span: ${n}`);continue}let c=(0,l.Bj)(n,s,i,e);c&&r.push(c)}(0,l.lV)(e,r)})}}))},538600(e,t,r){"use strict";r.d(t,{M:()=>n});let n="8.33.1"},545203(e,t,r){"use strict";r.d(t,{E8:()=>o,RZ:()=>i,kp:()=>a});var n=r(448967),s=r(290266);function a(...e){let t=e[0]?.type==="type",r=Object.assign({},...e.map(({schema:e})=>e));return t?(0,s.NW)(r):(0,s.Ik)(r)}function o(e,t){return new n._k({type:e,schema:null,validator:t})}function i(e){let t;return new n._k({type:"lazy",schema:null,*entries(r,n){t??(t=e()),yield*t.entries(r,n)},validator:(r,n)=>(t??(t=e()),t.validator(r,n)),coercer:(r,n)=>(t??(t=e()),t.coercer(r,n)),refiner:(r,n)=>(t??(t=e()),t.refiner(r,n))})}},550041(e,t,r){"use strict";r.d(t,{Ts:()=>j,kF:()=>C,lo:()=>I,mn:()=>T,nI:()=>E,w7:()=>A});var n=r(793111),s=r(933190),a=r(76838),o=r(155682),i=r(290264),l=r(724666),c=r(48718),u=r(254759),m=r(107842),d=r(680985),p=r(388006),h=r(225669),f=r(494688),g=r(902419),y=r(845226),b=r(443227),k=r(868888),v=r(266615),_=r(130760),w=r(642735),x=r(503510),S=r(47810);function E(e){return[(0,c.D)(),(0,l.Z)(),(0,k.G)(),(0,b.F)(),(0,v.L)(),(0,w.p)(),(0,u.s)(),(0,_.M)()]}function j(e={}){let t=function(e={}){let t={defaultIntegrations:E(),release:"string"==typeof __SENTRY_RELEASE__?__SENTRY_RELEASE__:y.jf.SENTRY_RELEASE&&y.jf.SENTRY_RELEASE.id?y.jf.SENTRY_RELEASE.id:void 0,autoSessionTracking:!0,sendClientReports:!0};return null==e.defaultIntegrations&&delete e.defaultIntegrations,{...t,...e}}(e);if(function(){let e=void 0!==y.jf.window&&y.jf;if(!e)return!1;let t=e.chrome?"chrome":"browser",r=e[t],n=r&&r.runtime&&r.runtime.id,s=y.jf.location&&y.jf.location.href||"",a=!!n&&y.jf===y.jf.top&&["chrome-extension:","moz-extension:","ms-browser-extension:","safari-web-extension:"].some(e=>s.startsWith(`${e}//`)),o=void 0!==e.nw;return!!n&&!a&&!o}())return void(0,m.pq)(()=>{console.error("[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/")});g.T&&!(0,p.vm)()&&m.vF.warn("No Fetch API detected. The Sentry SDK requires a Fetch API compatible environment to send events. Please add a Fetch API polyfill.");let r={...t,stackParser:(0,d.vk)(t.stackParser||x.lG),integrations:(0,i.mH)(t),transport:t.transport||S._},s=(0,o.J)(f.y,r);return t.autoSessionTracking&&function(){if(void 0===y.jf.document){g.T&&m.vF.warn("Session tracking in non-browser environment with @sentry/browser is not supported.");return}(0,n.J0)({ignoreDuration:!0}),(0,n.J5)(),(0,h._)(({from:e,to:t})=>{void 0!==e&&e!==t&&((0,n.J0)({ignoreDuration:!0}),(0,n.J5)())})}(),s}function T(e={}){if(!y.jf.document){g.T&&m.vF.error("Global document not defined in showReportDialog call");return}let t=(0,s.o5)(),r=t.getClient(),o=r&&r.getDsn();if(!o){g.T&&m.vF.error("DSN not configured for showReportDialog call");return}if(t&&(e.user={...t.getUser(),...e.user}),!e.eventId){let t=(0,n.Q)();t&&(e.eventId=t)}let i=y.jf.document.createElement("script");i.async=!0,i.crossOrigin="anonymous",i.src=(0,a.k)(o,e),e.onLoad&&(i.onload=e.onLoad);let{onClose:l}=e;if(l){let e=t=>{if("__sentry_reportdialog_closed__"===t.data)try{l()}finally{y.jf.removeEventListener("message",e)}};y.jf.addEventListener("message",e)}let c=y.jf.document.head||y.jf.document.body;c?c.appendChild(i):g.T&&m.vF.error("Not injecting report dialog. No injection point found in HTML")}function A(){}function C(e){e()}function I(e){let t=(0,s.KU)();t&&t.captureUserFeedback(e)}},553205(e,t,r){"use strict";r.d(t,{Bj:()=>C,DE:()=>N,Dg:()=>T,TD:()=>j,WK:()=>x,Xu:()=>A,c4:()=>_,ex:()=>O,lV:()=>w,ws:()=>M});var n=r(933190),s=r(608119),a=r(276277),o=r(230337),i=r(107842),l=r(696294),c=r(37853),u=r(85182),m=r(902419),d=r(845226);let p=String(0),h="",f="",g="",y=d.jf.navigator&&d.jf.navigator.userAgent||"",b="",k=d.jf.navigator&&d.jf.navigator.language||d.jf.navigator&&d.jf.navigator.languages&&d.jf.navigator.languages[0]||"",v=d.jf.navigator&&d.jf.navigator.userAgentData;function _(e){return"pageload"===(0,s.et)(e).op}function w(e,t){if(!t.length)return e;for(let r of t)e[1].push([{type:"profile"},r]);return e}function x(e){let t=[];return(0,u.yH)(e,(e,r)=>{if("transaction"===r)for(let r=1;r<e.length;r++){let n=e[r];n&&n.contexts&&n.contexts.profile&&n.contexts.profile.profile_id&&t.push(e[r])}}),t}"object"==typeof v&&null!==v&&"getHighEntropyValues"in v&&v.getHighEntropyValues(["architecture","model","platform","platformVersion","fullVersionList"]).then(e=>{if(h=e.platform||"",g=e.architecture||"",b=e.model||"",f=e.platformVersion||"",e.fullVersionList&&e.fullVersionList.length>0){let t=e.fullVersionList[e.fullVersionList.length-1];y=`${t.brand} ${t.version}`}}).catch(e=>void 0);let S=new WeakMap,E=!1,j=3e4;function T(){let e=d.jf.Profiler;if("function"!=typeof e){m.T&&i.vF.log("[Profiling] Profiling is not supported by this browser, Profiler interface missing on window object.");return}let t=Math.floor(j/10);try{return new e({sampleInterval:10,maxBufferSize:t})}catch(e){m.T&&(i.vF.log("[Profiling] Failed to initialize the Profiling constructor, this is likely due to a missing 'Document-Policy': 'js-profiling' header."),i.vF.log("[Profiling] Disabling profiling for current user session.")),E=!0}}function A(e){if(E)return m.T&&i.vF.log("[Profiling] Profiling has been disabled for the duration of the current user session."),!1;if(!e.isRecording())return m.T&&i.vF.log("[Profiling] Discarding profile because transaction was not sampled."),!1;let t=(0,n.KU)(),r=t&&t.getOptions();if(!r)return m.T&&i.vF.log("[Profiling] Profiling disabled, no options found."),!1;let s=r.profilesSampleRate;return("number"!=typeof s&&"boolean"!=typeof s||"number"==typeof s&&isNaN(s)?(m.T&&i.vF.warn(`[Profiling] Invalid sample rate. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(s)} of type ${JSON.stringify(typeof s)}.`),1):!0!==s&&!1!==s&&(s<0||s>1)&&(m.T&&i.vF.warn(`[Profiling] Invalid sample rate. Sample rate must be between 0 and 1. Got ${s}.`),1))?(m.T&&i.vF.warn("[Profiling] Discarding profile because of invalid sample rate."),!1):s?!!(!0===s||Math.random()<s)||(m.T&&i.vF.log(`[Profiling] Discarding profile because it's not included in the random sample (sampling rate = ${Number(s)})`),!1):(m.T&&i.vF.log("[Profiling] Discarding profile because a negative sampling decision was inherited or profileSampleRate is set to 0"),!1)}function C(e,t,r,s){var u;if(!(r.samples.length<2?(m.T&&i.vF.log("[Profiling] Discarding profile because it contains less than 2 samples"),!1):!!r.frames.length||(m.T&&i.vF.log("[Profiling] Discarding profile because it contains no frames"),!1)))return null;if("transaction"!==s.type)throw TypeError("Profiling events may only be attached to transactions, this should never occur.");if(null==r)throw TypeError(`Cannot construct profiling event envelope without a valid profile. Got ${r} instead.`);let v=function(e){let t=e&&e.contexts&&e.contexts.trace&&e.contexts.trace.trace_id;return("string"==typeof t&&32!==t.length&&m.T&&i.vF.log(`[Profiling] Invalid traceId: ${t} on profiled event`),"string"!=typeof t)?"":t}(s),_="thread_metadata"in(u=r)?u:function(e){let t,r=0,n={samples:[],stacks:[],frames:[],thread_metadata:{[p]:{name:"main"}}},s=e.samples[0];if(!s)return n;let a=s.timestamp,o="number"==typeof performance.timeOrigin?performance.timeOrigin:c.k3||0,i=o-(c.k3||o);return e.samples.forEach((s,o)=>{if(void 0===s.stackId){void 0===t&&(t=r,n.stacks[t]=[],r++),n.samples[o]={elapsed_since_start_ns:((s.timestamp+i-a)*1e6).toFixed(0),stack_id:t,thread_id:p};return}let l=e.stacks[s.stackId],c=[];for(;l;){c.push(l.frameId);let t=e.frames[l.frameId];t&&void 0===n.frames[l.frameId]&&(n.frames[l.frameId]={function:t.name,abs_path:"number"==typeof t.resourceId?e.resources[t.resourceId]:void 0,lineno:t.line,colno:t.column}),l=void 0===l.parentId?void 0:e.stacks[l.parentId]}let u={elapsed_since_start_ns:((s.timestamp+i-a)*1e6).toFixed(0),stack_id:r,thread_id:p};n.stacks[r]=c,n.samples[o]=u,r++}),n}(u),w=t||("number"==typeof s.start_timestamp?1e3*s.start_timestamp:1e3*(0,c.zf)()),x="number"==typeof s.timestamp?1e3*s.timestamp:1e3*(0,c.zf)();return{event_id:e,timestamp:new Date(w).toISOString(),platform:"javascript",version:"1",release:s.release||"",environment:s.environment||a.U,runtime:{name:"javascript",version:d.jf.navigator.userAgent},os:{name:h,version:f,build_number:y},device:{locale:k,model:b,manufacturer:y,architecture:g,is_emulator:!1},debug_meta:{images:function(e){let t,r=o.O._sentryDebugIds;if(!r)return[];let s=(0,n.KU)(),a=s&&s.getOptions(),i=a&&a.stackParser;if(!i)return[];let l=S.get(i);l?t=l:(t=new Map,S.set(i,t));let c=Object.keys(r).reduce((e,n)=>{let s,a=t.get(n);a?s=a:(s=i(n),t.set(n,s));for(let t=s.length-1;t>=0;t--){let a=s[t],o=a&&a.filename;if(a&&o){e[o]=r[n];break}}return e},{}),u=[];for(let t of e)t&&c[t]&&u.push({type:"sourcemap",code_file:t,debug_id:c[t]});return u}(r.resources)},profile:_,transactions:[{name:s.transaction||"",id:s.event_id||(0,l.eJ)(),trace_id:v,active_thread_id:p,relative_start_ns:"0",relative_end_ns:((x-w)*1e6).toFixed(0)}]}}let I=new Map;function O(){return I.size}function M(e){let t=I.get(e);return t&&I.delete(e),t}function N(e,t){if(I.set(e,t),I.size>30){let e=I.keys().next().value;I.delete(e)}}},554839(e,t,r){"use strict";r.d(t,{vA:()=>s});class n extends Error{constructor(e){super(e.message),this.code="ERR_ASSERTION"}}function s(e,t="Assertion failed.",r=n){if(!e){if(t instanceof Error)throw t;throw"string"==typeof r?.prototype?.constructor?.name?new r({message:t}):r({message:t})}}},555974(e,t,r){"use strict";r.d(t,{pr:()=>n});let n="APP_INIT_ALIVE"},562298(e,t,r){"use strict";r.d(t,{T:()=>n});let n="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__},571825(e,t,r){"use strict";r.d(t,{Q:()=>a});var n=r(397718),s=r(40209);function a(e,t,r=250,l,c,u,m){var d,p;if(!u.exception||!u.exception.values||!m||!(0,n.tH)(m.originalException,Error))return;let h=u.exception.values.length>0?u.exception.values[u.exception.values.length-1]:void 0;h&&(u.exception.values=(d=function e(t,r,s,a,l,c,u,m){if(c.length>=s+1)return c;let d=[...c];if((0,n.tH)(a[l],Error)){o(u,m);let n=t(r,a[l]),c=d.length;i(n,l,c,m),d=e(t,r,s,a[l],l,[n,...d],n,c)}return Array.isArray(a.errors)&&a.errors.forEach((a,c)=>{if((0,n.tH)(a,Error)){o(u,m);let n=t(r,a),p=d.length;i(n,`errors[${c}]`,p,m),d=e(t,r,s,a,l,[n,...d],n,p)}}),d}(e,t,c,m.originalException,l,u.exception.values,h,0),p=r,d.map(e=>(e.value&&(e.value=(0,s.xv)(e.value,p)),e))))}function o(e,t){e.mechanism=e.mechanism||{type:"generic",handled:!0},e.mechanism={...e.mechanism,..."AggregateError"===e.type&&{is_exception_group:!0},exception_id:t}}function i(e,t,r,n){e.mechanism=e.mechanism||{type:"generic",handled:!0},e.mechanism={...e.mechanism,type:"chained",source:t,exception_id:r,parent_id:n}}},572858(e,t,r){"use strict";r.d(t,{TC:()=>i,kM:()=>o});var n=r(644094),s=r(696294);let a=RegExp("^[ \\t]*([0-9a-f]{32})?-?([0-9a-f]{16})?-?([01])?[ \\t]*$");function o(e,t){let r=function(e){let t;if(!e)return;let r=e.match(a);if(r)return"1"===r[3]?t=!0:"0"===r[3]&&(t=!1),{traceId:r[1],parentSampled:t,parentSpanId:r[2]}}(e),o=(0,n.yD)(t),{traceId:i,parentSpanId:l,parentSampled:c}=r||{};return r?{traceId:i||(0,s.eJ)(),parentSpanId:l||(0,s.eJ)().substring(16),spanId:(0,s.eJ)().substring(16),sampled:c,dsc:o||{}}:{traceId:i||(0,s.eJ)(),spanId:(0,s.eJ)().substring(16)}}function i(e=(0,s.eJ)(),t=(0,s.eJ)().substring(16),r){let n="";return void 0!==r&&(n=r?"-1":"-0"),`${e}-${t}${n}`}},584222(e,t,r){"use strict";r.d(t,{Lb:()=>i,d_:()=>o});var n=r(97407);let s="_sentryScope",a="_sentryIsolationScope";function o(e,t,r){e&&((0,n.my)(e,a,r),(0,n.my)(e,s,t))}function i(e){return{scope:e[s],isolationScope:e[a]}}},584553(e,t,r){"use strict";r.d(t,{f:()=>n,z:()=>s});let n={rpc:{invalidInput:-32e3,resourceNotFound:-32001,resourceUnavailable:-32002,transactionRejected:-32003,methodNotSupported:-32004,limitExceeded:-32005,parse:-32700,invalidRequest:-32600,methodNotFound:-32601,invalidParams:-32602,internal:-32603},provider:{userRejectedRequest:4001,unauthorized:4100,unsupportedMethod:4200,disconnected:4900,chainDisconnected:4901}},s={"-32700":{standard:"JSON RPC 2.0",message:"Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."},"-32600":{standard:"JSON RPC 2.0",message:"The JSON sent is not a valid Request object."},"-32601":{standard:"JSON RPC 2.0",message:"The method does not exist / is not available."},"-32602":{standard:"JSON RPC 2.0",message:"Invalid method parameter(s)."},"-32603":{standard:"JSON RPC 2.0",message:"Internal JSON-RPC error."},"-32000":{standard:"EIP-1474",message:"Invalid input."},"-32001":{standard:"EIP-1474",message:"Resource not found."},"-32002":{standard:"EIP-1474",message:"Resource unavailable."},"-32003":{standard:"EIP-1474",message:"Transaction rejected."},"-32004":{standard:"EIP-1474",message:"Method not supported."},"-32005":{standard:"EIP-1474",message:"Request limit exceeded."},4001:{standard:"EIP-1193",message:"User rejected the request."},4100:{standard:"EIP-1193",message:"The requested account and/or method has not been authorized by the user."},4200:{standard:"EIP-1193",message:"The requested method is not supported by this Ethereum provider."},4900:{standard:"EIP-1193",message:"The provider is disconnected from all chains."},4901:{standard:"EIP-1193",message:"The provider is disconnected from the specified chain."}}},586312(e,t,r){"use strict";r.d(t,{T2:()=>l,XW:()=>o,xg:()=>i});var n,s,a=r(397718);function o(e){return new l(t=>{t(e)})}function i(e){return new l((t,r)=>{r(e)})}(n=s||(s={}))[n.PENDING=0]="PENDING",n[n.RESOLVED=1]="RESOLVED",n[n.REJECTED=2]="REJECTED";class l{constructor(e){l.prototype.__init.call(this),l.prototype.__init2.call(this),l.prototype.__init3.call(this),l.prototype.__init4.call(this),this._state=s.PENDING,this._handlers=[];try{e(this._resolve,this._reject)}catch(e){this._reject(e)}}then(e,t){return new l((r,n)=>{this._handlers.push([!1,t=>{if(e)try{r(e(t))}catch(e){n(e)}else r(t)},e=>{if(t)try{r(t(e))}catch(e){n(e)}else n(e)}]),this._executeHandlers()})}catch(e){return this.then(e=>e,e)}finally(e){return new l((t,r)=>{let n,s;return this.then(t=>{s=!1,n=t,e&&e()},t=>{s=!0,n=t,e&&e()}).then(()=>{if(s)return void r(n);t(n)})})}__init(){this._resolve=e=>{this._setResult(s.RESOLVED,e)}}__init2(){this._reject=e=>{this._setResult(s.REJECTED,e)}}__init3(){this._setResult=(e,t)=>{if(this._state===s.PENDING){if((0,a.Qg)(t))return void t.then(this._resolve,this._reject);this._state=e,this._value=t,this._executeHandlers()}}}__init4(){this._executeHandlers=()=>{if(this._state===s.PENDING)return;let e=this._handlers.slice();this._handlers=[],e.forEach(e=>{e[0]||(this._state===s.RESOLVED&&e[1](this._value),this._state===s.REJECTED&&e[2](this._value),e[0]=!0)})}}}},587044(e,t,r){"use strict";r.d(t,{N:()=>i});var n=r(895315),s=r(85182),a=r(76838);function o(e,t){let r;return(0,s.yH)(e,(e,n)=>(t.includes(n)&&(r=Array.isArray(e)?e[1]:void 0),!!r)),r}function i(e,t){return r=>{let i=e(r),l=new Map;function c(t,s){let i=s?`${t}:${s}`:t,c=l.get(i);if(!c){let u=(0,n.hH)(t);if(!u)return;let m=(0,a.Z)(u,r.tunnel);c=s?(t=>{let r=e(t);return{...r,send:async e=>{let t=o(e,["event","transaction","profile","replay_event"]);return t&&(t.release=s),r.send(e)}}})({...r,url:m}):e({...r,url:m}),l.set(i,c)}return[t,c]}return{send:async function(e){let r=t({envelope:e,getEvent:function(t){return o(e,t&&t.length?t:["event"])}}).map(e=>"string"==typeof e?c(e,void 0):c(e.dsn,e.release)).filter(e=>!!e),n=r.length?r:[["",i]];return(await Promise.all(n.map(([t,r])=>r.send((0,s.h4)(t?{...e[0],dsn:t}:e[0],e[1])))))[0]},flush:async function(e){let t=[...l.values(),i];return(await Promise.all(t.map(t=>t.flush(e)))).every(e=>e)}}}}},591386(e,t,r){"use strict";r.d(t,{Nt:()=>E,Sx:()=>S,dp:()=>x});var n=r(234598),s=r(225669),a=r(185746),o=r(718800),i=r(441227),l=r(836164),c=r(812863),u=r(933190),m=r(608119),d=r(834028),p=r(230337),h=r(107842),f=r(37853),g=r(572858),y=r(620209),b=r(902419),k=r(845226),v=r(369735),_=r(659129);let w={...i.C,instrumentNavigation:!0,instrumentPageLoad:!0,markBackgroundSpan:!0,enableLongTask:!0,enableLongAnimationFrame:!0,enableInp:!0,_experiments:{},..._.h$},x=(e={})=>{(0,o.s)();let{enableInp:t,enableLongTask:r,enableLongAnimationFrame:d,_experiments:{enableInteractions:y,enableStandaloneClsSpans:x},beforeStartSpan:T,idleTimeout:A,finalTimeout:C,childSpanTimeout:I,markBackgroundSpan:O,traceFetch:M,traceXHR:N,shouldCreateSpanForRequest:D,enableHTTPTimings:R,instrumentPageLoad:L,instrumentNavigation:F}={...w,...e},P=(0,n.bk)({recordClsStandaloneSpans:x||!1});t&&(0,a.Z)(),d&&p.O.PerformanceObserver&&PerformanceObserver.supportedEntryTypes&&PerformanceObserver.supportedEntryTypes.includes("long-animation-frame")?(0,n.U$)():r&&(0,n.c8)(),y&&(0,n.DI)();let q={name:void 0,source:void 0};function z(e,t){let r="pageload"===t.op,s=T?T(t):t,a=s.attributes||{};t.name!==s.name&&(a[c.i_]="custom",s.attributes=a),q.name=s.name,q.source=a[c.i_];let o=(0,i.D)(s,{idleTimeout:A,finalTimeout:C,childSpanTimeout:I,disableAutoFinish:r,beforeSpanEnd:e=>{P(),(0,n.QU)(e,{recordClsOnPageloadSpan:!x})}});function l(){["interactive","complete"].includes(k.jf.document.readyState)&&e.emit("idleSpanEnableAutoFinish",o)}return r&&k.jf.document&&(k.jf.document.addEventListener("readystatechange",()=>{l()}),l()),o}return{name:"BrowserTracing",afterAllSetup(e){var r,n,o,d;let p,w,x=k.jf.location&&k.jf.location.href;e.on("startNavigationSpan",t=>{(0,u.KU)()===e&&(w&&!(0,m.et)(w).timestamp&&(b.T&&h.vF.log(`[Tracing] Finishing current root span with op: ${(0,m.et)(w).op}`),w.end()),w=z(e,{op:"navigation",...t}))}),e.on("startPageLoadSpan",(t,r={})=>{if((0,u.KU)()!==e)return;w&&!(0,m.et)(w).timestamp&&(b.T&&h.vF.log(`[Tracing] Finishing current root span with op: ${(0,m.et)(w).op}`),w.end());let n=r.sentryTrace||j("sentry-trace"),s=r.baggage||j("baggage"),a=(0,g.kM)(n,s);(0,u.o5)().setPropagationContext(a),w=z(e,{op:"pageload",...t})}),e.on("spanEnd",e=>{let t=(0,m.et)(e).op;if(e!==(0,m.zU)(e)||"navigation"!==t&&"pageload"!==t)return;let r=(0,u.o5)(),n=r.getPropagationContext();r.setPropagationContext({...n,sampled:void 0!==n.sampled?n.sampled:(0,m.pK)(e),dsc:n.dsc||(0,l.k1)(e)})}),k.jf.location&&(L&&S(e,{name:k.jf.location.pathname,startTime:f.k3?f.k3/1e3:void 0,attributes:{[c.i_]:"url",[c.JD]:"auto.pageload.browser"}}),F&&(0,s._)(({to:t,from:r})=>{if(void 0===r&&x&&-1!==x.indexOf(t)){x=void 0;return}r!==t&&(x=void 0,E(e,{name:k.jf.location.pathname,attributes:{[c.i_]:"url",[c.JD]:"auto.navigation.browser"}}))})),O&&(0,v.i)(),y&&(r=A,n=C,o=I,d=q,k.jf.document&&addEventListener("click",()=>{let e="ui.action.click",t=(0,m.Bk)(),s=t&&(0,m.zU)(t);if(s&&["navigation","pageload"].includes((0,m.et)(s).op)){b.T&&h.vF.warn(`[Tracing] Did not create ${e} span because a pageload or navigation span is in progress.`);return}if(p&&(p.setAttribute(c.fs,"interactionInterrupted"),p.end(),p=void 0),!d.name){b.T&&h.vF.warn(`[Tracing] Did not create ${e} transaction because _latestRouteName is missing.`);return}p=(0,i.D)({name:d.name,op:e,attributes:{[c.i_]:d.source||"url"}},{idleTimeout:r,finalTimeout:n,childSpanTimeout:o})},{once:!1,capture:!0})),t&&(0,a.B)(),(0,_.Qb)(e,{traceFetch:M,traceXHR:N,tracePropagationTargets:e.getOptions().tracePropagationTargets,shouldCreateSpanForRequest:D,enableHTTPTimings:R})}}};function S(e,t,r){e.emit("startPageLoadSpan",t,r),(0,u.o5)().setTransactionName(t.name);let n=(0,m.Bk)();return"pageload"===(n&&(0,m.et)(n).op)?n:void 0}function E(e,t){(0,u.rm)().setPropagationContext((0,y.J)()),(0,u.o5)().setPropagationContext((0,y.J)()),e.emit("startNavigationSpan",t),(0,u.o5)().setTransactionName(t.name);let r=(0,m.Bk)();return"navigation"===(r&&(0,m.et)(r).op)?r:void 0}function j(e){let t=(0,d.NX)(`meta[name=${e}]`);return t?t.getAttribute("content"):void 0}},597014(e,t,r){"use strict";r.d(t,{Vu:()=>l,fj:()=>o,qO:()=>i});var n=r(696294),s=r(97407),a=r(37853);function o(e){let t=(0,a.zf)(),r={sid:(0,n.eJ)(),init:!0,timestamp:t,started:t,duration:0,status:"ok",errors:0,ignoreDuration:!1,toJSON:()=>{var e;return e=r,(0,s.Ce)({sid:`${e.sid}`,init:e.init,started:new Date(1e3*e.started).toISOString(),timestamp:new Date(1e3*e.timestamp).toISOString(),status:e.status,errors:e.errors,did:"number"==typeof e.did||"string"==typeof e.did?`${e.did}`:void 0,duration:e.duration,abnormal_mechanism:e.abnormal_mechanism,attrs:{release:e.release,environment:e.environment,ip_address:e.ipAddress,user_agent:e.userAgent}})}};return e&&i(r,e),r}function i(e,t={}){if(t.user&&(!e.ipAddress&&t.user.ip_address&&(e.ipAddress=t.user.ip_address),e.did||t.did||(e.did=t.user.id||t.user.email||t.user.username)),e.timestamp=t.timestamp||(0,a.zf)(),t.abnormal_mechanism&&(e.abnormal_mechanism=t.abnormal_mechanism),t.ignoreDuration&&(e.ignoreDuration=t.ignoreDuration),t.sid&&(e.sid=32===t.sid.length?t.sid:(0,n.eJ)()),void 0!==t.init&&(e.init=t.init),!e.did&&t.did&&(e.did=`${t.did}`),"number"==typeof t.started&&(e.started=t.started),e.ignoreDuration)e.duration=void 0;else if("number"==typeof t.duration)e.duration=t.duration;else{let t=e.timestamp-e.started;e.duration=t>=0?t:0}t.release&&(e.release=t.release),t.environment&&(e.environment=t.environment),!e.ipAddress&&t.ipAddress&&(e.ipAddress=t.ipAddress),!e.userAgent&&t.userAgent&&(e.userAgent=t.userAgent),"number"==typeof t.errors&&(e.errors=t.errors),t.status&&(e.status=t.status)}function l(e,t){let r={};t?r={status:t}:"ok"===e.status&&(r={status:"exited"}),i(e,r)}},597361(e,t,r){"use strict";r.d(t,{t:()=>i});var n=r(290266),s=r(545203),a=r(728195),o=r(157392);let i=(0,s.kp)(o.Wu,(0,n.Ik)({type:(0,a.eu)(o.Z6.Spinner)}))},608119(e,t,r){"use strict";r.d(t,{Bk:()=>C,CC:()=>p,Ck:()=>f,Hu:()=>E,Qh:()=>y,VS:()=>j,aO:()=>h,cI:()=>b,et:()=>v,kX:()=>g,pK:()=>_,r2:()=>I,xO:()=>T,yW:()=>w,zU:()=>A});var n=r(97407),s=r(37853),a=r(572858),o=r(960196),i=r(16278),l=r(933190),c=r(973149),u=r(812863),m=r(96331),d=r(71409);let p=0,h=1;function f(e){let{spanId:t,traceId:r}=e.spanContext(),{data:s,op:a,parent_span_id:o,status:i,origin:l}=v(e);return(0,n.Ce)({parent_span_id:o,span_id:t,trace_id:r,data:s,op:a,status:i,origin:l})}function g(e){let{spanId:t,traceId:r}=e.spanContext(),{parent_span_id:s}=v(e);return(0,n.Ce)({parent_span_id:s,span_id:t,trace_id:r})}function y(e){let{traceId:t,spanId:r}=e.spanContext(),n=_(e);return(0,a.TC)(t,r,n)}function b(e){return"number"==typeof e?k(e):Array.isArray(e)?e[0]+e[1]/1e9:e instanceof Date?k(e.getTime()):(0,s.zf)()}function k(e){return e>0x2540be3ff?e/1e3:e}function v(e){if("function"==typeof e.getSpanJSON)return e.getSpanJSON();try{var t;let{spanId:r,traceId:s}=e.spanContext();if((t=e).attributes&&t.startTime&&t.name&&t.endTime&&t.status){let{attributes:t,startTime:a,name:o,endTime:i,parentSpanId:l,status:m}=e;return(0,n.Ce)({span_id:r,trace_id:s,data:t,description:o,parent_span_id:l,start_timestamp:b(a),timestamp:b(i)||void 0,status:w(m),op:t[u.uT],origin:t[u.JD],_metrics_summary:(0,c.g)(e)})}return{span_id:r,trace_id:s}}catch(e){return{}}}function _(e){let{traceFlags:t}=e.spanContext();return t===h}function w(e){if(e&&e.code!==m.a3)return e.code===m.F3?"ok":e.message||"unknown_error"}let x="_sentryChildSpans",S="_sentryRootSpan";function E(e,t){let r=e[S]||e;(0,n.my)(t,S,r),e[x]?e[x].add(t):(0,n.my)(e,x,new Set([t]))}function j(e,t){e[x]&&e[x].delete(t)}function T(e){let t=new Set;return!function e(r){if(!t.has(r)&&_(r))for(let n of(t.add(r),r[x]?Array.from(r[x]):[]))e(n)}(e),Array.from(t)}function A(e){return e[S]||e}function C(){let e=(0,i.E)(),t=(0,o.h)(e);return t.getActiveSpan?t.getActiveSpan():(0,d.f)((0,l.o5)())}function I(e,t,r,n,s,a){let o=C();o&&(0,c.X)(o,e,t,r,n,s,a)}},612815(e,t,r){"use strict";function n(e){return"object"==typeof e&&null!==e}function s(e){return"symbol"==typeof e?e.toString():"string"==typeof e?JSON.stringify(e):`${e}`}function a(e){let{done:t,value:r}=e.next();return t?void 0:r}function*o(e,t,r,a){var o;for(let i of(n(o=e)&&"function"==typeof o[Symbol.iterator]||(e=[e]),e)){let e=function(e,t,r,n){if(!0===e)return;!1===e?e={}:"string"==typeof e&&(e={message:e});let{path:a,branch:o}=t,{type:i}=r,{refinement:l,message:c=`Expected a value of type \`${i}\`${l?` with refinement \`${l}\``:""}, but received: \`${s(n)}\``}=e;return{value:n,type:i,refinement:l,key:a[a.length-1],path:a,branch:o,...e,message:c}}(i,t,r,a);e&&(yield e)}}r.d(t,{Gv:()=>n,RF:()=>o,eF:()=>function* e(t,r,s={}){let{path:a=[],branch:o=[t],coerce:i=!1,mask:l=!1}=s,c={path:a,branch:o};if(i&&(t=r.coercer(t,c),l&&"type"!==r.type&&n(r.schema)&&n(t)&&!Array.isArray(t)))for(let e in t)void 0===r.schema[e]&&delete t[e];let u="valid";for(let e of r.validator(t,c))e.explanation=s.message,u="not_valid",yield[e,void 0];for(let[m,d,p]of r.entries(t,c))for(let r of e(d,p,{path:void 0===m?a:[...a,m],branch:void 0===m?o:[...o,d],coerce:i,mask:l,message:s.message}))r[0]?(u=null===r[0].refinement||void 0===r[0].refinement?"not_valid":"not_refined",yield[r[0],void 0]):i&&(d=r[1],void 0===m?t=d:t instanceof Map?t.set(m,d):t instanceof Set?t.add(d):n(t)&&(void 0!==d||m in t)&&(t[m]=d));if("not_valid"!==u)for(let e of r.refiner(t,c))e.explanation=s.message,u="not_refined",yield[e,void 0];"valid"===u&&(yield[void 0,t])},jT:()=>a,yy:()=>s})},620209(e,t,r){"use strict";r.d(t,{J:()=>s});var n=r(696294);function s(){return{traceId:(0,n.eJ)(),spanId:(0,n.eJ)().substring(16)}}},631905(e,t,r){"use strict";r.d(t,{B:()=>o});var n=r(92376),s=r(933190),a=r(793111);let o=function(){return{bindClient(e){(0,s.o5)().setClient(e)},withScope:s.v4,getClient:()=>(0,s.KU)(),getScope:s.o5,getIsolationScope:s.rm,captureException:(e,t)=>(0,s.o5)().captureException(e,t),captureMessage:(e,t,r)=>(0,s.o5)().captureMessage(e,t,r),captureEvent:a.r,addBreadcrumb:n.Z,setUser:a.gV,setTags:a.Wt,setTag:a.NA,setExtra:a.l7,setExtras:a.cx,setContext:a.o,getIntegration(e){let t=(0,s.KU)();return t&&t.getIntegrationByName(e.id)||null},startSession:a.J0,endSession:a.ky,captureSession(e){if(e)return(0,a.ky)();let t=(0,s.o5)(),r=(0,s.KU)(),n=t.getSession();r&&n&&r.captureSession(n)}}}},633089(e,t,r){"use strict";r.d(t,{$:()=>i});var n=r(290266),s=r(545203),a=r(728195),o=r(157392);let i=(0,s.kp)(o.Tl,(0,n.Ik)({type:(0,a.eu)(o.Z6.Copyable),value:(0,n.Yj)(),sensitive:(0,n.lq)((0,n.zM)())}))},640846(e,t,r){"use strict";r.d(t,{A:()=>v});var n=r(316244),s=r(208570),a=r(392134),o=r(347022),i=r(831022);let l={},c={};function u(e,t={}){let r=JSON.stringify([e,t]),n=c[r];return n||(n=new Intl.DateTimeFormat(e,t),c[r]=n),n}let m={},d={},p=null,h={};function f(e,t,r,n){let s=e.listingMode();return"error"===s?null:"en"===s?r(t):n(t)}class g{constructor(e,t,r){this.padTo=r.padTo||0,this.floor=r.floor||!1;let{padTo:n,floor:s,...a}=r;if(!t||Object.keys(a).length>0){let t={useGrouping:!1,...r};r.padTo>0&&(t.minimumIntegerDigits=r.padTo),this.inf=function(e,t={}){let r=JSON.stringify([e,t]),n=m[r];return n||(n=new Intl.NumberFormat(e,t),m[r]=n),n}(e,t)}}format(e){if(this.inf){let t=this.floor?Math.floor(e):e;return this.inf.format(t)}{let t=this.floor?Math.floor(e):(0,n.GB)(e,3);return(0,n.CF)(t,this.padTo)}}}class y{constructor(e,t,r){let n;if(this.opts=r,this.originalZone=void 0,this.opts.timeZone)this.dt=e;else if("fixed"===e.zone.type){let t=-1*(e.offset/60),r=t>=0?`Etc/GMT+${t}`:`Etc/GMT${t}`;0!==e.offset&&i.A.create(r).valid?(n=r,this.dt=e):(n="UTC",this.dt=0===e.offset?e:e.setZone("UTC").plus({minutes:e.offset}),this.originalZone=e.zone)}else"system"===e.zone.type?this.dt=e:"iana"===e.zone.type?(this.dt=e,n=e.zone.name):(n="UTC",this.dt=e.setZone("UTC").plus({minutes:e.offset}),this.originalZone=e.zone);let s={...this.opts};s.timeZone=s.timeZone||n,this.dtf=u(t,s)}format(){return this.originalZone?this.formatToParts().map(({value:e})=>e).join(""):this.dtf.format(this.dt.toJSDate())}formatToParts(){let e=this.dtf.formatToParts(this.dt.toJSDate());return this.originalZone?e.map(e=>{if("timeZoneName"!==e.type)return e;{let t=this.originalZone.offsetName(this.dt.ts,{locale:this.dt.locale,format:this.opts.timeZoneName});return{...e,value:t}}}):e}resolvedOptions(){return this.dtf.resolvedOptions()}}class b{constructor(e,t,r){this.opts={style:"long",...r},!t&&(0,n.h3)()&&(this.rtf=function(e,t={}){let{base:r,...n}=t,s=JSON.stringify([e,n]),a=d[s];return a||(a=new Intl.RelativeTimeFormat(e,t),d[s]=a),a}(e,r))}format(e,t){return this.rtf?this.rtf.format(e,t):s.fw(t,e,this.opts.numeric,"long"!==this.opts.style)}formatToParts(e,t){return this.rtf?this.rtf.formatToParts(e,t):[]}}let k={firstDay:1,minimalDays:4,weekend:[6,7]};class v{static fromOpts(e){return v.create(e.locale,e.numberingSystem,e.outputCalendar,e.weekSettings,e.defaultToEN)}static create(e,t,r,s,o=!1){let i=e||a.A.defaultLocale,l=i||(o?"en-US":p||(p=new Intl.DateTimeFormat().resolvedOptions().locale)),c=t||a.A.defaultNumberingSystem;return new v(l,c,r||a.A.defaultOutputCalendar,(0,n._v)(s)||a.A.defaultWeekSettings,i)}static resetCache(){p=null,c={},m={},d={}}static fromObject({locale:e,numberingSystem:t,outputCalendar:r,weekSettings:n}={}){return v.create(e,t,r,n)}constructor(e,t,r,n,s){let[a,o,i]=function(e){let t=e.indexOf("-x-");-1!==t&&(e=e.substring(0,t));let r=e.indexOf("-u-");if(-1===r)return[e];{let t,n;try{t=u(e).resolvedOptions(),n=e}catch(a){let s=e.substring(0,r);t=u(s).resolvedOptions(),n=s}let{numberingSystem:s,calendar:a}=t;return[n,s,a]}}(e);this.locale=a,this.numberingSystem=t||o||null,this.outputCalendar=r||i||null,this.weekSettings=n,this.intl=function(e,t,r){return(r||t)&&(e.includes("-u-")||(e+="-u"),r&&(e+=`-ca-${r}`),t&&(e+=`-nu-${t}`)),e}(this.locale,this.numberingSystem,this.outputCalendar),this.weekdaysCache={format:{},standalone:{}},this.monthsCache={format:{},standalone:{}},this.meridiemCache=null,this.eraCache={},this.specifiedLocale=s,this.fastNumbersCached=null}get fastNumbers(){return null==this.fastNumbersCached&&(this.fastNumbersCached=(!this.numberingSystem||"latn"===this.numberingSystem)&&("latn"===this.numberingSystem||!this.locale||this.locale.startsWith("en")||"latn"===new Intl.DateTimeFormat(this.intl).resolvedOptions().numberingSystem)),this.fastNumbersCached}listingMode(){let e=this.isEnglish(),t=(null===this.numberingSystem||"latn"===this.numberingSystem)&&(null===this.outputCalendar||"gregory"===this.outputCalendar);return e&&t?"en":"intl"}clone(e){return e&&0!==Object.getOwnPropertyNames(e).length?v.create(e.locale||this.specifiedLocale,e.numberingSystem||this.numberingSystem,e.outputCalendar||this.outputCalendar,(0,n._v)(e.weekSettings)||this.weekSettings,e.defaultToEN||!1):this}redefaultToEN(e={}){return this.clone({...e,defaultToEN:!0})}redefaultToSystem(e={}){return this.clone({...e,defaultToEN:!1})}months(e,t=!1){return f(this,e,s.US,()=>{let r=t?{month:e,day:"numeric"}:{month:e},n=t?"format":"standalone";return this.monthsCache[n][e]||(this.monthsCache[n][e]=function(e){let t=[];for(let r=1;r<=12;r++){let n=o.A.utc(2009,r,1);t.push(e(n))}return t}(e=>this.extract(e,r,"month"))),this.monthsCache[n][e]})}weekdays(e,t=!1){return f(this,e,s.mx,()=>{let r=t?{weekday:e,year:"numeric",month:"long",day:"numeric"}:{weekday:e},n=t?"format":"standalone";return this.weekdaysCache[n][e]||(this.weekdaysCache[n][e]=function(e){let t=[];for(let r=1;r<=7;r++){let n=o.A.utc(2016,11,13+r);t.push(e(n))}return t}(e=>this.extract(e,r,"weekday"))),this.weekdaysCache[n][e]})}meridiems(){return f(this,void 0,()=>s.us,()=>{if(!this.meridiemCache){let e={hour:"numeric",hourCycle:"h12"};this.meridiemCache=[o.A.utc(2016,11,13,9),o.A.utc(2016,11,13,19)].map(t=>this.extract(t,e,"dayperiod"))}return this.meridiemCache})}eras(e){return f(this,e,s.qH,()=>{let t={era:e};return this.eraCache[e]||(this.eraCache[e]=[o.A.utc(-40,1,1),o.A.utc(2017,1,1)].map(e=>this.extract(e,t,"era"))),this.eraCache[e]})}extract(e,t,r){let n=this.dtFormatter(e,t).formatToParts().find(e=>e.type.toLowerCase()===r);return n?n.value:null}numberFormatter(e={}){return new g(this.intl,e.forceSimple||this.fastNumbers,e)}dtFormatter(e,t={}){return new y(e,this.intl,t)}relFormatter(e={}){return new b(this.intl,this.isEnglish(),e)}listFormatter(e={}){return function(e,t={}){let r=JSON.stringify([e,t]),n=l[r];return n||(n=new Intl.ListFormat(e,t),l[r]=n),n}(this.intl,e)}isEnglish(){return"en"===this.locale||"en-us"===this.locale.toLowerCase()||new Intl.DateTimeFormat(this.intl).resolvedOptions().locale.startsWith("en-us")}getWeekSettings(){if(this.weekSettings)return this.weekSettings;if(!(0,n.jv)())return k;var e=this.locale;let t=h[e];if(!t){let r=new Intl.Locale(e);t="getWeekInfo"in r?r.getWeekInfo():r.weekInfo,h[e]=t}return t}getStartOfWeek(){return this.getWeekSettings().firstDay}getMinDaysInFirstWeek(){return this.getWeekSettings().minimalDays}getWeekendDays(){return this.getWeekSettings().weekend}equals(e){return this.locale===e.locale&&this.numberingSystem===e.numberingSystem&&this.outputCalendar===e.outputCalendar}toString(){return`Locale(${this.locale}, ${this.numberingSystem}, ${this.outputCalendar})`}}},642735(e,t,r){"use strict";r.d(t,{p:()=>o});var n=r(290264),s=r(571825),a=r(943544);let o=(0,n._C)((e={})=>{let t=e.limit||5,r=e.key||"cause";return{name:"LinkedErrors",preprocessEvent(e,n,o){let i=o.getOptions();(0,s.Q)(a.K8,i.stackParser,i.maxValueLength,r,t,e,n)}}})},644094(e,t,r){"use strict";r.d(t,{De:()=>u,hF:()=>o,yD:()=>c});var n=r(562298),s=r(397718),a=r(107842);let o="baggage",i="sentry-",l=/^sentry-/;function c(e){let t=function(e){if(e&&((0,s.Kg)(e)||Array.isArray(e)))return Array.isArray(e)?e.reduce((e,t)=>(Object.entries(m(t)).forEach(([t,r])=>{e[t]=r}),e),{}):m(e)}(e);if(!t)return;let r=Object.entries(t).reduce((e,[t,r])=>(t.match(l)&&(e[t.slice(i.length)]=r),e),{});return Object.keys(r).length>0?r:void 0}function u(e){if(e){var t=Object.entries(e).reduce((e,[t,r])=>(r&&(e[`${i}${t}`]=r),e),{});return 0!==Object.keys(t).length?Object.entries(t).reduce((e,[t,r],s)=>{let o=`${encodeURIComponent(t)}=${encodeURIComponent(r)}`,i=0===s?o:`${e},${o}`;return i.length>8192?(n.T&&a.vF.warn(`Not adding key: ${t} with val: ${r} to baggage header due to exceeding baggage size limits.`),e):i},""):void 0}}function m(e){return e.split(",").map(e=>e.split("=").map(e=>decodeURIComponent(e.trim()))).reduce((e,[t,r])=>(t&&r&&(e[t]=r),e),{})}},648017(e,t,r){"use strict";r.d(t,{N:()=>s});let n=r(230337).O;function s(){let e=n.chrome,t=e&&e.app&&e.app.runtime,r="history"in n&&!!n.history.pushState&&!!n.history.replaceState;return!t&&r}},652825(e,t,r){"use strict";r.d(t,{Ej:()=>o,T1:()=>a,YP:()=>i});var n=r(448967),s=r(612815);function a(e,t){return i(e,"pattern",r=>t.test(r)||`Expected a ${e.type} matching \`/${t.source}/\` but received "${r}"`)}function o(e,t,r=t){let n=`Expected a ${e.type}`,s=t===r?`of \`${t}\``:`between \`${t}\` and \`${r}\``;return i(e,"size",e=>{if("number"==typeof e||e instanceof Date)return t<=e&&e<=r||`${n} ${s} but received \`${e}\``;if(e instanceof Map||e instanceof Set){let{size:a}=e;return t<=a&&a<=r||`${n} with a size ${s} but received one with a size of \`${a}\``}let{length:a}=e;return t<=a&&a<=r||`${n} with a length ${s} but received one with a length of \`${a}\``})}function i(e,t,r){return new n._k({...e,*refiner(n,a){yield*e.refiner(n,a);let o=r(n,a);for(let r of(0,s.RF)(o,a,e,n))yield{...r,refinement:t}}})}},654761(e,t,r){"use strict";r.d(t,{S8:()=>l,cd:()=>function e(t,r=3,n=102400){let s=l(t,r);return~-encodeURI(JSON.stringify(s)).split(/%..|./).length>n?e(t,r-1,n):s}});var n=r(397718),s=r(940344),o=r(97407),i=r(680985);function l(e,t=100,r=Infinity){try{return function e(t,r,l=Infinity,c=Infinity,u=(0,s.s)()){let[m,d]=u;if(null==r||["boolean","string"].includes(typeof r)||"number"==typeof r&&Number.isFinite(r))return r;let p=function(e,t){try{if("domain"===e&&t&&"object"==typeof t&&t._events)return"[Domain]";if("domainEmitter"===e)return"[DomainEmitter]";if("undefined"!=typeof globalThis&&t===globalThis)return"[Global]";if("undefined"!=typeof window&&t===window)return"[Window]";if(void 0!==a&&t===a)return"[Document]";if((0,n.L2)(t))return"[VueViewModel]";if((0,n.mE)(t))return"[SyntheticEvent]";if("number"==typeof t&&!Number.isFinite(t))return`[${t}]`;if("function"==typeof t)return`[Function: ${(0,i.qQ)(t)}]`;if("symbol"==typeof t)return`[${String(t)}]`;if("bigint"==typeof t)return`[BigInt: ${String(t)}]`;let r=function(e){let t=Object.getPrototypeOf(e);return t?t.constructor.name:"null prototype"}(t);if(/^HTML(\w*)Element$/.test(r))return`[HTMLElement: ${r}]`;return`[object ${r}]`}catch(e){return`**non-serializable** (${e})`}}(t,r);if(!p.startsWith("[object "))return p;if(r.__sentry_skip_normalization__)return r;let h="number"==typeof r.__sentry_override_normalization_depth__?r.__sentry_override_normalization_depth__:l;if(0===h)return p.replace("object ","");if(m(r))return"[Circular ~]";if(r&&"function"==typeof r.toJSON)try{let t=r.toJSON();return e("",t,h-1,c,u)}catch(e){}let f=Array.isArray(r)?[]:{},g=0,y=(0,o.W4)(r);for(let t in y){if(!Object.prototype.hasOwnProperty.call(y,t))continue;if(g>=c){f[t]="[MaxProperties ~]";break}let r=y[t];f[t]=e(t,r,h-1,c,u),g++}return d(r),f}("",e,t,r)}catch(e){return{ERROR:`**non-serializable** (${e})`}}}},659008(e,t,r){"use strict";r.d(t,{A:()=>a});var n,s=new Uint8Array(16);function a(){if(!n&&!(n="undefined"!=typeof crypto&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto)||"undefined"!=typeof msCrypto&&"function"==typeof msCrypto.getRandomValues&&msCrypto.getRandomValues.bind(msCrypto)))throw Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");return n(s)}},659129(e,t,r){"use strict";r.d(t,{Qb:()=>E,h$:()=>S});var s=r(932294),a=r(714599),o=r(140722),i=r(96331),l=r(16686),c=r(836164),u=r(812863),m=r(933190),d=r(777217),p=r(608119),h=r(730074),f=r(821016),g=r(40209),y=r(37853),b=r(572858),k=r(644094),v=r(830339),_=r(845226);let w=new WeakMap,x=new Map,S={traceFetch:!0,traceXHR:!0,enableHTTPTimings:!0};function E(e,t){let{traceFetch:r,traceXHR:n,shouldCreateSpanForRequest:s,enableHTTPTimings:y,tracePropagationTargets:E}={traceFetch:S.traceFetch,traceXHR:S.traceXHR,...t},T="function"==typeof s?s:e=>!0,C=e=>(function(e,t){let r=_.jf.location&&_.jf.location.href;if(r){let n,s;try{n=new URL(e,r),s=new URL(r).origin}catch(e){return!1}let a=n.origin===s;return t?(0,g.Xr)(n.toString(),t)||a&&(0,g.Xr)(n.pathname,t):a}{let r=!!e.match(/^\/(?!\/)/);return t?(0,g.Xr)(e,t):r}})(e,E),I={};r&&(e.addEventProcessor(e=>("transaction"===e.type&&e.spans&&e.spans.forEach(e=>{if("http.client"===e.op){let t=x.get(e.span_id);t&&(e.timestamp=t/1e3,x.delete(e.span_id))}}),e)),(0,f.B$)(e=>{if(e.response){let t=w.get(e.response);t&&e.endTimestamp&&x.set(t,e.endTimestamp)}}),(0,f.ur)(e=>{let t=(0,h.v)(e,T,C,I);if(e.response&&e.fetchData.__span&&w.set(e.response,e.fetchData.__span),t){let r=A(e.fetchData.url),n=r?(0,v.Dl)(r).host:void 0;t.setAttributes({"http.url":r,"server.address":n})}y&&t&&j(t)})),n&&(0,a.Mn)(e=>{let t=function(e,t,r,n){let s=e.xhr,h=s&&s[a.Er];if(!s||s.__sentry_own_request__||!h)return;let f=(0,d.w)()&&t(h.url);if(e.endTimestamp&&f){let e=s.__sentry_xhr_span_id__;if(!e)return;let t=n[e];t&&void 0!==h.status_code&&((0,i.N8)(t,h.status_code),t.end(),delete n[e]);return}let g=A(h.url),y=g?(0,v.Dl)(g).host:void 0,_=!!(0,p.Bk)(),w=f&&_?(0,l.Uk)({name:`${h.method} ${h.url}`,attributes:{type:"xhr","http.method":h.method,"http.url":g,url:h.url,"server.address":y,[u.JD]:"auto.http.browser",[u.uT]:"http.client"}}):new o.w;s.__sentry_xhr_span_id__=w.spanContext().spanId,n[s.__sentry_xhr_span_id__]=w;let x=(0,m.KU)();return s.setRequestHeader&&r(h.url)&&x&&function(e,t,r){let n=(0,m.o5)(),{traceId:s,spanId:a,sampled:o,dsc:i}={...(0,m.rm)().getPropagationContext(),...n.getPropagationContext()},l=r&&(0,d.w)()?(0,p.Qh)(r):(0,b.TC)(s,a,o);var u=e,h=l,f=(0,k.De)(i||(r?(0,c.k1)(r):(0,c.lF)(s,t)));try{u.setRequestHeader("sentry-trace",h),f&&u.setRequestHeader(k.hF,f)}catch(e){}}(s,x,(0,d.w)()&&_?w:void 0),w}(e,T,C,I);y&&t&&j(t)})}function j(e){let{url:t}=(0,p.et)(e).data||{};if(!t||"string"!=typeof t)return;let r=(0,s.wv)("resource",({entries:s})=>{s.forEach(s=>{"resource"===s.entryType&&"initiatorType"in s&&"string"==typeof s.nextHopProtocol&&("fetch"===s.initiatorType||"xmlhttprequest"===s.initiatorType)&&s.name.endsWith(t)&&((function(e){let{name:t,version:r}=function(e){let t="unknown",r="unknown",n="";for(let s of e){if("/"===s){[t,r]=e.split("/");break}if(!isNaN(Number(s))){t="h"===n?"http":n,r=e.split(n)[1];break}n+=s}return n===e&&(t=n),{name:t,version:r}}(e.nextHopProtocol),n=[];return(n.push(["network.protocol.version",r],["network.protocol.name",t]),y.k3)?[...n,["http.request.redirect_start",T(e.redirectStart)],["http.request.fetch_start",T(e.fetchStart)],["http.request.domain_lookup_start",T(e.domainLookupStart)],["http.request.domain_lookup_end",T(e.domainLookupEnd)],["http.request.connect_start",T(e.connectStart)],["http.request.secure_connection_start",T(e.secureConnectionStart)],["http.request.connection_end",T(e.connectEnd)],["http.request.request_start",T(e.requestStart)],["http.request.response_start",T(e.responseStart)],["http.request.response_end",T(e.responseEnd)]]:n})(s).forEach(t=>e.setAttribute(...t)),n(r))})})}function T(e=0){return((y.k3||performance.timeOrigin)+e)/1e3}function A(e){try{return new URL(e,_.jf.location.origin).href}catch(e){return}}},666012(e,t,r){"use strict";r.d(t,{Sq:()=>I,U$:()=>e4,aD:()=>P,e4:()=>q,j0:()=>e2});var o=r(933190),i=r(532725),l=r(834028),c=r(230337),u=r(424264),m=r(107842);let d=c.O,p=d.document,h=d.navigator,f="Report a Bug",g="Cancel",y="Send Bug Report",b="Confirm",k="Report a Bug",v="your.email@example.org",_="Email",w="What's the bug? What did you expect?",x="Description",S="Your Name",E="Name",j="Thank you for your report!",T="(required)",A="Add a screenshot",C="Remove screenshot",I=(e,t={includeReplay:!0})=>{if(!e.message)throw Error("Unable to submit feedback with empty message");let r=(0,o.KU)();if(!r)throw Error("No client setup, cannot send feedback.");e.tags&&Object.keys(e.tags).length&&(0,o.o5)().setTags(e.tags);let a=(0,i.q)({source:"api",url:(0,l.$N)(),...e},t);return new Promise((e,t)=>{let o=n(()=>t("Unable to determine if Feedback was correctly sent."),5e3),i=r.on("afterSendEvent",(r,n)=>{if(r.event_id===a)return(s(o),i(),n&&"number"==typeof n.statusCode&&n.statusCode>=200&&n.statusCode<300&&e(a),n&&"number"==typeof n.statusCode&&0===n.statusCode)?t("Unable to send Feedback. This is because of network issues, or because you are using an ad-blocker."):n&&"number"==typeof n.statusCode&&403===n.statusCode?t("Unable to send Feedback. This could be because this domain is not in your list of allowed domains."):t("Unable to send Feedback. This could be because of network issues, or because you are using an ad-blocker")})})},O="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__;function M(e,t){return{...e,...t,tags:{...e.tags,...t.tags},onFormOpen:()=>{t.onFormOpen&&t.onFormOpen(),e.onFormOpen&&e.onFormOpen()},onFormClose:()=>{t.onFormClose&&t.onFormClose(),e.onFormClose&&e.onFormClose()},onSubmitSuccess:r=>{t.onSubmitSuccess&&t.onSubmitSuccess(r),e.onSubmitSuccess&&e.onSubmitSuccess(r)},onSubmitError:r=>{t.onSubmitError&&t.onSubmitError(r),e.onSubmitError&&e.onSubmitError(r)},onFormSubmitted:()=>{t.onFormSubmitted&&t.onFormSubmitted(),e.onFormSubmitted&&e.onFormSubmitted()},themeDark:{...e.themeDark,...t.themeDark},themeLight:{...e.themeLight,...t.themeLight}}}function N(e,t){return Object.entries(t).forEach(([t,r])=>{e.setAttributeNS(null,t,r)}),e}let D="rgba(88, 74, 192, 1)",R={foreground:"#2b2233",background:"#ffffff",accentForeground:"white",accentBackground:D,successColor:"#268d75",errorColor:"#df3338",border:"1.5px solid rgba(41, 35, 47, 0.13)",boxShadow:"0px 4px 24px 0px rgba(43, 34, 51, 0.12)",outline:"1px auto var(--accent-background)",interactiveFilter:"brightness(95%)"},L={foreground:"#ebe6ef",background:"#29232f",accentForeground:"white",accentBackground:D,successColor:"#2da98c",errorColor:"#f55459",border:"1.5px solid rgba(235, 230, 239, 0.15)",boxShadow:"0px 4px 24px 0px rgba(43, 34, 51, 0.12)",outline:"1px auto var(--accent-background)",interactiveFilter:"brightness(150%)"};function F(e){return`
  --foreground: ${e.foreground};
  --background: ${e.background};
  --accent-foreground: ${e.accentForeground};
  --accent-background: ${e.accentBackground};
  --success-color: ${e.successColor};
  --error-color: ${e.errorColor};
  --border: ${e.border};
  --box-shadow: ${e.boxShadow};
  --outline: ${e.outline};
  --interactive-filter: ${e.interactiveFilter};
  `}let P=({lazyLoadIntegration:e,getModalIntegration:t,getScreenshotIntegration:r})=>({id:n="sentry-feedback",autoInject:s=!0,showBranding:a=!0,isEmailRequired:i=!1,isNameRequired:l=!1,showEmail:c=!0,showName:D=!0,enableScreenshot:P=!0,useSentryUser:q={email:"email",name:"username"},tags:z,styleNonce:$,scriptNonce:U,colorScheme:B="system",themeLight:W={},themeDark:H={},addScreenshotButtonLabel:V=A,cancelButtonLabel:Y=g,confirmButtonLabel:G=b,emailLabel:J=_,emailPlaceholder:Z=v,formTitle:K=k,isRequiredLabel:X=T,messageLabel:Q=x,messagePlaceholder:ee=w,nameLabel:et=E,namePlaceholder:er=S,removeScreenshotButtonLabel:en=C,submitButtonLabel:es=y,successMessageText:ea=j,triggerLabel:eo=f,triggerAriaLabel:ei="",onFormOpen:el,onFormClose:ec,onSubmitSuccess:eu,onSubmitError:em,onFormSubmitted:ed}={})=>{let ep={id:n,autoInject:s,showBranding:a,isEmailRequired:i,isNameRequired:l,showEmail:c,showName:D,enableScreenshot:P,useSentryUser:q,tags:z,styleNonce:$,scriptNonce:U,colorScheme:B,themeDark:H,themeLight:W,triggerLabel:eo,triggerAriaLabel:ei,cancelButtonLabel:Y,submitButtonLabel:es,confirmButtonLabel:G,formTitle:K,emailLabel:J,emailPlaceholder:Z,messageLabel:Q,messagePlaceholder:ee,nameLabel:et,namePlaceholder:er,successMessageText:ea,isRequiredLabel:X,addScreenshotButtonLabel:V,removeScreenshotButtonLabel:en,onFormClose:ec,onFormOpen:el,onSubmitError:em,onSubmitSuccess:eu,onFormSubmitted:ed},eh=null,ef=[],eg=e=>{if(!eh){let t=p.createElement("div");t.id=String(e.id),p.body.appendChild(t),(eh=t.attachShadow({mode:"open"})).appendChild(function({colorScheme:e,themeDark:t,themeLight:r,styleNonce:n}){let s=p.createElement("style");return s.textContent=`
:host {
  --font-family: system-ui, 'Helvetica Neue', Arial, sans-serif;
  --font-size: 14px;
  --z-index: 100000;

  --page-margin: 16px;
  --inset: auto 0 0 auto;
  --actor-inset: var(--inset);

  font-family: var(--font-family);
  font-size: var(--font-size);

  ${"system"!==e?"color-scheme: only light;":""}

  ${F("dark"===e?{...L,...t}:{...R,...r})}
}

${"system"===e?`
@media (prefers-color-scheme: dark) {
  :host {
    ${F({...L,...t})}
  }
}`:""}
}
`,n&&s.setAttribute("nonce",n),s}(e))}return eh},ey=async(t,r,n)=>{let s=(0,o.KU)(),a=s&&s.getIntegrationByName(t);if(a)return a;let i=(r&&r()||await e(n,U))();return s&&s.addIntegration(i),i},eb=async e=>{let n=e.enableScreenshot&&!(/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(h.userAgent)||/Macintosh/i.test(h.userAgent)&&h.maxTouchPoints&&h.maxTouchPoints>1)&&!!isSecureContext,[s,a]=await Promise.all([ey("FeedbackModal",t,"feedbackModalIntegration"),n?ey("FeedbackScreenshot",r,"feedbackScreenshotIntegration"):void 0]);if(!s)throw O&&m.vF.error("[Feedback] Missing feedback modal integration. Try using `feedbackSyncIntegration` in your `Sentry.init`."),Error("[Feedback] Missing feedback modal integration!");n&&!a&&O&&m.vF.error("[Feedback] Missing feedback screenshot integration. Proceeding without screenshots.");let o=s.createDialog({options:{...e,onFormClose:()=>{o&&o.close(),e.onFormClose&&e.onFormClose()},onFormSubmitted:()=>{o&&o.close(),e.onFormSubmitted&&e.onFormSubmitted()}},screenshotIntegration:n?a:void 0,sendFeedback:I,shadow:eg(e)});return o},ek=(e,t={})=>{let r=M(ep,t),n="string"==typeof e?p.querySelector(e):"function"==typeof e.addEventListener?e:null;if(!n)throw O&&m.vF.error("[Feedback] Unable to attach to target element"),Error("Unable to attach to target element");let s=null,a=async()=>{s||(s=await eb({...r,onFormSubmitted:()=>{s&&s.removeFromDom(),r.onFormSubmitted&&r.onFormSubmitted()}})),s.appendToDom(),s.open()};n.addEventListener("click",a);let o=()=>{ef=ef.filter(e=>e!==o),s&&s.removeFromDom(),s=null,n.removeEventListener("click",a)};return ef.push(o),o},ev=(e={})=>{let t=M(ep,e),r=eg(t),n=function({triggerLabel:e,triggerAriaLabel:t,shadow:r,styleNonce:n}){let s=p.createElement("button");if(s.type="button",s.className="widget__actor",s.ariaHidden="false",s.ariaLabel=t||e||f,s.appendChild(function(){let e=e=>d.document.createElementNS("http://www.w3.org/2000/svg",e),t=N(e("svg"),{width:"20",height:"20",viewBox:"0 0 20 20",fill:"var(--actor-color, var(--foreground))"}),r=N(e("g"),{clipPath:"url(#clip0_57_80)"}),n=N(e("path"),{"fill-rule":"evenodd","clip-rule":"evenodd",d:"M15.6622 15H12.3997C12.2129 14.9959 12.031 14.9396 11.8747 14.8375L8.04965 12.2H7.49956V19.1C7.4875 19.3348 7.3888 19.5568 7.22256 19.723C7.05632 19.8892 6.83435 19.9879 6.59956 20H2.04956C1.80193 19.9968 1.56535 19.8969 1.39023 19.7218C1.21511 19.5467 1.1153 19.3101 1.11206 19.0625V12.2H0.949652C0.824431 12.2017 0.700142 12.1783 0.584123 12.1311C0.468104 12.084 0.362708 12.014 0.274155 11.9255C0.185602 11.8369 0.115689 11.7315 0.0685419 11.6155C0.0213952 11.4995 -0.00202913 11.3752 -0.00034808 11.25V3.75C-0.00900498 3.62067 0.0092504 3.49095 0.0532651 3.36904C0.0972798 3.24712 0.166097 3.13566 0.255372 3.04168C0.344646 2.94771 0.452437 2.87327 0.571937 2.82307C0.691437 2.77286 0.82005 2.74798 0.949652 2.75H8.04965L11.8747 0.1625C12.031 0.0603649 12.2129 0.00407221 12.3997 0H15.6622C15.9098 0.00323746 16.1464 0.103049 16.3215 0.278167C16.4966 0.453286 16.5964 0.689866 16.5997 0.9375V3.25269C17.3969 3.42959 18.1345 3.83026 18.7211 4.41679C19.5322 5.22788 19.9878 6.32796 19.9878 7.47502C19.9878 8.62209 19.5322 9.72217 18.7211 10.5333C18.1345 11.1198 17.3969 11.5205 16.5997 11.6974V14.0125C16.6047 14.1393 16.5842 14.2659 16.5395 14.3847C16.4948 14.5035 16.4268 14.6121 16.3394 14.7042C16.252 14.7962 16.147 14.8698 16.0307 14.9206C15.9144 14.9714 15.7891 14.9984 15.6622 15ZM1.89695 10.325H1.88715V4.625H8.33715C8.52423 4.62301 8.70666 4.56654 8.86215 4.4625L12.6872 1.875H14.7247V13.125H12.6872L8.86215 10.4875C8.70666 10.3835 8.52423 10.327 8.33715 10.325H2.20217C2.15205 10.3167 2.10102 10.3125 2.04956 10.3125C1.9981 10.3125 1.94708 10.3167 1.89695 10.325ZM2.98706 12.2V18.1625H5.66206V12.2H2.98706ZM16.5997 9.93612V5.01393C16.6536 5.02355 16.7072 5.03495 16.7605 5.04814C17.1202 5.13709 17.4556 5.30487 17.7425 5.53934C18.0293 5.77381 18.2605 6.06912 18.4192 6.40389C18.578 6.73866 18.6603 7.10452 18.6603 7.47502C18.6603 7.84552 18.578 8.21139 18.4192 8.54616C18.2605 8.88093 18.0293 9.17624 17.7425 9.41071C17.4556 9.64518 17.1202 9.81296 16.7605 9.90191C16.7072 9.91509 16.6536 9.9265 16.5997 9.93612Z"});t.appendChild(r).appendChild(n);let s=e("defs"),a=N(e("clipPath"),{id:"clip0_57_80"}),o=N(e("rect"),{width:"20",height:"20",fill:"white"});return a.appendChild(o),s.appendChild(a),t.appendChild(s).appendChild(a).appendChild(o),t}()),e){let t=p.createElement("span");t.appendChild(p.createTextNode(e)),s.appendChild(t)}let a=function(e){let t=p.createElement("style");return t.textContent=`
.widget__actor {
  position: fixed;
  z-index: var(--z-index);
  margin: var(--page-margin);
  inset: var(--actor-inset);

  display: flex;
  align-items: center;
  gap: 8px;
  padding: 16px;

  font-family: inherit;
  font-size: var(--font-size);
  font-weight: 600;
  line-height: 1.14em;
  text-decoration: none;

  background: var(--actor-background, var(--background));
  border-radius: var(--actor-border-radius, 1.7em/50%);
  border: var(--actor-border, var(--border));
  box-shadow: var(--actor-box-shadow, var(--box-shadow));
  color: var(--actor-color, var(--foreground));
  fill: var(--actor-color, var(--foreground));
  cursor: pointer;
  opacity: 1;
  transition: transform 0.2s ease-in-out;
  transform: translate(0, 0) scale(1);
}
.widget__actor[aria-hidden="true"] {
  opacity: 0;
  pointer-events: none;
  visibility: hidden;
  transform: translate(0, 16px) scale(0.98);
}

.widget__actor:hover {
  background: var(--actor-hover-background, var(--background));
  filter: var(--interactive-filter);
}

.widget__actor svg {
  width: 1.14em;
  height: 1.14em;
}

@media (max-width: 600px) {
  .widget__actor span {
    display: none;
  }
}
`,e&&t.setAttribute("nonce",e),t}(n);return{el:s,appendToDom(){r.appendChild(a),r.appendChild(s)},removeFromDom(){r.removeChild(s),r.removeChild(a)},show(){s.ariaHidden="false"},hide(){s.ariaHidden="true"}}}({triggerLabel:t.triggerLabel,triggerAriaLabel:t.triggerAriaLabel,shadow:r,styleNonce:$});return ek(n.el,{...t,onFormOpen(){n.hide()},onFormClose(){n.show()},onFormSubmitted(){n.show()}}),n};return{name:"Feedback",setupOnce(){(0,u.B)()&&ep.autoInject&&("loading"===p.readyState?p.addEventListener("DOMContentLoaded",()=>ev().appendToDom()):ev().appendToDom())},attachTo:ek,createWidget(e={}){let t=ev(M(ep,e));return t.appendToDom(),t},createForm:async(e={})=>eb(M(ep,e)),remove(){eh&&(eh.parentElement&&eh.parentElement.remove(),eh=null),ef.forEach(e=>e()),ef=[]}}};function q(){let e=(0,o.KU)();return e&&e.getIntegrationByName("Feedback")}var z,$,U,B,W,H,V,Y={},G=[],J=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i,Z=Array.isArray;function K(e,t){for(var r in t)e[r]=t[r];return e}function X(e){var t=e.parentNode;t&&t.removeChild(e)}function Q(e,t,r){var n,s,a,o={};for(a in t)"key"==a?n=t[a]:"ref"==a?s=t[a]:o[a]=t[a];if(arguments.length>2&&(o.children=arguments.length>3?z.call(arguments,2):r),"function"==typeof e&&null!=e.defaultProps)for(a in e.defaultProps)void 0===o[a]&&(o[a]=e.defaultProps[a]);return ee(e,o,n,s,null)}function ee(e,t,r,n,s){var a={type:e,props:t,key:r,ref:n,__k:null,__:null,__b:0,__e:null,__d:void 0,__c:null,constructor:void 0,__v:null==s?++U:s,__i:-1,__u:0};return null==s&&null!=$.vnode&&$.vnode(a),a}function et(e){return e.children}function er(e,t){this.props=e,this.context=t}function en(e,t){if(null==t)return e.__?en(e.__,e.__i+1):null;for(var r;t<e.__k.length;t++)if(null!=(r=e.__k[t])&&null!=r.__e)return r.__e;return"function"==typeof e.type?en(e):null}function es(e){(!e.__d&&(e.__d=!0)&&B.push(e)&&!ea.__r++||W!==$.debounceRendering)&&((W=$.debounceRendering)||H)(ea)}function ea(){var e,t,r,n=[],s=[];for(B.sort(V);e=B.shift();)e.__d&&(r=B.length,t=function(e,t,r){var n,s=e.__v,a=s.__e,o=e.__P;if(o)return(n=K({},s)).__v=s.__v+1,$.vnode&&$.vnode(n),em(o,n,s,e.__n,void 0!==o.ownerSVGElement,32&s.__u?[a]:null,t,null==a?en(s):a,!!(32&s.__u),r),n.__.__k[n.__i]=n,n.__d=void 0,n.__e!=a&&function e(t){var r,n;if(null!=(t=t.__)&&null!=t.__c){for(t.__e=t.__c.base=null,r=0;r<t.__k.length;r++)if(null!=(n=t.__k[r])&&null!=n.__e){t.__e=t.__c.base=n.__e;break}return e(t)}}(n),n}(e,n,s)||t,0===r||B.length>r?(ed(n,t,s),s.length=n.length=0,t=void 0,B.sort(V)):t&&$.__c&&$.__c(t,G));t&&ed(n,t,s),ea.__r=0}function eo(e,t,r,n,s,a,o,i,l,c,u){var m,d,p,h,f,g=n&&n.__k||G,y=t.length;for(r.__d=l,function(e,t,r){var n,s,a,o,i,l=t.length,c=r.length,u=c,m=0;for(e.__k=[],n=0;n<l;n++)null!=(s=e.__k[n]=null==(s=t[n])||"boolean"==typeof s||"function"==typeof s?null:"string"==typeof s||"number"==typeof s||"bigint"==typeof s||s.constructor==String?ee(null,s,null,null,s):Z(s)?ee(et,{children:s},null,null,null):void 0===s.constructor&&s.__b>0?ee(s.type,s.props,s.key,s.ref?s.ref:null,s.__v):s)?(s.__=e,s.__b=e.__b+1,i=function(e,t,r,n){var s=e.key,a=e.type,o=r-1,i=r+1,l=t[r];if(null===l||l&&s==l.key&&a===l.type)return r;if(n>+(null!=l&&0==(131072&l.__u)))for(;o>=0||i<t.length;){if(o>=0){if((l=t[o])&&0==(131072&l.__u)&&s==l.key&&a===l.type)return o;o--}if(i<t.length){if((l=t[i])&&0==(131072&l.__u)&&s==l.key&&a===l.type)return i;i++}}return -1}(s,r,o=n+m,u),s.__i=i,a=null,-1!==i&&(u--,(a=r[i])&&(a.__u|=131072)),null==a||null===a.__v?(-1==i&&m--,"function"!=typeof s.type&&(s.__u|=65536)):i!==o&&(i===o+1?m++:i>o?u>l-o?m+=i-o:m--:m=i<o&&i==o-1?i-o:0,i!==n+m&&(s.__u|=65536))):(a=r[n])&&null==a.key&&a.__e&&(a.__e==e.__d&&(e.__d=en(a)),eh(a,a,!1),r[n]=null,u--);if(u)for(n=0;n<c;n++)null!=(a=r[n])&&0==(131072&a.__u)&&(a.__e==e.__d&&(e.__d=en(a)),eh(a,a))}(r,t,g),l=r.__d,m=0;m<y;m++)null!=(p=r.__k[m])&&"boolean"!=typeof p&&"function"!=typeof p&&(d=-1===p.__i?Y:g[p.__i]||Y,p.__i=m,em(e,p,d,s,a,o,i,l,c,u),h=p.__e,p.ref&&d.ref!=p.ref&&(d.ref&&ep(d.ref,null,p),u.push(p.ref,p.__c||h,p)),null==f&&null!=h&&(f=h),65536&p.__u||d.__k===p.__k?l=function e(t,r,n){var s,a;if("function"==typeof t.type){for(s=t.__k,a=0;s&&a<s.length;a++)s[a]&&(s[a].__=t,r=e(s[a],r,n));return r}t.__e!=r&&(n.insertBefore(t.__e,r||null),r=t.__e);do r=r&&r.nextSibling;while(null!=r&&8===r.nodeType)return r}(p,l,e):"function"==typeof p.type&&void 0!==p.__d?l=p.__d:h&&(l=h.nextSibling),p.__d=void 0,p.__u&=-196609);r.__d=l,r.__e=f}function ei(e,t,r){"-"===t[0]?e.setProperty(t,null==r?"":r):e[t]=null==r?"":"number"!=typeof r||J.test(t)?r:r+"px"}function el(e,t,r,n,s){var a;e:if("style"===t)if("string"==typeof r)e.style.cssText=r;else{if("string"==typeof n&&(e.style.cssText=n=""),n)for(t in n)r&&t in r||ei(e.style,t,"");if(r)for(t in r)n&&r[t]===n[t]||ei(e.style,t,r[t])}else if("o"===t[0]&&"n"===t[1])a=t!==(t=t.replace(/(PointerCapture)$|Capture$/i,"$1")),t=t.toLowerCase()in e?t.toLowerCase().slice(2):t.slice(2),e.l||(e.l={}),e.l[t+a]=r,r?n?r.u=n.u:(r.u=Date.now(),e.addEventListener(t,a?eu:ec,a)):e.removeEventListener(t,a?eu:ec,a);else{if(s)t=t.replace(/xlink(H|:h)/,"h").replace(/sName$/,"s");else if("width"!==t&&"height"!==t&&"href"!==t&&"list"!==t&&"form"!==t&&"tabIndex"!==t&&"download"!==t&&"rowSpan"!==t&&"colSpan"!==t&&"role"!==t&&t in e)try{e[t]=null==r?"":r;break e}catch(e){}"function"==typeof r||(null==r||!1===r&&"-"!==t[4]?e.removeAttribute(t):e.setAttribute(t,r))}}function ec(e){if(this.l){var t=this.l[e.type+!1];if(e.t){if(e.t<=t.u)return}else e.t=Date.now();return t($.event?$.event(e):e)}}function eu(e){if(this.l)return this.l[e.type+!0]($.event?$.event(e):e)}function em(e,t,r,n,s,o,i,l,c,u){var m,d,p,h,f,g,y,b,k,v,_,w,x,S,E,j=t.type;if(void 0!==t.constructor)return null;128&r.__u&&(c=!!(32&r.__u),o=[l=t.__e=r.__e]),(m=$.__b)&&m(t);e:if("function"==typeof j)try{if(b=t.props,k=(m=j.contextType)&&n[m.__c],v=m?k?k.props.value:m.__:n,r.__c?y=(d=t.__c=r.__c).__=d.__E:("prototype"in j&&j.prototype.render?t.__c=d=new j(b,v):(t.__c=d=new er(b,v),d.constructor=j,d.render=ef),k&&k.sub(d),d.props=b,d.state||(d.state={}),d.context=v,d.__n=n,p=d.__d=!0,d.__h=[],d._sb=[]),null==d.__s&&(d.__s=d.state),null!=j.getDerivedStateFromProps&&(d.__s==d.state&&(d.__s=K({},d.__s)),K(d.__s,j.getDerivedStateFromProps(b,d.__s))),h=d.props,f=d.state,d.__v=t,p)null==j.getDerivedStateFromProps&&null!=d.componentWillMount&&d.componentWillMount(),null!=d.componentDidMount&&d.__h.push(d.componentDidMount);else{if(null==j.getDerivedStateFromProps&&b!==h&&null!=d.componentWillReceiveProps&&d.componentWillReceiveProps(b,v),!d.__e&&(null!=d.shouldComponentUpdate&&!1===d.shouldComponentUpdate(b,d.__s,v)||t.__v===r.__v)){for(t.__v!==r.__v&&(d.props=b,d.state=d.__s,d.__d=!1),t.__e=r.__e,t.__k=r.__k,t.__k.forEach(function(e){e&&(e.__=t)}),_=0;_<d._sb.length;_++)d.__h.push(d._sb[_]);d._sb=[],d.__h.length&&i.push(d);break e}null!=d.componentWillUpdate&&d.componentWillUpdate(b,d.__s,v),null!=d.componentDidUpdate&&d.__h.push(function(){d.componentDidUpdate(h,f,g)})}if(d.context=v,d.props=b,d.__P=e,d.__e=!1,w=$.__r,x=0,"prototype"in j&&j.prototype.render){for(d.state=d.__s,d.__d=!1,w&&w(t),m=d.render(d.props,d.state,d.context),S=0;S<d._sb.length;S++)d.__h.push(d._sb[S]);d._sb=[]}else do d.__d=!1,w&&w(t),m=d.render(d.props,d.state,d.context),d.state=d.__s;while(d.__d&&++x<25)d.state=d.__s,null!=d.getChildContext&&(n=K(K({},n),d.getChildContext())),p||null==d.getSnapshotBeforeUpdate||(g=d.getSnapshotBeforeUpdate(h,f)),eo(e,Z(E=null!=m&&m.type===et&&null==m.key?m.props.children:m)?E:[E],t,r,n,s,o,i,l,c,u),d.base=t.__e,t.__u&=-161,d.__h.length&&i.push(d),y&&(d.__E=d.__=null)}catch(e){t.__v=null,c||null!=o?(t.__e=l,t.__u|=c?160:32,o[o.indexOf(l)]=null):(t.__e=r.__e,t.__k=r.__k),$.__e(e,t,r)}else null==o&&t.__v===r.__v?(t.__k=r.__k,t.__e=r.__e):t.__e=function(e,t,r,n,s,o,i,l,c){var u,m,d,p,h,f,g,y=r.props,b=t.props,k=t.type;if("svg"===k&&(s=!0),null!=o){for(u=0;u<o.length;u++)if((h=o[u])&&"setAttribute"in h==!!k&&(k?h.localName===k:3===h.nodeType)){e=h,o[u]=null;break}}if(null==e){if(null===k)return a.createTextNode(b);e=s?a.createElementNS("http://www.w3.org/2000/svg",k):a.createElement(k,b.is&&b),o=null,l=!1}if(null===k)y===b||l&&e.data===b||(e.data=b);else{if(o=o&&z.call(e.childNodes),y=r.props||Y,!l&&null!=o)for(y={},u=0;u<e.attributes.length;u++)y[(h=e.attributes[u]).name]=h.value;for(u in y)h=y[u],"children"==u||("dangerouslySetInnerHTML"==u?d=h:"key"===u||u in b||el(e,u,null,h,s));for(u in b)h=b[u],"children"==u?p=h:"dangerouslySetInnerHTML"==u?m=h:"value"==u?f=h:"checked"==u?g=h:"key"===u||l&&"function"!=typeof h||y[u]===h||el(e,u,h,y[u],s);if(m)l||d&&(m.__html===d.__html||m.__html===e.innerHTML)||(e.innerHTML=m.__html),t.__k=[];else if(d&&(e.innerHTML=""),eo(e,Z(p)?p:[p],t,r,n,s&&"foreignObject"!==k,o,i,o?o[0]:r.__k&&en(r,0),l,c),null!=o)for(u=o.length;u--;)null!=o[u]&&X(o[u]);l||(u="value",void 0===f||f===e[u]&&("progress"!==k||f)&&("option"!==k||f===y[u])||el(e,u,f,y[u],!1),u="checked",void 0!==g&&g!==e[u]&&el(e,u,g,y[u],!1))}return e}(r.__e,t,r,n,s,o,i,c,u);(m=$.diffed)&&m(t)}function ed(e,t,r){for(var n=0;n<r.length;n++)ep(r[n],r[++n],r[++n]);$.__c&&$.__c(t,e),e.some(function(t){try{e=t.__h,t.__h=[],e.some(function(e){e.call(t)})}catch(e){$.__e(e,t.__v)}})}function ep(e,t,r){try{"function"==typeof e?e(t):e.current=t}catch(e){$.__e(e,r)}}function eh(e,t,r){var n,s;if($.unmount&&$.unmount(e),(n=e.ref)&&(n.current&&n.current!==e.__e||ep(n,null,t)),null!=(n=e.__c)){if(n.componentWillUnmount)try{n.componentWillUnmount()}catch(e){$.__e(e,t)}n.base=n.__P=null,e.__c=void 0}if(n=e.__k)for(s=0;s<n.length;s++)n[s]&&eh(n[s],t,r||"function"!=typeof e.type);r||null==e.__e||X(e.__e),e.__=e.__e=e.__d=void 0}function ef(e,t,r){return this.constructor(e,r)}z=G.slice,$={__e:function(e,t,r,n){for(var s,a,o;t=t.__;)if((s=t.__c)&&!s.__)try{if((a=s.constructor)&&null!=a.getDerivedStateFromError&&(s.setState(a.getDerivedStateFromError(e)),o=s.__d),null!=s.componentDidCatch&&(s.componentDidCatch(e,n||{}),o=s.__d),o)return s.__E=s}catch(t){e=t}throw e}},U=0,er.prototype.setState=function(e,t){var r;r=null!=this.__s&&this.__s!==this.state?this.__s:this.__s=K({},this.state),"function"==typeof e&&(e=e(K({},r),this.props)),e&&K(r,e),null!=e&&this.__v&&(t&&this._sb.push(t),es(this))},er.prototype.forceUpdate=function(e){this.__v&&(this.__e=!0,e&&this.__h.push(e),es(this))},er.prototype.render=et,B=[],H="function"==typeof Promise?Promise.prototype.then.bind(Promise.resolve()):n,V=function(e,t){return e.__v.__b-t.__v.__b},ea.__r=0;var eg,ey,eb,ek,ev=0,e_=[],ew=[],ex=$,eS=ex.__b,eE=ex.__r,ej=ex.diffed,eT=ex.__c,eA=ex.unmount,eC=ex.__;function eI(e,t){ex.__h&&ex.__h(ey,e,ev||t),ev=0;var r=ey.__H||(ey.__H={__:[],__h:[]});return e>=r.__.length&&r.__.push({__V:ew}),r.__[e]}function eO(e){return ev=1,eM(e$,e)}function eM(e,t,r){var n=eI(eg++,2);if(n.t=e,!n.__c&&(n.__=[r?r(t):e$(void 0,t),function(e){var t=n.__N?n.__N[0]:n.__[0],r=n.t(t,e);t!==r&&(n.__N=[r,n.__[1]],n.__c.setState({}))}],n.__c=ey,!ey.u)){var s=function(e,t,r){if(!n.__c.__H)return!0;var s=n.__c.__H.__.filter(function(e){return!!e.__c});if(s.every(function(e){return!e.__N}))return!a||a.call(this,e,t,r);var o=!1;return s.forEach(function(e){if(e.__N){var t=e.__[0];e.__=e.__N,e.__N=void 0,t!==e.__[0]&&(o=!0)}}),!(!o&&n.__c.props===e)&&(!a||a.call(this,e,t,r))};ey.u=!0;var a=ey.shouldComponentUpdate,o=ey.componentWillUpdate;ey.componentWillUpdate=function(e,t,r){if(this.__e){var n=a;a=void 0,s(e,t,r),a=n}o&&o.call(this,e,t,r)},ey.shouldComponentUpdate=s}return n.__N||n.__}function eN(e,t){var r=eI(eg++,4);!ex.__s&&ez(r.__H,t)&&(r.__=e,r.i=t,ey.__h.push(r))}function eD(e,t){var r=eI(eg++,7);return ez(r.__H,t)?(r.__V=e(),r.i=t,r.__h=e,r.__V):r.__}function eR(e,t){return ev=8,eD(function(){return e},t)}function eL(){for(var e;e=e_.shift();)if(e.__P&&e.__H)try{e.__H.__h.forEach(eP),e.__H.__h.forEach(eq),e.__H.__h=[]}catch(t){e.__H.__h=[],ex.__e(t,e.__v)}}ex.__b=function(e){ey=null,eS&&eS(e)},ex.__=function(e,t){t.__k&&t.__k.__m&&(e.__m=t.__k.__m),eC&&eC(e,t)},ex.__r=function(e){eE&&eE(e),eg=0;var t=(ey=e.__c).__H;t&&(eb===ey?(t.__h=[],ey.__h=[],t.__.forEach(function(e){e.__N&&(e.__=e.__N),e.__V=ew,e.__N=e.i=void 0})):(t.__h.forEach(eP),t.__h.forEach(eq),t.__h=[],eg=0)),eb=ey},ex.diffed=function(e){ej&&ej(e);var t=e.__c;t&&t.__H&&(t.__H.__h.length&&(1!==e_.push(t)&&ek===ex.requestAnimationFrame||((ek=ex.requestAnimationFrame)||function(e){var t,r=function(){s(a),eF&&cancelAnimationFrame(t),n(e)},a=n(r,100);eF&&(t=requestAnimationFrame(r))})(eL)),t.__H.__.forEach(function(e){e.i&&(e.__H=e.i),e.__V!==ew&&(e.__=e.__V),e.i=void 0,e.__V=ew})),eb=ey=null},ex.__c=function(e,t){t.some(function(e){try{e.__h.forEach(eP),e.__h=e.__h.filter(function(e){return!e.__||eq(e)})}catch(r){t.some(function(e){e.__h&&(e.__h=[])}),t=[],ex.__e(r,e.__v)}}),eT&&eT(e,t)},ex.unmount=function(e){eA&&eA(e);var t,r=e.__c;r&&r.__H&&(r.__H.__.forEach(function(e){try{eP(e)}catch(e){t=e}}),r.__H=void 0,t&&ex.__e(t,r.__v))};var eF="function"==typeof requestAnimationFrame;function eP(e){var t=ey,r=e.__c;"function"==typeof r&&(e.__c=void 0,r()),ey=t}function eq(e){var t=ey;e.__c=e.__(),ey=t}function ez(e,t){return!e||e.length!==t.length||t.some(function(t,r){return t!==e[r]})}function e$(e,t){return"function"==typeof t?t(e):t}let eU={__proto__:null,useCallback:eR,useContext:function(e){var t=ey.context[e.__c],r=eI(eg++,9);return r.c=e,t?(null==r.__&&(r.__=!0,t.sub(ey)),t.props.value):e.__},useDebugValue:function(e,t){ex.useDebugValue&&ex.useDebugValue(t?t(e):e)},useEffect:function(e,t){var r=eI(eg++,3);!ex.__s&&ez(r.__H,t)&&(r.__=e,r.i=t,ey.__H.__h.push(r))},useErrorBoundary:function(e){var t=eI(eg++,10),r=eO();return t.__=e,ey.componentDidCatch||(ey.componentDidCatch=function(e,n){t.__&&t.__(e,n),r[1](e)}),[r[0],function(){r[1](void 0)}]},useId:function(){var e=eI(eg++,11);if(!e.__){for(var t=ey.__v;null!==t&&!t.__m&&null!==t.__;)t=t.__;var r=t.__m||(t.__m=[0,0]);e.__="P"+r[0]+"-"+r[1]++}return e.__},useImperativeHandle:function(e,t,r){ev=6,eN(function(){return"function"==typeof e?(e(t()),function(){return e(null)}):e?(e.current=t(),function(){return e.current=null}):void 0},null==r?r:r.concat(e))},useLayoutEffect:eN,useMemo:eD,useReducer:eM,useRef:function(e){return ev=5,eD(function(){return{current:e}},[])},useState:eO},eB="/home/runner/work/sentry-javascript/sentry-javascript/packages/feedback/src/modal/components/DialogHeader.tsx";function eW({options:e}){let t=eD(()=>({__html:function(){let e=e=>p.createElementNS("http://www.w3.org/2000/svg",e),t=N(e("svg"),{width:"32",height:"30",viewBox:"0 0 72 66",fill:"inherit"}),r=N(e("path"),{transform:"translate(11, 11)",d:"M29,2.26a4.67,4.67,0,0,0-8,0L14.42,13.53A32.21,32.21,0,0,1,32.17,40.19H27.55A27.68,27.68,0,0,0,12.09,17.47L6,28a15.92,15.92,0,0,1,9.23,12.17H4.62A.76.76,0,0,1,4,39.06l2.94-5a10.74,10.74,0,0,0-3.36-1.9l-2.91,5a4.54,4.54,0,0,0,1.69,6.24A4.66,4.66,0,0,0,4.62,44H19.15a19.4,19.4,0,0,0-8-17.31l2.31-4A23.87,23.87,0,0,1,23.76,44H36.07a35.88,35.88,0,0,0-16.41-31.8l4.67-8a.77.77,0,0,1,1.05-.27c.53.29,20.29,34.77,20.66,35.17a.76.76,0,0,1-.68,1.13H40.6q.09,1.91,0,3.81h4.78A4.59,4.59,0,0,0,50,39.43a4.49,4.49,0,0,0-.62-2.28Z"});return t.appendChild(r),t}().outerHTML}),[]);return Q("h2",{class:"dialog__header",__self:this,__source:{fileName:eB,lineNumber:16}},e.formTitle,e.showBranding?Q("a",{class:"brand-link",target:"_blank",href:"https://sentry.io/welcome/",title:"Powered by Sentry",rel:"noopener noreferrer",dangerouslySetInnerHTML:t,__self:this,__source:{fileName:eB,lineNumber:19}}):null)}let eH="/home/runner/work/sentry-javascript/sentry-javascript/packages/feedback/src/modal/components/Form.tsx";function eV(e,t){let r=e.get(t);return"string"==typeof r?r.trim():""}function eY({options:e,defaultEmail:t,defaultName:r,onFormClose:n,onSubmit:s,onSubmitSuccess:a,onSubmitError:o,showEmail:i,showName:l,screenshotInput:c}){let{tags:u,addScreenshotButtonLabel:d,removeScreenshotButtonLabel:p,cancelButtonLabel:h,emailLabel:f,emailPlaceholder:g,isEmailRequired:y,isNameRequired:b,messageLabel:k,messagePlaceholder:v,nameLabel:_,namePlaceholder:w,submitButtonLabel:x,isRequiredLabel:S}=e,[E,j]=eO(null),[T,A]=eO(!1),C=c&&c.input,[I,M]=eO(null),N=eR(e=>{M(e),A(!1)},[]),D=eR(e=>{let t=function(e,t){let r=[];return t.isNameRequired&&!e.name&&r.push(t.nameLabel),t.isEmailRequired&&!e.email&&r.push(t.emailLabel),e.message||r.push(t.messageLabel),r}(e,{emailLabel:f,isEmailRequired:y,isNameRequired:b,messageLabel:k,nameLabel:_});return t.length>0?j(`Please enter in the following required fields: ${t.join(", ")}`):j(null),0===t.length},[f,y,b,k,_]);return Q("form",{class:"form",onSubmit:eR(async e=>{try{if(e.preventDefault(),!(e.target instanceof HTMLFormElement))return;let t=new FormData(e.target),r=await (c&&T?c.value():void 0),n={name:eV(t,"name"),email:eV(t,"email"),message:eV(t,"message"),attachments:r?[r]:void 0};if(!D(n))return;try{await s({name:n.name,email:n.email,message:n.message,source:"widget",tags:u},{attachments:n.attachments}),a(n)}catch(e){O&&m.vF.error(e),j(e),o(e)}}catch(e){}},[c&&T,a,o]),__self:this,__source:{fileName:eH,lineNumber:144}},C&&T?Q(C,{onError:N,__self:this,__source:{fileName:eH,lineNumber:146}}):null,Q("div",{class:"form__right","data-sentry-feedback":!0,__self:this,__source:{fileName:eH,lineNumber:149}},Q("div",{class:"form__top",__self:this,__source:{fileName:eH,lineNumber:150}},E?Q("div",{class:"form__error-container",__self:this,__source:{fileName:eH,lineNumber:151}},E):null,l?Q("label",{for:"name",class:"form__label",__self:this,__source:{fileName:eH,lineNumber:154}},Q(eG,{label:_,isRequiredLabel:S,isRequired:b,__self:this,__source:{fileName:eH,lineNumber:155}}),Q("input",{class:"form__input",defaultValue:r,id:"name",name:"name",placeholder:w,required:b,type:"text",__self:this,__source:{fileName:eH,lineNumber:156}})):Q("input",{"aria-hidden":!0,value:r,name:"name",type:"hidden",__self:this,__source:{fileName:eH,lineNumber:167}}),i?Q("label",{for:"email",class:"form__label",__self:this,__source:{fileName:eH,lineNumber:171}},Q(eG,{label:f,isRequiredLabel:S,isRequired:y,__self:this,__source:{fileName:eH,lineNumber:172}}),Q("input",{class:"form__input",defaultValue:t,id:"email",name:"email",placeholder:g,required:y,type:"email",__self:this,__source:{fileName:eH,lineNumber:173}})):Q("input",{"aria-hidden":!0,value:t,name:"email",type:"hidden",__self:this,__source:{fileName:eH,lineNumber:184}}),Q("label",{for:"message",class:"form__label",__self:this,__source:{fileName:eH,lineNumber:187}},Q(eG,{label:k,isRequiredLabel:S,isRequired:!0,__self:this,__source:{fileName:eH,lineNumber:188}}),Q("textarea",{autoFocus:!0,class:"form__input form__input--textarea",id:"message",name:"message",placeholder:v,required:!0,rows:5,__self:this,__source:{fileName:eH,lineNumber:189}})),C?Q("label",{for:"screenshot",class:"form__label",__self:this,__source:{fileName:eH,lineNumber:201}},Q("button",{class:"btn btn--default",type:"button",onClick:()=>{M(null),A(e=>!e)},__self:this,__source:{fileName:eH,lineNumber:202}},T?p:d),I?Q("div",{class:"form__error-container",__self:this,__source:{fileName:eH,lineNumber:212}},I.message):null):null),Q("div",{class:"btn-group",__self:this,__source:{fileName:eH,lineNumber:216}},Q("button",{class:"btn btn--primary",type:"submit",__self:this,__source:{fileName:eH,lineNumber:217}},x),Q("button",{class:"btn btn--default",type:"button",onClick:n,__self:this,__source:{fileName:eH,lineNumber:220}},h))))}function eG({label:e,isRequired:t,isRequiredLabel:r}){return Q("span",{class:"form__label__text",__self:this,__source:{fileName:eH,lineNumber:239}},e,t&&Q("span",{class:"form__label__text--required",__self:this,__source:{fileName:eH,lineNumber:241}},r))}let eJ="/home/runner/work/sentry-javascript/sentry-javascript/packages/feedback/src/modal/components/Dialog.tsx";function eZ({open:e,onFormSubmitted:t,...r}){let a=r.options,o=eD(()=>({__html:function(){let e=e=>d.document.createElementNS("http://www.w3.org/2000/svg",e),t=N(e("svg"),{width:"16",height:"17",viewBox:"0 0 16 17",fill:"inherit"}),r=N(e("g"),{clipPath:"url(#clip0_57_156)"}),n=N(e("path"),{"fill-rule":"evenodd","clip-rule":"evenodd",d:"M3.55544 15.1518C4.87103 16.0308 6.41775 16.5 8 16.5C10.1217 16.5 12.1566 15.6571 13.6569 14.1569C15.1571 12.6566 16 10.6217 16 8.5C16 6.91775 15.5308 5.37103 14.6518 4.05544C13.7727 2.73985 12.5233 1.71447 11.0615 1.10897C9.59966 0.503466 7.99113 0.34504 6.43928 0.653721C4.88743 0.962403 3.46197 1.72433 2.34315 2.84315C1.22433 3.96197 0.462403 5.38743 0.153721 6.93928C-0.15496 8.49113 0.00346625 10.0997 0.608967 11.5615C1.21447 13.0233 2.23985 14.2727 3.55544 15.1518ZM4.40546 3.1204C5.46945 2.40946 6.72036 2.03 8 2.03C9.71595 2.03 11.3616 2.71166 12.575 3.92502C13.7883 5.13838 14.47 6.78405 14.47 8.5C14.47 9.77965 14.0905 11.0306 13.3796 12.0945C12.6687 13.1585 11.6582 13.9878 10.476 14.4775C9.29373 14.9672 7.99283 15.0953 6.73777 14.8457C5.48271 14.596 4.32987 13.9798 3.42502 13.075C2.52018 12.1701 1.90397 11.0173 1.65432 9.76224C1.40468 8.50718 1.5328 7.20628 2.0225 6.02404C2.5122 4.8418 3.34148 3.83133 4.40546 3.1204Z"}),s=N(e("path"),{d:"M6.68775 12.4297C6.78586 12.4745 6.89218 12.4984 7 12.5C7.11275 12.4955 7.22315 12.4664 7.32337 12.4145C7.4236 12.3627 7.51121 12.2894 7.58 12.2L12 5.63999C12.0848 5.47724 12.1071 5.28902 12.0625 5.11098C12.0178 4.93294 11.9095 4.77744 11.7579 4.67392C11.6064 4.57041 11.4221 4.52608 11.24 4.54931C11.0579 4.57254 10.8907 4.66173 10.77 4.79999L6.88 10.57L5.13 8.56999C5.06508 8.49566 4.98613 8.43488 4.89768 8.39111C4.80922 8.34735 4.713 8.32148 4.61453 8.31498C4.51605 8.30847 4.41727 8.32147 4.32382 8.35322C4.23038 8.38497 4.14413 8.43484 4.07 8.49999C3.92511 8.63217 3.83692 8.81523 3.82387 9.01092C3.81083 9.2066 3.87393 9.39976 4 9.54999L6.43 12.24C6.50187 12.3204 6.58964 12.385 6.68775 12.4297Z"});t.appendChild(r).append(s,n);let a=e("defs"),o=N(e("clipPath"),{id:"clip0_57_156"}),i=N(e("rect"),{width:"16",height:"16",fill:"white",transform:"translate(0 0.5)"});return o.appendChild(i),a.appendChild(o),t.appendChild(a).appendChild(o).appendChild(i),t}().outerHTML}),[]),[i,l]=eO(null),c=eR(()=>{i&&(s(i),l(null)),t()},[i]),u=eR(e=>{r.onSubmitSuccess(e),l(n(()=>{t(),l(null)},5e3))},[t]);return Q(et,{__self:this,__source:{fileName:eJ,lineNumber:48}},i?Q("div",{class:"success__position",onClick:c,__self:this,__source:{fileName:eJ,lineNumber:50}},Q("div",{class:"success__content",__self:this,__source:{fileName:eJ,lineNumber:51}},a.successMessageText,Q("span",{class:"success__icon",dangerouslySetInnerHTML:o,__self:this,__source:{fileName:eJ,lineNumber:53}}))):Q("dialog",{class:"dialog",onClick:a.onFormClose,open:e,__self:this,__source:{fileName:eJ,lineNumber:57}},Q("div",{class:"dialog__position",__self:this,__source:{fileName:eJ,lineNumber:58}},Q("div",{class:"dialog__content",onClick:e=>{e.stopPropagation()},__self:this,__source:{fileName:eJ,lineNumber:59}},Q(eW,{options:a,__self:this,__source:{fileName:eJ,lineNumber:66}}),Q(eY,{...r,onSubmitSuccess:u,__self:this,__source:{fileName:eJ,lineNumber:67}})))))}let eK=`
.dialog {
  position: fixed;
  z-index: var(--z-index);
  margin: 0;
  inset: 0;

  display: flex;
  align-items: center;
  justify-content: center;
  padding: 0;
  height: 100vh;
  width: 100vw;

  color: var(--dialog-color, var(--foreground));
  fill: var(--dialog-color, var(--foreground));
  line-height: 1.75em;

  background-color: rgba(0, 0, 0, 0.05);
  border: none;
  inset: 0;
  opacity: 1;
  transition: opacity 0.2s ease-in-out;
}

.dialog__position {
  position: fixed;
  z-index: var(--z-index);
  inset: var(--dialog-inset);
  padding: var(--page-margin);
  display: flex;
  max-height: calc(100vh - (2 * var(--page-margin)));
}
@media (max-width: 600px) {
  .dialog__position {
    inset: var(--page-margin);
    padding: 0;
  }
}

.dialog__position:has(.editor) {
  inset: var(--page-margin);
  padding: 0;
}

.dialog:not([open]) {
  opacity: 0;
  pointer-events: none;
  visibility: hidden;
}
.dialog:not([open]) .dialog__content {
  transform: translate(0, -16px) scale(0.98);
}

.dialog__content {
  display: flex;
  flex-direction: column;
  gap: 16px;
  padding: var(--dialog-padding, 24px);
  max-width: 100%;
  width: 100%;
  max-height: 100%;
  overflow: auto;

  background: var(--dialog-background, var(--background));
  border-radius: var(--dialog-border-radius, 20px);
  border: var(--dialog-border, var(--border));
  box-shadow: var(--dialog-box-shadow, var(--box-shadow));
  transform: translate(0, 0) scale(1);
  transition: transform 0.2s ease-in-out;
}
`,eX=`
.dialog__header {
  display: flex;
  align-items: center;
  justify-content: space-between;
  font-weight: var(--dialog-header-weight, 600);
  margin: 0;
}

.brand-link {
  display: inline-flex;
}
.brand-link:focus-visible {
  outline: var(--outline);
}
`,eQ=`
.form {
  display: flex;
  overflow: auto;
  flex-direction: row;
  gap: 16px;
  flex: 1 0;
}

.form__right {
  flex: 0 0 auto;
  width: var(--form-width, 272px);
  display: flex;
  overflow: auto;
  flex-direction: column;
  justify-content: space-between;
  gap: 20px;
}

@media (max-width: 600px) {
  .form__right {
    width: var(--form-width, 100%);
  }
}

.form__top {
  display: flex;
  flex-direction: column;
  gap: 8px;
}

.form__error-container {
  color: var(--error-color);
  fill: var(--error-color);
}

.form__label {
  display: flex;
  flex-direction: column;
  gap: 4px;
  margin: 0px;
}

.form__label__text {
  display: flex;
  gap: 4px;
  align-items: center;
}

.form__label__text--required {
  font-size: 0.85em;
}

.form__input {
  font-family: inherit;
  line-height: inherit;
  background: transparent;
  box-sizing: border-box;
  border: var(--input-border, var(--border));
  border-radius: var(--input-border-radius, 6px);
  color: var(--input-color, inherit);
  fill: var(--input-color, inherit);
  font-size: var(--input-font-size, inherit);
  font-weight: var(--input-font-weight, 500);
  padding: 6px 12px;
}

.form__input::placeholder {
  opacity: 0.65;
  color: var(--input-placeholder-color, inherit);
  filter: var(--interactive-filter);
}

.form__input:focus-visible {
  outline: var(--input-focus-outline, var(--outline));
}

.form__input--textarea {
  font-family: inherit;
  resize: vertical;
}

.error {
  color: var(--error-color);
  fill: var(--error-color);
}
`,e0=`
.btn-group {
  display: grid;
  gap: 8px;
}

.btn {
  line-height: inherit;
  border: var(--button-border, var(--border));
  border-radius: var(--button-border-radius, 6px);
  cursor: pointer;
  font-family: inherit;
  font-size: var(--button-font-size, inherit);
  font-weight: var(--button-font-weight, 600);
  padding: var(--button-padding, 6px 16px);
}
.btn[disabled] {
  opacity: 0.6;
  pointer-events: none;
}

.btn--primary {
  color: var(--button-primary-color, var(--accent-foreground));
  fill: var(--button-primary-color, var(--accent-foreground));
  background: var(--button-primary-background, var(--accent-background));
  border: var(--button-primary-border, var(--border));
  border-radius: var(--button-primary-border-radius, 6px);
  font-weight: var(--button-primary-font-weight, 500);
}
.btn--primary:hover {
  color: var(--button-primary-hover-color, var(--accent-foreground));
  fill: var(--button-primary-hover-color, var(--accent-foreground));
  background: var(--button-primary-hover-background, var(--accent-background));
  filter: var(--interactive-filter);
}
.btn--primary:focus-visible {
  background: var(--button-primary-hover-background, var(--accent-background));
  filter: var(--interactive-filter);
  outline: var(--button-primary-focus-outline, var(--outline));
}

.btn--default {
  color: var(--button-color, var(--foreground));
  fill: var(--button-color, var(--foreground));
  background: var(--button-background, var(--background));
  border: var(--button-border, var(--border));
  border-radius: var(--button-border-radius, 6px);
  font-weight: var(--button-font-weight, 500);
}
.btn--default:hover {
  color: var(--button-color, var(--foreground));
  fill: var(--button-color, var(--foreground));
  background: var(--button-hover-background, var(--background));
  filter: var(--interactive-filter);
}
.btn--default:focus-visible {
  background: var(--button-hover-background, var(--background));
  filter: var(--interactive-filter);
  outline: var(--button-focus-outline, var(--outline));
}
`,e1=`
.success__position {
  position: fixed;
  inset: var(--dialog-inset);
  padding: var(--page-margin);
  z-index: var(--z-index);
}
.success__content {
  background: var(--success-background, var(--background));
  border: var(--success-border, var(--border));
  border-radius: var(--success-border-radius, 1.7em/50%);
  box-shadow: var(--success-box-shadow, var(--box-shadow));
  font-weight: var(--success-font-weight, 600);
  color: var(--success-color);
  fill: var(--success-color);
  padding: 12px 24px;
  line-height: 1.75em;

  display: grid;
  align-items: center;
  grid-auto-flow: column;
  gap: 6px;
  cursor: default;
}

.success__icon {
  display: flex;
}
`,e2=()=>({name:"FeedbackModal",setupOnce(){},createDialog:({options:e,screenshotIntegration:t,sendFeedback:r,shadow:n})=>{let s=e.useSentryUser,a=function(){let e=(0,o.o5)().getUser(),t=(0,o.rm)().getUser(),r=(0,o.m6)().getUser();return e&&Object.keys(e).length?e:t&&Object.keys(t).length?t:r}(),i=p.createElement("div"),l=function(e){let t=p.createElement("style");return t.textContent=`
:host {
  --dialog-inset: var(--inset);
}

${eK}
${eX}
${eQ}
${e0}
${e1}
`,e&&t.setAttribute("nonce",e),t}(e.styleNonce),c="",u={get el(){return i},appendToDom(){n.contains(l)||n.contains(i)||(n.appendChild(l),n.appendChild(i))},removeFromDom(){n.removeChild(i),n.removeChild(l),p.body.style.overflow=c},open(){d(!0),e.onFormOpen&&e.onFormOpen(),c=p.body.style.overflow,p.body.style.overflow="hidden"},close(){d(!1),p.body.style.overflow=c}},m=t&&t.createInput({h:Q,hooks:eU,dialog:u,options:e}),d=t=>{var n,o,l,c,u;n=Q(eZ,{options:e,screenshotInput:m,showName:e.showName||e.isNameRequired,showEmail:e.showEmail||e.isEmailRequired,defaultName:s&&a&&a[s.name]||"",defaultEmail:s&&a&&a[s.email]||"",onFormClose:()=>{d(!1),e.onFormClose&&e.onFormClose()},onSubmit:r,onSubmitSuccess:t=>{d(!1),e.onSubmitSuccess&&e.onSubmitSuccess(t)},onSubmitError:t=>{e.onSubmitError&&e.onSubmitError(t)},onFormSubmitted:()=>{e.onFormSubmitted&&e.onFormSubmitted()},open:t,__self:void 0,__source:{fileName:"/home/runner/work/sentry-javascript/sentry-javascript/packages/feedback/src/modal/integration.tsx",lineNumber:67}}),$.__&&$.__(n,i),l=o&&o.__k||i.__k,c=[],u=[],em(i,n=(o||i).__k=Q(et,null,[n]),l||Y,Y,void 0!==i.ownerSVGElement,o?[o]:l?null:i.firstChild?z.call(i.childNodes):null,c,o?o:l?l.__e:i.firstChild,!1,u),n.__d=void 0,ed(c,n,u)};return u}}),e3="/home/runner/work/sentry-javascript/sentry-javascript/packages/feedback/src/screenshot/components/ScreenshotEditor.tsx",e5=d.devicePixelRatio,e6=e=>({x:Math.min(e.startX,e.endX),y:Math.min(e.startY,e.endY),width:Math.abs(e.startX-e.endX),height:Math.abs(e.startY-e.endY)}),e8=e=>{let t=e.clientHeight,r=e.clientWidth,n=e.width/e.height,s=t*n,a=t;s>r&&(s=r,a=r/n);let o=(r-s)/2,i=(t-a)/2;return{startX:o,startY:i,endX:s+o,endY:a+i}},e4=()=>({name:"FeedbackScreenshot",setupOnce(){},createInput:({h:e,hooks:t,dialog:r,options:n})=>{let s=p.createElement("canvas");return{input:function({h:e,hooks:t,imageBuffer:r,dialog:n,options:s}){let a=function({hooks:e}){return function({onBeforeScreenshot:t,onScreenshot:r,onAfterScreenshot:n,onError:s}){e.useEffect(()=>{(async()=>{t();let e=await h.mediaDevices.getDisplayMedia({video:{width:d.innerWidth*d.devicePixelRatio,height:d.innerHeight*d.devicePixelRatio},audio:!1,monitorTypeSurfaces:"exclude",preferCurrentTab:!0,selfBrowserSurface:"include",surfaceSwitching:"exclude"}),s=p.createElement("video");await new Promise((t,n)=>{s.srcObject=e,s.onloadedmetadata=()=>{r(s),e.getTracks().forEach(e=>e.stop()),t()},s.play().catch(n)}),n()})().catch(s)},[])}}({hooks:t});return function({onError:o}){let i=t.useMemo(()=>({__html:function(e){let t=p.createElement("style"),r="#1A141F",n="#302735";return t.textContent=`
.editor {
  padding: 10px;
  padding-top: 65px;
  padding-bottom: 65px;
  flex-grow: 1;

  background-color: ${r};
  background-image: repeating-linear-gradient(
      -145deg,
      transparent,
      transparent 8px,
      ${r} 8px,
      ${r} 11px
    ),
    repeating-linear-gradient(
      -45deg,
      transparent,
      transparent 15px,
      ${n} 15px,
      ${n} 16px
    );
}

.editor__canvas-container {
  width: 100%;
  height: 100%;
  position: relative;
  display: flex;
  align-items: center;
  justify-content: center;
}

.editor__canvas-container canvas {
  object-fit: contain;
  position: relative;
}

.editor__crop-btn-group {
  padding: 8px;
  gap: 8px;
  border-radius: var(--menu-border-radius, 6px);
  background: var(--button-primary-background, var(--background));
  width: 175px;
  position: absolute;
}

.editor__crop-corner {
  width: 30px;
  height: 30px;
  position: absolute;
  background: none;
  border: 3px solid #ffffff;
}

.editor__crop-corner--top-left {
  cursor: nwse-resize;
  border-right: none;
  border-bottom: none;
}
.editor__crop-corner--top-right {
  cursor: nesw-resize;
  border-left: none;
  border-bottom: none;
}
.editor__crop-corner--bottom-left {
  cursor: nesw-resize;
  border-right: none;
  border-top: none;
}
.editor__crop-corner--bottom-right {
  cursor: nwse-resize;
  border-left: none;
  border-top: none;
}
`,e&&t.setAttribute("nonce",e),t}(s.styleNonce).innerText}),[]),l=function({h:e}){return function({top:t,left:r,corner:n,onGrabButton:s}){return e("button",{class:`editor__crop-corner editor__crop-corner--${n} `,style:{top:t,left:r},onMouseDown:e=>{e.preventDefault(),s(e,n)},onClick:e=>{e.preventDefault()},__self:this,__source:{fileName:"/home/runner/work/sentry-javascript/sentry-javascript/packages/feedback/src/screenshot/components/CropCorner.tsx",lineNumber:22}})}}({h:e}),c=t.useRef(null),u=t.useRef(null),m=t.useRef(null),[h,f]=t.useState({startX:0,startY:0,endX:0,endY:0}),[g,y]=t.useState(!1),[b,k]=t.useState(!1);function v(){let e=m.current,t=e6(e8(r));if(e){e.width=t.width*e5,e.height=t.height*e5,e.style.width=`${t.width}px`,e.style.height=`${t.height}px`;let r=e.getContext("2d");r&&r.scale(e5,e5)}let n=u.current;n&&(n.style.width=`${t.width}px`,n.style.height=`${t.height}px`),f({startX:0,startY:0,endX:t.width,endY:t.height})}function _(e,t){y(!1),k(!0);let r=w(t),n=()=>{p.removeEventListener("mousemove",r),p.removeEventListener("mouseup",n),y(!0),k(!1)};p.addEventListener("mouseup",n),p.addEventListener("mousemove",r)}t.useEffect(()=>{d.addEventListener("resize",v,!1)},[]),t.useEffect(()=>{let e=m.current;if(!e)return;let t=e.getContext("2d");if(!t)return;let n=e6(e8(r)),s=e6(h);t.clearRect(0,0,n.width,n.height),t.fillStyle="rgba(0, 0, 0, 0.5)",t.fillRect(0,0,n.width,n.height),t.clearRect(s.x,s.y,s.width,s.height),t.strokeStyle="#ffffff",t.lineWidth=3,t.strokeRect(s.x+1,s.y+1,s.width-2,s.height-2),t.strokeStyle="#000000",t.lineWidth=1,t.strokeRect(s.x+3,s.y+3,s.width-6,s.height-6)},[h]);let w=t.useCallback(e=>function(t){if(!m.current)return;let r=m.current,n=r.getBoundingClientRect(),s=t.clientX-n.x,a=t.clientY-n.y;switch(e){case"top-left":f(e=>({...e,startX:Math.min(Math.max(0,s),e.endX-33),startY:Math.min(Math.max(0,a),e.endY-33)}));break;case"top-right":f(e=>({...e,endX:Math.max(Math.min(s,r.width/e5),e.startX+33),startY:Math.min(Math.max(0,a),e.endY-33)}));break;case"bottom-left":f(e=>({...e,startX:Math.min(Math.max(0,s),e.endX-33),endY:Math.max(Math.min(a,r.height/e5),e.startY+33)}));break;case"bottom-right":f(e=>({...e,endX:Math.max(Math.min(s,r.width/e5),e.startX+33),endY:Math.max(Math.min(a,r.height/e5),e.startY+33)}))}},[]),x=t.useRef({initialX:0,initialY:0});return a({onBeforeScreenshot:t.useCallback(()=>{n.el.style.display="none"},[]),onScreenshot:t.useCallback(e=>{let t=r.getContext("2d");if(!t)throw Error("Could not get canvas context");r.width=e.videoWidth,r.height=e.videoHeight,r.style.width="100%",r.style.height="100%",t.drawImage(e,0,0)},[r]),onAfterScreenshot:t.useCallback(()=>{n.el.style.display="block";let e=c.current;e&&e.appendChild(r),v()},[]),onError:t.useCallback(e=>{n.el.style.display="block",o(e)},[])}),e("div",{class:"editor",__self:this,__source:{fileName:e3,lineNumber:315}},e("style",{nonce:s.styleNonce,dangerouslySetInnerHTML:i,__self:this,__source:{fileName:e3,lineNumber:316}}),e("div",{class:"editor__canvas-container",ref:c,__self:this,__source:{fileName:e3,lineNumber:317}},e("div",{class:"editor__crop-container",style:{position:"absolute",zIndex:1},ref:u,__self:this,__source:{fileName:e3,lineNumber:318}},e("canvas",{onMouseDown:function(e){if(b)return;x.current={initialX:e.clientX,initialY:e.clientY};let t=e=>{let t=m.current;if(!t)return;let r=e.clientX-x.current.initialX,n=e.clientY-x.current.initialY;f(s=>{let a=Math.max(0,Math.min(s.startX+r,t.width/e5-(s.endX-s.startX))),o=Math.max(0,Math.min(s.startY+n,t.height/e5-(s.endY-s.startY))),i=a+(s.endX-s.startX),l=o+(s.endY-s.startY);return x.current.initialX=e.clientX,x.current.initialY=e.clientY,{startX:a,startY:o,endX:i,endY:l}})},r=()=>{p.removeEventListener("mousemove",t),p.removeEventListener("mouseup",r)};p.addEventListener("mousemove",t),p.addEventListener("mouseup",r)},style:{position:"absolute",cursor:g?"move":"auto"},ref:m,__self:this,__source:{fileName:e3,lineNumber:319}}),e(l,{left:h.startX-3,top:h.startY-3,onGrabButton:_,corner:"top-left",__self:this,__source:{fileName:e3,lineNumber:324}}),e(l,{left:h.endX-30+3,top:h.startY-3,onGrabButton:_,corner:"top-right",__self:this,__source:{fileName:e3,lineNumber:330}}),e(l,{left:h.startX-3,top:h.endY-30+3,onGrabButton:_,corner:"bottom-left",__self:this,__source:{fileName:e3,lineNumber:336}}),e(l,{left:h.endX-30+3,top:h.endY-30+3,onGrabButton:_,corner:"bottom-right",__self:this,__source:{fileName:e3,lineNumber:342}}),e("div",{style:{left:Math.max(0,h.endX-191),top:Math.max(0,h.endY+8),display:g?"flex":"none"},class:"editor__crop-btn-group",__self:this,__source:{fileName:e3,lineNumber:348}},e("button",{onClick:e=>{e.preventDefault(),m.current&&f({startX:0,startY:0,endX:m.current.width/e5,endY:m.current.height/e5}),y(!1)},class:"btn btn--default",__self:this,__source:{fileName:e3,lineNumber:356}},s.cancelButtonLabel),e("button",{onClick:e=>{e.preventDefault(),function(){let e=p.createElement("canvas"),t=e6(e8(r)),n=e6(h);e.width=n.width*e5,e.height=n.height*e5;let s=e.getContext("2d");s&&r&&s.drawImage(r,n.x/t.width*r.width,n.y/t.height*r.height,n.width/t.width*r.width,n.height/t.height*r.height,0,0,e.width,e.height);let a=r.getContext("2d");a&&(a.clearRect(0,0,r.width,r.height),r.width=e.width,r.height=e.height,r.style.width=`${n.width}px`,r.style.height=`${n.height}px`,a.drawImage(e,0,0),v())}(),y(!1)},class:"btn btn--primary",__self:this,__source:{fileName:e3,lineNumber:373}},s.confirmButtonLabel)))))}}({h:e,hooks:t,imageBuffer:s,dialog:r,options:n}),value:async()=>{let e=await new Promise(e=>{s.toBlob(e,"image/png")});if(e)return{data:new Uint8Array(await e.arrayBuffer()),filename:"screenshot.png",contentType:"application/png"}}}}})},671054(e,t,r){"use strict";r.d(t,{wQ:()=>a});var n=r(258862);let s=(0,n.u)("sentry"),a=(0,n.X)(s,globalThis.document?"ui":"background")},680985(e,t,r){"use strict";r.d(t,{RV:()=>m,gd:()=>o,qQ:()=>u,vk:()=>i,yF:()=>n});let n="?",s=/\(error: (.*)\)/,a=/captureMessage|captureException/;function o(...e){let t=e.sort((e,t)=>e[0]-t[0]).map(e=>e[1]);return(e,r=0,o=0)=>{let i=[],c=e.split(`
`);for(let e=r;e<c.length;e++){let r=c[e];if(r.length>1024)continue;let n=s.test(r)?r.replace(s,"$1"):r;if(!n.match(/\S*Error: /)){for(let e of t){let t=e(n);if(t){i.push(t);break}}if(i.length>=50+o)break}}var u=i.slice(o);if(!u.length)return[];let m=Array.from(u);return/sentryWrapped/.test(l(m).function||"")&&m.pop(),m.reverse(),a.test(l(m).function||"")&&(m.pop(),a.test(l(m).function||"")&&m.pop()),m.slice(0,50).map(e=>({...e,filename:e.filename||l(m).filename,function:e.function||n}))}}function i(e){return Array.isArray(e)?o(...e):e}function l(e){return e[e.length-1]||{}}let c="<anonymous>";function u(e){try{if(!e||"function"!=typeof e)return c;return e.name||c}catch(e){return c}}function m(e){let t=e.exception;if(t){let e=[];try{return t.values.forEach(t=>{t.stacktrace.frames&&e.push(...t.stacktrace.frames)}),e}catch(e){}}}},681747(e,t,r){"use strict";r.d(t,{I:()=>s});var n=r(12796);let s=e=>{n.j.document&&n.j.document.prerendering?addEventListener("prerenderingchange",()=>e(),!0):e()}},683075(e,t,r){e.exports=function(e){function t(e){let r,s,a,o=null;function i(...e){if(!i.enabled)return;let n=Number(new Date);i.diff=n-(r||n),i.prev=r,i.curr=n,r=n,e[0]=t.coerce(e[0]),"string"!=typeof e[0]&&e.unshift("%O");let s=0;e[0]=e[0].replace(/%([a-zA-Z%])/g,(r,n)=>{if("%%"===r)return"%";s++;let a=t.formatters[n];if("function"==typeof a){let t=e[s];r=a.call(i,t),e.splice(s,1),s--}return r}),t.formatArgs.call(i,e),(i.log||t.log).apply(i,e)}return i.namespace=e,i.useColors=t.useColors(),i.color=t.selectColor(e),i.extend=n,i.destroy=t.destroy,Object.defineProperty(i,"enabled",{enumerable:!0,configurable:!1,get:()=>null!==o?o:(s!==t.namespaces&&(s=t.namespaces,a=t.enabled(e)),a),set:e=>{o=e}}),"function"==typeof t.init&&t.init(i),i}function n(e,r){let n=t(this.namespace+(void 0===r?":":r)+e);return n.log=this.log,n}function s(e,t){let r=0,n=0,s=-1,a=0;for(;r<e.length;)if(n<t.length&&(t[n]===e[r]||"*"===t[n]))"*"===t[n]?(s=n,a=r):r++,n++;else{if(-1===s)return!1;n=s+1,r=++a}for(;n<t.length&&"*"===t[n];)n++;return n===t.length}return t.debug=t,t.default=t,t.coerce=function(e){return e instanceof Error?e.stack||e.message:e},t.disable=function(){let e=[...t.names,...t.skips.map(e=>"-"+e)].join(",");return t.enable(""),e},t.enable=function(e){for(let r of(t.save(e),t.namespaces=e,t.names=[],t.skips=[],("string"==typeof e?e:"").trim().replace(/\s+/g,",").split(",").filter(Boolean)))"-"===r[0]?t.skips.push(r.slice(1)):t.names.push(r)},t.enabled=function(e){for(let r of t.skips)if(s(e,r))return!1;for(let r of t.names)if(s(e,r))return!0;return!1},t.humanize=r(254660),t.destroy=function(){console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.")},Object.keys(e).forEach(r=>{t[r]=e[r]}),t.names=[],t.skips=[],t.formatters={},t.selectColor=function(e){let r=0;for(let t=0;t<e.length;t++)r=(r<<5)-r+e.charCodeAt(t)|0;return t.colors[Math.abs(r)%t.colors.length]},t.enable(t.load()),t}},689686(e,t,r){"use strict";r.d(t,{U:()=>i});var n=r(652825),s=r(290266),a=r(525037);let o=/Z|([+-]\d{2}:?\d{2})$/u,i=(0,n.YP)((0,s.Yj)(),"ISO 8601 date",e=>a.c9.fromISO(e).isValid?!!o.test(e)||"ISO 8601 date must have timezone information":"Not a valid ISO 8601 date")},691963(e,t,r){"use strict";r.d(t,{q:()=>m});var n=r(230337),s=r(384255),a=r(107842),o=r(696294),i=r(837075),l=r(40209),c=r(933190),u=r(793111);let m=(0,r(290264)._C)((e={})=>{let t=e.levels||a.Ow;return{name:"CaptureConsole",setup(e){"console"in n.O&&(0,s.P)(({args:r,level:n})=>{(0,c.KU)()===e&&t.includes(n)&&function(e,t){let r={level:(0,i.t)(t),extra:{arguments:e}};(0,c.v4)(n=>{if(n.addEventProcessor(e=>(e.logger="console",(0,o.M6)(e,{handled:!1,type:"console"}),e)),"assert"===t){if(!e[0]){let t=`Assertion failed: ${(0,l.gt)(e.slice(1)," ")||"console.assert"}`;n.setExtra("arguments",e.slice(1)),(0,u.wd)(t,r)}return}let s=e.find(e=>e instanceof Error);if(s)return void(0,u.Cp)(s,r);let a=(0,l.gt)(e," ");(0,u.wd)(a,r)})}(r,n)})}}})},694729(e,t,r){"use strict";r.d(t,{x:()=>l});var n=r(290266),s=r(545203),a=r(728195),o=r(159167),i=r(157392);let l=(0,s.kp)(i.Wu,(0,n.Ik)({type:(0,a.eu)(i.Z6.Image),value:(0,o.J)()}))},696294(e,t,r){"use strict";r.d(t,{$X:()=>l,GR:()=>d,M6:()=>u,db:()=>m,eJ:()=>o,gO:()=>c,k9:()=>p});var n=r(97407),s=r(40209),a=r(230337);function o(){let e=a.O,t=e.crypto||e.msCrypto,r=()=>16*Math.random();try{if(t&&t.randomUUID)return t.randomUUID().replace(/-/g,"");t&&t.getRandomValues&&(r=()=>{let e=new Uint8Array(1);return t.getRandomValues(e),e[0]})}catch(e){}return"10000000100040008000100000000000".replace(/[018]/g,e=>(e^(15&r())>>e/4).toString(16))}function i(e){return e.exception&&e.exception.values?e.exception.values[0]:void 0}function l(e){let{message:t,event_id:r}=e;if(t)return t;let n=i(e);return n?n.type&&n.value?`${n.type}: ${n.value}`:n.type||n.value||r||"<unknown>":r||"<unknown>"}function c(e,t,r){let n=e.exception=e.exception||{},s=n.values=n.values||[],a=s[0]=s[0]||{};a.value||(a.value=t||""),a.type||(a.type=r||"Error")}function u(e,t){let r=i(e);if(!r)return;let n=r.mechanism;if(r.mechanism={type:"generic",handled:!0,...n,...t},t&&"data"in t){let e={...n&&n.data,...t.data};r.mechanism.data=e}}function m(e,t,r=5){if(void 0===t.lineno)return;let n=e.length,a=Math.max(Math.min(n-1,t.lineno-1),0);t.pre_context=e.slice(Math.max(0,a-r),a).map(e=>(0,s.nC)(e,0));let o=Math.min(n-1,a);t.context_line=(0,s.nC)(e[o],t.colno||0),t.post_context=e.slice(Math.min(a+1,n),a+1+r).map(e=>(0,s.nC)(e,0))}function d(e){if(e&&e.__sentry_captured__)return!0;try{(0,n.my)(e,"__sentry_captured__",!0)}catch(e){}return!1}function p(e){return Array.isArray(e)?e:[e]}},707995(e,t,r){"use strict";r.d(t,{l:()=>l});var n=r(290264),s=r(230337),a=r(696294),o=r(830339);let i=s.O,l=(0,n._C)((e={})=>{let t=null!=e.frameContextLines?e.frameContextLines:7;return{name:"ContextLines",processEvent:e=>(function(e,t){let r=i.document,n=i.location&&(0,o.f)(i.location.href);if(!r||!n)return e;let s=e.exception&&e.exception.values;if(!s||!s.length)return e;let l=r.documentElement.innerHTML;if(!l)return e;let c=["<!DOCTYPE html>","<html>",...l.split(`
`),"</html>"];return s.forEach(e=>{let r=e.stacktrace;r&&r.frames&&(r.frames=r.frames.map(e=>{var r,s,o,i;return r=e,s=c,o=n,i=t,r.filename===o&&r.lineno&&s.length&&(0,a.db)(s,r,i),r}))}),e})(e,t)}})},711210(e,t,r){"use strict";r.d(t,{r:()=>o});var n=r(353959),s=r(584553),a=r(132002);let o={parse:e=>i(s.f.rpc.parse,e),invalidRequest:e=>i(s.f.rpc.invalidRequest,e),invalidParams:e=>i(s.f.rpc.invalidParams,e),methodNotFound:e=>i(s.f.rpc.methodNotFound,e),internal:e=>i(s.f.rpc.internal,e),server:e=>{if(!e||"object"!=typeof e||Array.isArray(e))throw Error("Ethereum RPC Server errors must provide single object argument.");let{code:t}=e;if(!Number.isInteger(t)||t>-32005||t<-32099)throw Error('"code" must be an integer such that: -32099 <= code <= -32005');return i(t,e)},invalidInput:e=>i(s.f.rpc.invalidInput,e),resourceNotFound:e=>i(s.f.rpc.resourceNotFound,e),resourceUnavailable:e=>i(s.f.rpc.resourceUnavailable,e),transactionRejected:e=>i(s.f.rpc.transactionRejected,e),methodNotSupported:e=>i(s.f.rpc.methodNotSupported,e),limitExceeded:e=>i(s.f.rpc.limitExceeded,e)};function i(e,t){let[r,s]=function(e){if(e){if("string"==typeof e)return[e];else if("object"==typeof e&&!Array.isArray(e)){let{message:t,data:r}=e;if(t&&"string"!=typeof t)throw Error("Must specify string message.");return[t??void 0,r]}}return[]}(t);return new n.G(e,r??(0,a.DW)(e),s)}},714599(e,t,r){"use strict";r.d(t,{Er:()=>i,Mn:()=>l});var n=r(25605),s=r(397718),a=r(37853),o=r(12796);let i="__sentry_xhr_v3__";function l(e){(0,n.s5)("xhr",e),(0,n.AS)("xhr",c)}function c(){if(!o.j.XMLHttpRequest)return;let e=XMLHttpRequest.prototype;e.open=new Proxy(e.open,{apply(e,t,r){let o=1e3*(0,a.zf)(),l=(0,s.Kg)(r[0])?r[0].toUpperCase():void 0,c=function(e){if((0,s.Kg)(e))return e;try{return e.toString()}catch(e){}}(r[1]);if(!l||!c)return e.apply(t,r);t[i]={method:l,url:c,request_headers:{}},"POST"===l&&c.match(/sentry_key/)&&(t.__sentry_own_request__=!0);let u=()=>{let e=t[i];if(e&&4===t.readyState){try{e.status_code=t.status}catch(e){}let r={endTimestamp:1e3*(0,a.zf)(),startTimestamp:o,xhr:t};(0,n.aj)("xhr",r)}};return"onreadystatechange"in t&&"function"==typeof t.onreadystatechange?t.onreadystatechange=new Proxy(t.onreadystatechange,{apply:(e,t,r)=>(u(),e.apply(t,r))}):t.addEventListener("readystatechange",u),t.setRequestHeader=new Proxy(t.setRequestHeader,{apply(e,t,r){let[n,a]=r,o=t[i];return o&&(0,s.Kg)(n)&&(0,s.Kg)(a)&&(o.request_headers[n.toLowerCase()]=a),e.apply(t,r)}}),e.apply(t,r)}}),e.send=new Proxy(e.send,{apply(e,t,r){let s=t[i];if(!s)return e.apply(t,r);void 0!==r[0]&&(s.body=r[0]);let o={startTimestamp:1e3*(0,a.zf)(),xhr:t};return(0,n.aj)("xhr",o),e.apply(t,r)}})}},716070(e,t,r){"use strict";function n(e){if(!Number.isSafeInteger(e)||e<0)throw Error("positive integer expected, got "+e)}function s(e,...t){if(!(e instanceof Uint8Array||ArrayBuffer.isView(e)&&"Uint8Array"===e.constructor.name))throw Error("Uint8Array expected");if(t.length>0&&!t.includes(e.length))throw Error("Uint8Array expected of length "+t+", got length="+e.length)}function a(e,t=!0){if(e.destroyed)throw Error("Hash instance has been destroyed");if(t&&e.finished)throw Error("Hash#digest() has already been called")}function o(e,t){s(e);let r=t.outputLen;if(e.length<r)throw Error("digestInto() expects output buffer of length at least "+r)}function i(e){return new Uint32Array(e.buffer,e.byteOffset,Math.floor(e.byteLength/4))}function l(...e){for(let t=0;t<e.length;t++)e[t].fill(0)}r.d(t,{CC:()=>a,DH:()=>i,DO:()=>s,Fe:()=>n,Ht:()=>o,Vw:()=>m,ZJ:()=>u,fd:()=>c,qj:()=>d,uH:()=>l});let c=68===new Uint8Array(new Uint32Array([0x11223344]).buffer)[0]?e=>e:function(e){for(let r=0;r<e.length;r++){var t;e[r]=(t=e[r])<<24&0xff000000|t<<8&0xff0000|t>>>8&65280|t>>>24&255}return e};function u(e){return"string"==typeof e&&(e=function(e){if("string"!=typeof e)throw Error("string expected");return new Uint8Array(new TextEncoder().encode(e))}(e)),s(e),e}class m{}function d(e){let t=t=>e().update(u(t)).digest(),r=e();return t.outputLen=r.outputLen,t.blockLen=r.blockLen,t.create=()=>e(),t}},717309(e,t,r){"use strict";r.r(t),r.d(t,{BrowserClient:()=>R.y,SDK_VERSION:()=>w.M,SEMANTIC_ATTRIBUTE_SENTRY_OP:()=>c.uT,SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN:()=>c.JD,SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE:()=>c.sy,SEMANTIC_ATTRIBUTE_SENTRY_SOURCE:()=>c.i_,Scope:()=>d.H,WINDOW:()=>D.jf,addBreadcrumb:()=>k.Z,addEventProcessor:()=>u.SA,addIntegration:()=>g.Q8,addTracingExtensions:()=>s.U,breadcrumbsIntegration:()=>$.F,browserApiErrorsIntegration:()=>H.G,browserProfilingIntegration:()=>ea.f,browserTracingIntegration:()=>en.dp,captureConsoleIntegration:()=>S.q,captureEvent:()=>u.r,captureException:()=>u.Cp,captureFeedback:()=>M.q,captureMessage:()=>u.wd,captureSession:()=>u.J5,captureUserFeedback:()=>z.lo,chromeStackLineParser:()=>F.Yj,close:()=>u.VN,contextLinesIntegration:()=>J.l,continueTrace:()=>o.V4,createTransport:()=>h.o,createUserFeedbackEnvelope:()=>q.L,debugIntegration:()=>E._,dedupeIntegration:()=>j.s,defaultRequestInstrumentationOptions:()=>er.h$,defaultStackLineParsers:()=>F.c9,defaultStackParser:()=>F.lG,endSession:()=>u.ky,eventFromException:()=>P.u,eventFromMessage:()=>P.qv,exceptionFromError:()=>P.K8,extraErrorDataIntegration:()=>T.X,feedbackAsyncIntegration:()=>X.C,feedbackIntegration:()=>Q.X,feedbackSyncIntegration:()=>Q.X,flush:()=>u.bX,forceLoad:()=>z.w7,functionToStringIntegration:()=>v.Z,geckoStackLineParser:()=>F.dY,getActiveSpan:()=>b.Bk,getClient:()=>m.KU,getCurrentHub:()=>N.B,getCurrentScope:()=>m.o5,getDefaultIntegrations:()=>z.nI,getFeedback:()=>ee.e4,getGlobalScope:()=>m.m6,getIsolationScope:()=>m.rm,getReplay:()=>Z.M,getRootSpan:()=>b.zU,getSpanDescendants:()=>b.xO,getSpanStatusFromHttpCode:()=>a.AJ,globalHandlersIntegration:()=>U.L,httpClientIntegration:()=>G.c,httpContextIntegration:()=>B.M,inboundFiltersIntegration:()=>_.D,init:()=>z.Ts,instrumentOutgoingRequests:()=>er.Qb,isInitialized:()=>u.Dp,lastEventId:()=>u.Q,lazyLoadIntegration:()=>V.b,linkedErrorsIntegration:()=>W.p,makeBrowserOfflineTransport:()=>es.z9,makeFetchTransport:()=>L._,makeMultiplexedTransport:()=>f.N,metrics:()=>et.q,moduleMetadataIntegration:()=>x.Q,onLoad:()=>z.kF,opera10StackLineParser:()=>F.Q_,opera11StackLineParser:()=>F.Vv,parameterize:()=>y.y,registerSpanErrorInstrumentation:()=>n.s,replayCanvasIntegration:()=>K.y,replayIntegration:()=>Z.w,reportingObserverIntegration:()=>Y.n,rewriteFramesIntegration:()=>A.D,sendFeedback:()=>ee.Sq,sessionTimingIntegration:()=>C.Z,setContext:()=>u.o,setCurrentClient:()=>p.B,setExtra:()=>u.l7,setExtras:()=>u.cx,setHttpStatus:()=>a.N8,setMeasurement:()=>l.X,setTag:()=>u.NA,setTags:()=>u.Wt,setUser:()=>u.gV,showReportDialog:()=>z.mn,spanToBaggageHeader:()=>i.HW,spanToJSON:()=>b.et,spanToTraceHeader:()=>b.Qh,startBrowserTracingNavigationSpan:()=>en.Nt,startBrowserTracingPageLoadSpan:()=>en.Sx,startInactiveSpan:()=>o.Uk,startNewTrace:()=>o.Y7,startSession:()=>u.J0,startSpan:()=>o.Lk,startSpanManual:()=>o.nV,thirdPartyErrorFilterIntegration:()=>O.y,winjsStackLineParser:()=>F.$2,withActiveSpan:()=>o.hb,withIsolationScope:()=>m.rB,withScope:()=>m.v4,zodErrorsIntegration:()=>I.r});var n=r(718800),s=r(77614),a=r(96331),o=r(16686),i=r(836164),l=r(173177),c=r(812863),u=r(793111),m=r(933190),d=r(973234),p=r(155682),h=r(136244),f=r(587044),g=r(290264),y=r(187763),b=r(608119),k=r(92376),v=r(724666),_=r(48718),w=r(538600),x=r(367877),S=r(691963),E=r(115433),j=r(254759),T=r(986746),A=r(808106),C=r(138706),I=r(534098),O=r(405971),M=r(532725),N=r(631905),D=r(845226),R=r(494688),L=r(47810),F=r(503510),P=r(943544),q=r(273521),z=r(550041),$=r(443227),U=r(266615),B=r(130760),W=r(642735),H=r(868888),V=r(360023),Y=r(851781),G=r(392788),J=r(707995),Z=r(117172),K=r(928535),X=r(106438),Q=r(224245),ee=r(666012),et=r(747402),er=r(659129),en=r(591386),es=r(216295),ea=r(537252)},718800(e,t,r){"use strict";r.d(t,{s:()=>u});var n=r(988217),s=r(471265),a=r(107842),o=r(67904),i=r(608119),l=r(96331);let c=!1;function u(){c||(c=!0,(0,n.L)(m),(0,s.r)(m))}function m(){let e=(0,i.Bk)(),t=e&&(0,i.zU)(e);if(t){let e="internal_error";o.T&&a.vF.log(`[Tracing] Root span: ${e} -> Global error occured`),t.setStatus({code:l.TJ,message:e})}}m.tag="sentry_tracingErrorCallback"},719149(e,t,r){"use strict";r.d(t,{Rg:()=>l,e2:()=>i});var n=r(696294),s=r(97407),a=r(836164),o=r(608119);function i(e,t){var r,i,l,c;let{fingerprint:u,span:m,breadcrumbs:d,sdkProcessingMetadata:p}=t;(function(e,t){let{extra:r,tags:n,user:a,contexts:o,level:i,transactionName:l}=t,c=(0,s.Ce)(r);c&&Object.keys(c).length&&(e.extra={...c,...e.extra});let u=(0,s.Ce)(n);u&&Object.keys(u).length&&(e.tags={...u,...e.tags});let m=(0,s.Ce)(a);m&&Object.keys(m).length&&(e.user={...m,...e.user});let d=(0,s.Ce)(o);d&&Object.keys(d).length&&(e.contexts={...d,...e.contexts}),i&&(e.level=i),l&&"transaction"!==e.type&&(e.transaction=l)})(e,t),m&&function(e,t){e.contexts={trace:(0,o.kX)(t),...e.contexts},e.sdkProcessingMetadata={dynamicSamplingContext:(0,a.k1)(t),...e.sdkProcessingMetadata};let r=(0,o.zU)(t),n=(0,o.et)(r).description;n&&!e.transaction&&"transaction"===e.type&&(e.transaction=n)}(e,m),r=e,i=u,r.fingerprint=r.fingerprint?(0,n.k9)(r.fingerprint):[],i&&(r.fingerprint=r.fingerprint.concat(i)),r.fingerprint&&!r.fingerprint.length&&delete r.fingerprint,function(e,t){let r=[...e.breadcrumbs||[],...t];e.breadcrumbs=r.length?r:void 0}(e,d),l=e,c=p,l.sdkProcessingMetadata={...l.sdkProcessingMetadata,...c}}function l(e,t){let{extra:r,tags:n,user:s,contexts:a,level:o,sdkProcessingMetadata:i,breadcrumbs:l,fingerprint:u,eventProcessors:m,attachments:d,propagationContext:p,transactionName:h,span:f}=t;c(e,"extra",r),c(e,"tags",n),c(e,"user",s),c(e,"contexts",a),c(e,"sdkProcessingMetadata",i),o&&(e.level=o),h&&(e.transactionName=h),f&&(e.span=f),l.length&&(e.breadcrumbs=[...e.breadcrumbs,...l]),u.length&&(e.fingerprint=[...e.fingerprint,...u]),m.length&&(e.eventProcessors=[...e.eventProcessors,...m]),d.length&&(e.attachments=[...e.attachments,...d]),e.propagationContext={...e.propagationContext,...p}}function c(e,t,r){if(r&&Object.keys(r).length)for(let n in e[t]={...e[t]},r)Object.prototype.hasOwnProperty.call(r,n)&&(e[t][n]=r[n])}},719509(e,t,r){"use strict";function n(e,t){var r,n,a,o;let i=t&&t.getDsn(),l=t&&t.getOptions().tunnel;return r=e,!!(n=i)&&r.includes(n.host)||(a=e,!!(o=l)&&s(a)===s(o))}function s(e){return"/"===e[e.length-1]?e.slice(0,-1):e}r.d(t,{A:()=>n})},721117(e,t,r){"use strict";var n,s;r.d(t,{h:()=>n}),(s=n||(n={})).Alert="alert",s.Confirmation="confirmation",s.Prompt="prompt"},724666(e,t,r){"use strict";let n;r.d(t,{Z:()=>l});var s=r(97407),a=r(933190),o=r(290264);let i=new WeakMap,l=(0,o._C)(()=>({name:"FunctionToString",setupOnce(){n=Function.prototype.toString;try{Function.prototype.toString=function(...e){let t=(0,s.sp)(this),r=i.has((0,a.KU)())&&void 0!==t?t:this;return n.apply(r,e)}}catch(e){}},setup(e){i.set(e,!0)}}))},728195(e,t,r){"use strict";r.d(t,{$9:()=>c,E$:()=>m,KC:()=>l,eu:()=>i,i5:()=>u});var n=r(448967),s=r(290266),a=r(545203),o=r(812805);function i(e){return(0,a.E8)(JSON.stringify(e),(0,s.eu)(e).validator)}function l([e,...t]){let r=(0,s.KC)([e,...t]);return new n._k({...r,schema:[e,...t]})}function c(e){return i(e)}function u(e){let t=e.map(e=>"union"===e.type&&Array.isArray(e.schema)?e.schema:e).flat(1/0),r=t.map(({schema:e})=>e.type.type),s=t.reduce((e,t)=>(e[JSON.parse(t.schema.type.type)]=t,e),{});return new n._k({type:"union",schema:t,*entries(e,t){if(!(0,o.Gv)(e)||!(0,o.i5)(e,"type")||"string"!=typeof e.type)return;let{type:r}=e,n=s[r];if(n)for(let r of n.entries(e,t))yield r},coercer(e,t){if(!(0,o.Gv)(e)||!(0,o.i5)(e,"type")||"string"!=typeof e.type)return e;let{type:r}=e,n=s[r];return n?n.coercer(e,t):e},*refiner(e,t){let r=s[e.type];yield*r.refiner(e,t)},validator(e,t){if(!(0,o.Gv)(e)||!(0,o.i5)(e,"type")||"string"!=typeof e.type)return`Expected type to be one of: ${r.join(", ")}, but received: undefined`;let{type:n}=e,a=s[n];return a?a.validator(e,t):`Expected type to be one of: ${r.join(", ")}, but received: "${n}"`}})}function m(e){return new n._k({type:"union",schema:null,*entries(t,r){for(let n of e(t).entries(t,r))yield n},*refiner(t,r){let n=e(t);yield*n.refiner(t,r)},coercer:(t,r)=>e(t).coercer(t,r),validator:(t,r)=>e(t).validator(t,r)})}},730074(e,t,r){"use strict";r.d(t,{v:()=>f});var n=r(397718),s=r(572858),a=r(644094),o=r(830339),i=r(933190),l=r(812863),c=r(777217),u=r(608119),m=r(140722),d=r(96331),p=r(16686),h=r(836164);function f(e,t,r,g,y="auto.http.browser"){if(!e.fetchData)return;let b=(0,c.w)()&&t(e.fetchData.url);if(e.endTimestamp&&b){let t=e.fetchData.__span;if(!t)return;let r=g[t];r&&(function(e,t){if(t.response){(0,d.N8)(e,t.response.status);let r=t.response&&t.response.headers&&t.response.headers.get("content-length");if(r){let t=parseInt(r);t>0&&e.setAttribute("http.response_content_length",t)}}else t.error&&e.setStatus({code:d.TJ,message:"internal_error"});e.end()}(r,e),delete g[t]);return}let k=(0,i.o5)(),v=(0,i.KU)(),{method:_,url:w}=e.fetchData,x=function(e){try{return new URL(e).href}catch(e){return}}(w),S=x?(0,o.Dl)(x).host:void 0,E=!!(0,u.Bk)(),j=b&&E?(0,p.Uk)({name:`${_} ${w}`,attributes:{url:w,type:"fetch","http.method":_,"http.url":x,"server.address":S,[l.JD]:y,[l.uT]:"http.client"}}):new m.w;if(e.fetchData.__span=j.spanContext().spanId,g[j.spanContext().spanId]=j,r(e.fetchData.url)&&v){let t=e.args[0];e.args[1]=e.args[1]||{};let r=e.args[1];r.headers=function(e,t,r,o,l){let{traceId:c,spanId:m,sampled:d,dsc:p}={...(0,i.rm)().getPropagationContext(),...r.getPropagationContext()},f=l?(0,u.Qh)(l):(0,s.TC)(c,m,d),g=(0,a.De)(p||(l?(0,h.k1)(l):(0,h.lF)(c,t))),y=o.headers||("undefined"!=typeof Request&&(0,n.tH)(e,Request)?e.headers:void 0);if(!y)return{"sentry-trace":f,baggage:g};if("undefined"!=typeof Headers&&(0,n.tH)(y,Headers)){let e=new Headers(y);return e.append("sentry-trace",f),g&&e.append(a.hF,g),e}if(Array.isArray(y)){let e=[...y,["sentry-trace",f]];return g&&e.push([a.hF,g]),e}{let e="baggage"in y?y.baggage:void 0,t=[];return Array.isArray(e)?t.push(...e):e&&t.push(e),g&&t.push(g),{...y,"sentry-trace":f,baggage:t.length>0?t.join(","):void 0}}}(t,v,k,r,(0,c.w)()&&E?j:void 0)}return j}},731318(e,t,r){"use strict";r.d(t,{J5:()=>V,QE:()=>Z,_E:()=>ee,a8:()=>Y,lA:()=>H,rB:()=>G});var n=r(316244),s=r(208570),a=r(794204),o=r(831022);let i=/[A-Za-z_+-]{1,256}(?::?\/[A-Za-z0-9_+-]{1,256}(?:\/[A-Za-z0-9_+-]{1,256})?)?/;function l(...e){let t=e.reduce((e,t)=>e+t.source,"");return RegExp(`^${t}$`)}function c(...e){return t=>e.reduce(([e,r,n],s)=>{let[a,o,i]=s(t,n);return[{...e,...a},o||r,i]},[{},null,1]).slice(0,2)}function u(e,...t){if(null==e)return[null,null];for(let[r,n]of t){let t=r.exec(e);if(t)return n(t)}return[null,null]}function m(...e){return(t,r)=>{let s,a={};for(s=0;s<e.length;s++)a[e[s]]=(0,n.cG)(t[r+s]);return[a,null,r+s]}}let d=/(?:(Z)|([+-]\d\d)(?::?(\d\d))?)/,p=`(?:${d.source}?(?:\\[(${i.source})\\])?)?`,h=/(\d\d)(?::?(\d\d)(?::?(\d\d)(?:[.,](\d{1,30}))?)?)?/,f=RegExp(`${h.source}${p}`),g=RegExp(`(?:T${f.source})?`),y=m("weekYear","weekNumber","weekDay"),b=m("year","ordinal"),k=RegExp(`${h.source} ?(?:${d.source}|(${i.source}))?`),v=RegExp(`(?: ${k.source})?`);function _(e,t,r){let s=e[t];return(0,n.b0)(s)?r:(0,n.cG)(s)}function w(e,t){return[{hours:_(e,t,0),minutes:_(e,t+1,0),seconds:_(e,t+2,0),milliseconds:(0,n.m3)(e[t+3])},null,t+4]}function x(e,t){let r=!e[t]&&!e[t+1],s=(0,n.gu)(e[t+1],e[t+2]);return[{},r?null:a.A.instance(s),t+3]}function S(e,t){return[{},e[t]?o.A.create(e[t]):null,t+1]}let E=RegExp(`^T?${h.source}$`),j=/^-?P(?:(?:(-?\d{1,20}(?:\.\d{1,20})?)Y)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20}(?:\.\d{1,20})?)W)?(?:(-?\d{1,20}(?:\.\d{1,20})?)D)?(?:T(?:(-?\d{1,20}(?:\.\d{1,20})?)H)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20})(?:[.,](-?\d{1,20}))?S)?)?)$/;function T(e){let[t,r,s,a,o,i,l,c,u]=e,m="-"===t[0],d=c&&"-"===c[0],p=(e,t=!1)=>void 0!==e&&(t||e&&m)?-e:e;return[{years:p((0,n.mp)(r)),months:p((0,n.mp)(s)),weeks:p((0,n.mp)(a)),days:p((0,n.mp)(o)),hours:p((0,n.mp)(i)),minutes:p((0,n.mp)(l)),seconds:p((0,n.mp)(c),"-0"===c),milliseconds:p((0,n.m3)(u),d)}]}let A={GMT:0,EDT:-240,EST:-300,CDT:-300,CST:-360,MDT:-360,MST:-420,PDT:-420,PST:-480};function C(e,t,r,a,o,i,l){let c={year:2===t.length?(0,n.fT)((0,n.cG)(t)):(0,n.cG)(t),month:s.s$.indexOf(r)+1,day:(0,n.cG)(a),hour:(0,n.cG)(o),minute:(0,n.cG)(i)};return l&&(c.second=(0,n.cG)(l)),e&&(c.weekday=e.length>3?s.s7.indexOf(e)+1:s.Ci.indexOf(e)+1),c}let I=/^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|(?:([+-]\d\d)(\d\d)))$/;function O(e){let t,[,r,s,o,i,l,c,u,m,d,p,h]=e,f=C(r,i,o,s,l,c,u);return t=m?A[m]:d?0:(0,n.gu)(p,h),[f,new a.A(t)]}let M=/^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d\d) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d\d):(\d\d):(\d\d) GMT$/,N=/^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d\d)-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d\d) (\d\d):(\d\d):(\d\d) GMT$/,D=/^(Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( \d|\d\d) (\d\d):(\d\d):(\d\d) (\d{4})$/;function R(e){let[,t,r,n,s,o,i,l]=e;return[C(t,s,n,r,o,i,l),a.A.utcInstance]}function L(e){let[,t,r,n,s,o,i,l]=e;return[C(t,l,r,n,s,o,i),a.A.utcInstance]}let F=l(/([+-]\d{6}|\d{4})(?:-?(\d\d)(?:-?(\d\d))?)?/,g),P=l(/(\d{4})-?W(\d\d)(?:-?(\d))?/,g),q=l(/(\d{4})-?(\d{3})/,g),z=l(f),$=c(function(e,t){return[{year:_(e,t),month:_(e,t+1,1),day:_(e,t+2,1)},null,t+3]},w,x,S),U=c(y,w,x,S),B=c(b,w,x,S),W=c(w,x,S);function H(e){return u(e,[F,$],[P,U],[q,B],[z,W])}function V(e){return u(e.replace(/\([^()]*\)|[\n\t]/g," ").replace(/(\s\s+)/g," ").trim(),[I,O])}function Y(e){return u(e,[M,R],[N,R],[D,L])}function G(e){return u(e,[j,T])}let J=c(w);function Z(e){return u(e,[E,J])}let K=l(/(\d{4})-(\d\d)-(\d\d)/,v),X=l(k),Q=c(w,x,S);function ee(e){return u(e,[K,$],[X,Q])}},733477(e,t,r){"use strict";r.d(t,{u:()=>s});class s{#e;#t=new Map;constructor(e,t={},r=2e4){for(let[r,n]of(this.#e=e,Object.entries(t))){let e=new Map;for(let t of n){let n=[],s=(...e)=>{n.push(e)};this.#r(r,t).addListener(s),e.set(t,{listener:s,args:n})}this.#t.set(r,e)}this.#n(r)}#n(e){n(()=>{for(let[t,r]of this.#t)for(let[n,{args:s}]of r)console.warn(`ExtensionLazyListener: Possible memory leak detected. The event "${t}.${n}" has been listened to, but no application code has added a listener after ${e}ms. There are currently ${s.length} buffered calls. If you are a developer of this extension, please ensure that you have added a listener for this event. If you are a user of this extension, please report this warning to the developers of the extension.`)},e)}#r(e,t){return this.#e[e][t]}addListener(e,t,r){let n=this.#r(e,t);n.addListener(r);let s=this.#t.get(e);if(s){let a=s.get(t);if(a){n.removeListener(a.listener),s.delete(t),0===s.size&&this.#t.delete(e);let{args:o}=a;for(let i=0,{length:l}=o;i<l;i++)try{if(r(...o[i]),!n.hasListener(r)){let r=i+1;r!==l&&(o.splice(0,r),s.set(t,a),this.#t.set(e,s),n.addListener(a.listener));break}}catch(c){let r=i+1;throw r!==l&&(o.splice(0,r),s.set(t,a),this.#t.set(e,s),n.addListener(a.listener)),c}}}}once(e,t){return new Promise(r=>{let n=this.#r(e,t),s=this.#t.get(e);if(s){let a=s.get(t),o=a?.args.length;if(o){r(a.args.shift()),n.removeListener(a.listener),1===o&&(s.delete(t),0===s.size&&this.#t.delete(e));return}}let a=(...e)=>{n.removeListener(a),r(e)};n.addListener(a)})}}},747402(e,t,r){"use strict";r.d(t,{q:()=>a});var n=r(803537),s=r(884488);let a={increment:function(e,t=1,r){n.q.increment(s.v,e,t,r)},distribution:function(e,t,r){n.q.distribution(s.v,e,t,r)},set:function(e,t,r){n.q.set(s.v,e,t,r)},gauge:function(e,t,r){n.q.gauge(s.v,e,t,r)},timing:function(e,t,r="second",a){return n.q.timing(s.v,e,t,r,a)}}},756025(e,t,r){"use strict";r.d(t,{T:()=>n});let n="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__},764651(e,t,r){"use strict";r.d(t,{r:()=>f});var n=r(12796),s=r(956742),a=r(495242),o=r(898026),i=r(259463),l=r(863531),c=r(681747);let u=[200,500],m=()=>(0,l.O)()-0,d=[],p={},h=e=>{let t=d[d.length-1],r=p[e.interactionId];if(r||d.length<10||t&&e.duration>t.latency){if(r)r.entries.push(e),r.latency=Math.max(r.latency,e.duration);else{let t={id:e.interactionId,latency:e.duration,entries:[e]};p[t.id]=t,d.push(t)}d.sort((e,t)=>t.latency-e.latency),d.splice(10).forEach(e=>{delete p[e.id]})}},f=(e,t={})=>{(0,c.I)(()=>{let r;(0,l.D)();let c=(0,a.X)("INP"),p=e=>{e.forEach(e=>{e.interactionId&&h(e),"first-input"===e.entryType&&(d.some(t=>t.entries.some(t=>e.duration===t.duration&&e.startTime===t.startTime))||h(e))});let t=(()=>{let e=Math.min(d.length-1,Math.floor(m()/50));return d[e]})();t&&t.latency!==c.value&&(c.value=t.latency,c.entries=t.entries,r())},f=(0,o.l)("event",p,{durationThreshold:null!=t.durationThreshold?t.durationThreshold:40});r=(0,s.R)(e,c,u,t.reportAllChanges),f&&("PerformanceEventTiming"in n.j&&"interactionId"in PerformanceEventTiming.prototype&&f.observe({type:"first-input",buffered:!0}),(0,i.Q)(()=>{p(f.takeRecords()),c.value<0&&m()>0&&(c.value=0,c.entries=[]),r(!0)}))})}},766221(e,t,r){"use strict";r.d(t,{C:()=>i});var a=r(16786),o=r(586312);function i(e){let t=[];function r(e){return t.splice(t.indexOf(e),1)[0]||Promise.resolve(void 0)}return{$:t,add:function(n){if(!(void 0===e||t.length<e))return(0,o.xg)(new a.U("Not adding Promise because buffer limit was reached."));let s=n();return -1===t.indexOf(s)&&t.push(s),s.then(()=>r(s)).then(null,()=>r(s).then(null,()=>{})),s},drain:function(e){return new o.T2((r,a)=>{let i=t.length;if(!i)return r(!0);let l=n(()=>{e&&e>0&&r(!1)},e);t.forEach(e=>{(0,o.XW)(e).then(()=>{--i||(s(l),r(!0))},a)})})}}}},768881(e,t,r){"use strict";r.d(t,{i:()=>a});var n=r(107842),s=r(67904);function a(e){if("boolean"==typeof e)return Number(e);let t="string"==typeof e?parseFloat(e):e;if("number"!=typeof t||isNaN(t)||t<0||t>1){s.T&&n.vF.warn(`[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(e)} of type ${JSON.stringify(typeof e)}.`);return}return t}},777217(e,t,r){"use strict";r.d(t,{w:()=>s});var n=r(933190);function s(e){if("boolean"==typeof __SENTRY_TRACING__&&!__SENTRY_TRACING__)return!1;let t=(0,n.KU)(),r=e||t&&t.getOptions();return!!r&&(r.enableTracing||"tracesSampleRate"in r||"tracesSampler"in r)}},793111(e,t,r){"use strict";r.d(t,{Cp:()=>u,Dp:()=>w,J0:()=>S,J5:()=>T,NA:()=>y,Q:()=>k,SA:()=>x,VN:()=>_,Wt:()=>g,bX:()=>v,cx:()=>h,gV:()=>b,ky:()=>E,l7:()=>f,o:()=>p,r:()=>d,wd:()=>m});var n=r(230337),s=r(107842),a=r(276277),o=r(933190),i=r(67904),l=r(597014),c=r(884405);function u(e,t){return(0,o.o5)().captureException(e,(0,c.li)(t))}function m(e,t){let r="string"==typeof t?t:void 0,n="string"!=typeof t?{captureContext:t}:void 0;return(0,o.o5)().captureMessage(e,r,n)}function d(e,t){return(0,o.o5)().captureEvent(e,t)}function p(e,t){(0,o.rm)().setContext(e,t)}function h(e){(0,o.rm)().setExtras(e)}function f(e,t){(0,o.rm)().setExtra(e,t)}function g(e){(0,o.rm)().setTags(e)}function y(e,t){(0,o.rm)().setTag(e,t)}function b(e){(0,o.rm)().setUser(e)}function k(){return(0,o.rm)().lastEventId()}async function v(e){let t=(0,o.KU)();return t?t.flush(e):(i.T&&s.vF.warn("Cannot flush events. No client defined."),Promise.resolve(!1))}async function _(e){let t=(0,o.KU)();return t?t.close(e):(i.T&&s.vF.warn("Cannot flush events and disable SDK. No client defined."),Promise.resolve(!1))}function w(){return!!(0,o.KU)()}function x(e){(0,o.rm)().addEventProcessor(e)}function S(e){let t=(0,o.KU)(),r=(0,o.rm)(),s=(0,o.o5)(),{release:i,environment:c=a.U}=t&&t.getOptions()||{},{userAgent:u}=n.O.navigator||{},m=(0,l.fj)({release:i,environment:c,user:s.getUser()||r.getUser(),...u&&{userAgent:u},...e}),d=r.getSession();return d&&"ok"===d.status&&(0,l.qO)(d,{status:"exited"}),E(),r.setSession(m),s.setSession(m),m}function E(){let e=(0,o.rm)(),t=(0,o.o5)(),r=t.getSession()||e.getSession();r&&(0,l.Vu)(r),j(),e.setSession(),t.setSession()}function j(){let e=(0,o.rm)(),t=(0,o.o5)(),r=(0,o.KU)(),n=t.getSession()||e.getSession();n&&r&&r.captureSession(n)}function T(e=!1){if(e)return void E();j()}},794204(e,t,r){"use strict";r.d(t,{A:()=>o});var n=r(316244),s=r(283707);let a=null;class o extends s.A{static get utcInstance(){return null===a&&(a=new o(0)),a}static instance(e){return 0===e?o.utcInstance:new o(e)}static parseSpecifier(e){if(e){let t=e.match(/^utc(?:([+-]\d{1,2})(?::(\d{2}))?)?$/i);if(t)return new o((0,n.gu)(t[1],t[2]))}return null}constructor(e){super(),this.fixed=e}get type(){return"fixed"}get name(){return 0===this.fixed?"UTC":`UTC${(0,n.xS)(this.fixed,"narrow")}`}get ianaName(){return 0===this.fixed?"Etc/UTC":`Etc/GMT${(0,n.xS)(-this.fixed,"narrow")}`}offsetName(){return this.name}formatOffset(e,t){return(0,n.xS)(this.fixed,t)}get isUniversal(){return!0}offset(){return this.fixed}equals(e){return"fixed"===e.type&&e.fixed===this.fixed}get isValid(){return!0}}},799130(e,t,r){"use strict";function n(e,t){return null!=e?e:t()}r.d(t,{S:()=>n})},803537(e,t,r){"use strict";r.d(t,{q:()=>f});var n=r(230337),s=r(107842),a=r(37853),o=r(933190),i=r(67904),l=r(608119),c=r(16686),u=r(267276),m=r(137891);function d(e,t){let r=(0,n.B)("globalMetricsAggregators",()=>new WeakMap),s=r.get(e);if(s)return s;let a=new t(e);return e.on("flush",()=>a.flush()),e.on("close",()=>a.close()),r.set(e,a),a}function p(e,t,r,n,a={}){let c=a.client||(0,o.KU)();if(!c)return;let u=(0,l.Bk)(),m=u?(0,l.zU)(u):void 0,h=m&&(0,l.et)(m).description,{unit:f,tags:g,timestamp:y}=a,{release:b,environment:k}=c.getOptions(),v={};b&&(v.release=b),k&&(v.environment=k),h&&(v.transaction=h),i.T&&s.vF.log(`Adding value of ${n} to ${t} metric ${r}`),d(c,e).add(t,r,n,f,{...v,...g},y)}function h(e,t,r,n){p(e,m.vR,t,g(r),n)}let f={increment:function(e,t,r=1,n){p(e,m.bD,t,g(r),n)},distribution:h,set:function(e,t,r,n){p(e,m.fN,t,r,n)},gauge:function(e,t,r,n){p(e,m.co,t,g(r),n)},timing:function(e,t,r,n="second",s){if("function"==typeof r){let n=(0,a.zf)();return(0,c.nV)({op:"metrics.timing",name:t,startTime:n,onlyIfParent:!0},o=>(0,u.x)(()=>r(),()=>{},()=>{let r=(0,a.zf)();h(e,t,r-n,{...s,unit:"second"}),o.end(r)}))}h(e,t,r,{...s,unit:n})},getMetricsAggregatorForClient:d};function g(e){return"string"==typeof e?parseInt(e):e}},808106(e,t,r){"use strict";r.d(t,{D:()=>a});var n=r(230337),s=r(450579);let a=(0,r(290264)._C)((e={})=>{let t=e.root,r=e.prefix||"app:///",a="window"in n.O&&void 0!==n.O.window,o=e.iteratee||function({isBrowser:e,root:t,prefix:r}){return n=>{if(!n.filename)return n;let a=/^[a-zA-Z]:\\/.test(n.filename)||n.filename.includes("\\")&&!n.filename.includes("/"),o=/^\//.test(n.filename);if(e){if(t){let e=n.filename;0===e.indexOf(t)&&(n.filename=e.replace(t,r))}}else if(a||o){let e=a?n.filename.replace(/^[a-zA-Z]:/,"").replace(/\\/g,"/"):n.filename,o=t?(0,s.V8)(t,e):(0,s.P8)(e);n.filename=`${r}${o}`}return n}}({isBrowser:a,root:t,prefix:r});return{name:"RewriteFrames",processEvent(e){let t=e;return e.exception&&Array.isArray(e.exception.values)&&(t=function(e){try{return{...e,exception:{...e.exception,values:e.exception.values.map(e=>{var t;return{...e,...e.stacktrace&&{stacktrace:{...t=e.stacktrace,frames:t&&t.frames&&t.frames.map(e=>o(e))}}}})}}}catch(t){return e}}(t)),t}}})},812805(e,t,r){"use strict";var n,s;function a(e){return!!e&&"object"==typeof e&&!Array.isArray(e)}r.d(t,{Gv:()=>a,Qd:()=>i,i5:()=>o});let o=(e,t)=>Object.hasOwnProperty.call(e,t);function i(e){if("object"!=typeof e||null===e)return!1;try{let t=e;for(;null!==Object.getPrototypeOf(t);)t=Object.getPrototypeOf(t);return Object.getPrototypeOf(e)===t}catch(e){return!1}}(s=n=n||(n={}))[s.Null=4]="Null",s[s.Comma=1]="Comma",s[s.Wrapper=1]="Wrapper",s[s.True=4]="True",s[s.False=5]="False",s[s.Quote=1]="Quote",s[s.Colon=1]="Colon",s[s.Date=24]="Date"},812863(e,t,r){"use strict";r.d(t,{E1:()=>u,JD:()=>o,Sn:()=>l,fs:()=>i,i_:()=>n,jG:()=>m,sy:()=>s,uT:()=>a,xc:()=>c});let n="sentry.source",s="sentry.sample_rate",a="sentry.op",o="sentry.origin",i="sentry.idle_span_finish_reason",l="sentry.measurement_unit",c="sentry.measurement_value",u="sentry.profile_id",m="sentry.exclusive_time"},814006(e,t,r){"use strict";r.d(t,{Es:()=>p,rI:()=>m,ux:()=>d});var n,s,a=r(290266),o=r(545203),i=r(297564),l=r(728195);(n=s||(s={})).ButtonClickEvent="ButtonClickEvent",n.FormSubmitEvent="FormSubmitEvent",n.InputChangeEvent="InputChangeEvent",n.FileUploadEvent="FileUploadEvent";let c=(0,a.Ik)({type:(0,a.Yj)(),name:(0,a.lq)((0,a.Yj)())}),u=(0,o.kp)(c,(0,a.Ik)({type:(0,l.eu)(s.ButtonClickEvent),name:(0,a.lq)((0,a.Yj)())})),m=(0,a.Ik)({accountId:(0,a.Yj)(),addresses:(0,a.YO)(i.FX)}),d=(0,a.Ik)({name:(0,a.Yj)(),size:(0,a.ai)(),contentType:(0,a.Yj)(),contents:(0,a.Yj)()}),p=(0,a.Ik)({asset:i.jx,name:(0,a.Yj)(),symbol:(0,a.Yj)()}),h=(0,o.kp)(c,(0,a.Ik)({type:(0,l.eu)(s.FormSubmitEvent),value:(0,a.g1)((0,a.Yj)(),(0,a.me)((0,a.KC)([(0,a.Yj)(),d,(0,a.zM)(),m,p]))),name:(0,a.Yj)()})),f=(0,o.kp)(c,(0,a.Ik)({type:(0,l.eu)(s.InputChangeEvent),name:(0,a.Yj)(),value:(0,a.me)((0,a.KC)([(0,a.Yj)(),(0,a.zM)(),m,p]))})),g=(0,o.kp)(c,(0,a.Ik)({type:(0,l.eu)(s.FileUploadEvent),name:(0,a.Yj)(),file:(0,a.me)(d)}));(0,l.i5)([u,h,f,g])},818337(e,t,r){"use strict";r.d(t,{s:()=>s});var n=r(545203);function s(e,t){return(0,n.E8)(e,e=>"string"==typeof e&&t.test(e))}},818747(e,t,r){"use strict";r.d(t,{z:()=>d});var n=r(397718),s=r(198066),a=r(973234),o=r(16278);class i{constructor(e,t){let r,n;r=e||new a.H,n=t||new a.H,this._stack=[{scope:r}],this._isolationScope=n}withScope(e){let t,r=this._pushScope();try{t=e(r)}catch(e){throw this._popScope(),e}return(0,n.Qg)(t)?t.then(e=>(this._popScope(),e),e=>{throw this._popScope(),e}):(this._popScope(),t)}getClient(){return this.getStackTop().client}getScope(){return this.getStackTop().scope}getIsolationScope(){return this._isolationScope}getStackTop(){return this._stack[this._stack.length-1]}_pushScope(){let e=this.getScope().clone();return this._stack.push({client:this.getClient(),scope:e}),e}_popScope(){return!(this._stack.length<=1)&&!!this._stack.pop()}}function l(){let e=(0,o.E)(),t=(0,o.S)(e);return t.stack=t.stack||new i((0,s.r)(),(0,s.q)())}function c(e){return l().withScope(e)}function u(e,t){let r=l();return r.withScope(()=>(r.getStackTop().scope=e,t(e)))}function m(e){return l().withScope(()=>e(l().getIsolationScope()))}function d(){return{withIsolationScope:m,withScope:c,withSetScope:u,withSetIsolationScope:(e,t)=>m(t),getCurrentScope:()=>l().getScope(),getIsolationScope:()=>l().getIsolationScope()}}},821016(e,t,r){"use strict";r.d(t,{B$:()=>d,ur:()=>m});var a=r(397718),o=r(97407),i=r(388006),l=r(37853),c=r(230337),u=r(25605);function m(e,t){let r="fetch";(0,u.s5)(r,e),(0,u.AS)(r,()=>p(void 0,t))}function d(e){let t="fetch-body-resolved";(0,u.s5)(t,e),(0,u.AS)(t,()=>p(f))}function p(e,t=!1){(!t||(0,i.m7)())&&(0,o.GS)(c.O,"fetch",function(t){return function(...r){let{method:n,url:s}=function(e){if(0===e.length)return{method:"GET",url:""};if(2===e.length){let[t,r]=e;return{url:y(t),method:g(r,"method")?String(r.method).toUpperCase():"GET"}}let t=e[0];return{url:y(t),method:g(t,"method")?String(t.method).toUpperCase():"GET"}}(r),i={args:r,fetchData:{method:n,url:s},startTimestamp:1e3*(0,l.zf)()};e||(0,u.aj)("fetch",{...i});let m=Error().stack;return t.apply(c.O,r).then(async t=>(e?e(t):(0,u.aj)("fetch",{...i,endTimestamp:1e3*(0,l.zf)(),response:t}),t),e=>{throw(0,u.aj)("fetch",{...i,endTimestamp:1e3*(0,l.zf)(),error:e}),(0,a.bJ)(e)&&void 0===e.stack&&(e.stack=m,(0,o.my)(e,"framesToPop",1)),e})}})}async function h(e,t){if(e&&e.body){let r=e.body,a=r.getReader(),o=n(()=>{r.cancel().then(null,()=>{})},9e4),i=!0;for(;i;){let e;try{e=n(()=>{r.cancel().then(null,()=>{})},5e3);let{done:o}=await a.read();s(e),o&&(t(),i=!1)}catch(e){i=!1}finally{s(e)}}s(o),a.releaseLock(),r.cancel().then(null,()=>{})}}function f(e){let t;try{t=e.clone()}catch(e){return}h(t,()=>{(0,u.aj)("fetch-body-resolved",{endTimestamp:1e3*(0,l.zf)(),response:e})})}function g(e,t){return!!e&&"object"==typeof e&&!!e[t]}function y(e){return"string"==typeof e?e:e?g(e,"url")?e.url:e.toString?e.toString():"":""}},821213(e,t,r){"use strict";r.d(t,{C9:()=>p,De:()=>k,EG:()=>v,WF:()=>b,WO:()=>h,_3:()=>y,d3:()=>f,fZ:()=>g,mK:()=>c,nM:()=>_,ui:()=>d});var n=r(316244),s=r(446655),a=r(961520);let o=[0,31,59,90,120,151,181,212,243,273,304,334],i=[0,31,60,91,121,152,182,213,244,274,305,335];function l(e,t){return new s.A("unit out of range",`you specified ${t} (of type ${typeof t}) as a ${e}, which is invalid`)}function c(e,t,r){let n=new Date(Date.UTC(e,t-1,r));e<100&&e>=0&&n.setUTCFullYear(n.getUTCFullYear()-1900);let s=n.getUTCDay();return 0===s?7:s}function u(e,t,r){return r+((0,n.U_)(e)?i:o)[t-1]}function m(e,t){let r=(0,n.U_)(e)?i:o,s=r.findIndex(e=>e<t),a=t-r[s];return{month:s+1,day:a}}function d(e,t){return(e-t+7)%7+1}function p(e,t=4,r=1){let{year:s,month:a,day:o}=e,i=u(s,a,o),l=d(c(s,a,o),r),m=Math.floor((i-l+14-t)/7),h;return m<1?(h=s-1,m=(0,n.ac)(h,t,r)):m>(0,n.ac)(s,t,r)?(h=s+1,m=1):h=s,{weekYear:h,weekNumber:m,weekday:l,...(0,n.B9)(e)}}function h(e,t=4,r=1){let{weekYear:s,weekNumber:a,weekday:o}=e,i=d(c(s,1,t),r),l=(0,n.Ki)(s),u=7*a+o-i-7+t,p;u<1?(p=s-1,u+=(0,n.Ki)(p)):u>l?(p=s+1,u-=(0,n.Ki)(s)):p=s;let{month:f,day:g}=m(p,u);return{year:p,month:f,day:g,...(0,n.B9)(e)}}function f(e){let{year:t,month:r,day:s}=e,a=u(t,r,s);return{year:t,ordinal:a,...(0,n.B9)(e)}}function g(e){let{year:t,ordinal:r}=e,{month:s,day:a}=m(t,r);return{year:t,month:s,day:a,...(0,n.B9)(e)}}function y(e,t){if(!(!(0,n.b0)(e.localWeekday)||!(0,n.b0)(e.localWeekNumber)||!(0,n.b0)(e.localWeekYear)))return{minDaysInFirstWeek:4,startOfWeek:1};if(!(0,n.b0)(e.weekday)||!(0,n.b0)(e.weekNumber)||!(0,n.b0)(e.weekYear))throw new a.gN("Cannot mix locale-based week fields with ISO-based week fields");return(0,n.b0)(e.localWeekday)||(e.weekday=e.localWeekday),(0,n.b0)(e.localWeekNumber)||(e.weekNumber=e.localWeekNumber),(0,n.b0)(e.localWeekYear)||(e.weekYear=e.localWeekYear),delete e.localWeekday,delete e.localWeekNumber,delete e.localWeekYear,{minDaysInFirstWeek:t.getMinDaysInFirstWeek(),startOfWeek:t.getStartOfWeek()}}function b(e,t=4,r=1){let s=(0,n.Fq)(e.weekYear),a=(0,n.f8)(e.weekNumber,1,(0,n.ac)(e.weekYear,t,r)),o=(0,n.f8)(e.weekday,1,7);return s?a?!o&&l("weekday",e.weekday):l("week",e.weekNumber):l("weekYear",e.weekYear)}function k(e){let t=(0,n.Fq)(e.year),r=(0,n.f8)(e.ordinal,1,(0,n.Ki)(e.year));return t?!r&&l("ordinal",e.ordinal):l("year",e.year)}function v(e){let t=(0,n.Fq)(e.year),r=(0,n.f8)(e.month,1,12),s=(0,n.f8)(e.day,1,(0,n.L3)(e.year,e.month));return t?r?!s&&l("day",e.day):l("month",e.month):l("year",e.year)}function _(e){let{hour:t,minute:r,second:s,millisecond:a}=e,o=(0,n.f8)(t,0,23)||24===t&&0===r&&0===s&&0===a,i=(0,n.f8)(r,0,59),c=(0,n.f8)(s,0,59),u=(0,n.f8)(a,0,999);return o?i?c?!u&&l("millisecond",a):l("second",s):l("minute",r):l("hour",t)}},823803(e){let t=globalThis.chrome?.runtime.getManifest()||globalThis.browser?.runtime.getManifest(),r=!t||3===t.manifest_version,n=!!globalThis.chrome?.offscreen;e.exports={isManifestV3:r,isOffscreenAvailable:n,isMv3ButOffscreenDocIsMissing:r&&!n}},830339(e,t,r){"use strict";function n(e){if(!e)return{};let t=e.match(/^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/);if(!t)return{};let r=t[6]||"",n=t[8]||"";return{host:t[4],path:t[5],protocol:t[2],search:r,hash:n,relative:t[5]+r+n}}function s(e){return e.split(/[?#]/,1)[0]}r.d(t,{Dl:()=>n,f:()=>s})},831022(e,t,r){"use strict";r.d(t,{A:()=>l});var n=r(316244),s=r(283707);let a={},o={year:0,month:1,day:2,era:3,hour:4,minute:5,second:6},i={};class l extends s.A{static create(e){return i[e]||(i[e]=new l(e)),i[e]}static resetCache(){i={},a={}}static isValidSpecifier(e){return this.isValidZone(e)}static isValidZone(e){if(!e)return!1;try{return new Intl.DateTimeFormat("en-US",{timeZone:e}).format(),!0}catch(e){return!1}}constructor(e){super(),this.zoneName=e,this.valid=l.isValidZone(e)}get type(){return"iana"}get name(){return this.zoneName}get isUniversal(){return!1}offsetName(e,{format:t,locale:r}){return(0,n.wG)(e,t,r,this.name)}formatOffset(e,t){return(0,n.xS)(this.offset(e),t)}offset(e){var t;let r=new Date(e);if(isNaN(r))return NaN;let s=(a[t=this.name]||(a[t]=new Intl.DateTimeFormat("en-US",{hour12:!1,timeZone:t,year:"numeric",month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",second:"2-digit",era:"short"})),a[t]),[i,l,c,u,m,d,p]=s.formatToParts?function(e,t){let r=e.formatToParts(t),s=[];for(let e=0;e<r.length;e++){let{type:t,value:a}=r[e],i=o[t];"era"===t?s[i]=a:(0,n.b0)(i)||(s[i]=parseInt(a,10))}return s}(s,r):function(e,t){let r=e.format(t).replace(/\u200E/g,""),[,n,s,a,o,i,l,c]=/(\d+)\/(\d+)\/(\d+) (AD|BC),? (\d+):(\d+):(\d+)/.exec(r);return[a,n,s,o,i,l,c]}(s,r);"BC"===u&&(i=-Math.abs(i)+1);let h=(0,n.JZ)({year:i,month:l,day:c,hour:24===m?0:m,minute:d,second:p,millisecond:0}),f=+r,g=f%1e3;return(h-(f-=g>=0?g:1e3+g))/6e4}equals(e){return"iana"===e.type&&e.name===this.name}get isValid(){return this.valid}}},833399(e,t,r){"use strict";r.d(t,{_g:()=>l,j6:()=>o,s1:()=>i});var n=r(652825),s=r(290266),a=r(297564);let o=(0,n.YP)((0,s.YO)(a.FX),"Non-EIP-155 Matching Addresses Account ID List",e=>{let t=e.map(e=>(0,a.Dz)(e));return t.every(({address:e,chain:{namespace:r}})=>e===t[0].address&&r===t[0].chain.namespace)?!t.some(({chain:{namespace:e}})=>e===a.wV.Eip155)||"All account IDs must have non-EIP-155 namespaces.":"All account IDs must have the same address and namespace."}),i=(0,n.YP)(a.dg,"Non-EIP-155 Chain ID",e=>{let{namespace:t}=(0,a.rW)(e);return t!==a.wV.Eip155||"Chain ID must not be an EIP-155 chain ID."}),l=(0,n.YP)(a.jx,"Non-EIP-155 Asset Type",e=>{let{chain:{namespace:t}}=(0,a.Ts)(e);return t!==a.wV.Eip155||"Asset type must not be an EIP-155 asset type."})},833414(e,t,r){"use strict";r.d(t,{W:()=>u});var n=r(290266),s=r(545203),a=r(984524),o=r(988068),i=r(728195),l=r(157392);let c=(0,n.KC)([o.y,a.s3]),u=(0,s.kp)(l.Wu,(0,n.Ik)({type:(0,i.eu)(l.Z6.Form),children:(0,n.YO)(c),name:(0,n.Yj)()}))},834028(e,t,r){"use strict";r.d(t,{$N:()=>o,Hd:()=>a,NX:()=>i,xE:()=>l});var n=r(397718);let s=r(230337).O;function a(e,t={}){if(!e)return"<unknown>";try{let r,a=e,o=[],i=0,l=0,c=Array.isArray(t)?t:t.keyAttrs,u=!Array.isArray(t)&&t.maxStringLength||80;for(;a&&i++<5&&(r=function(e,t){let r=[];if(!e||!e.tagName)return"";if(s.HTMLElement&&e instanceof HTMLElement&&e.dataset){if(e.dataset.sentryComponent)return e.dataset.sentryComponent;if(e.dataset.sentryElement)return e.dataset.sentryElement}r.push(e.tagName.toLowerCase());let a=t&&t.length?t.filter(t=>e.getAttribute(t)).map(t=>[t,e.getAttribute(t)]):null;if(a&&a.length)a.forEach(e=>{r.push(`[${e[0]}="${e[1]}"]`)});else{e.id&&r.push(`#${e.id}`);let t=e.className;if(t&&(0,n.Kg)(t))for(let e of t.split(/\s+/))r.push(`.${e}`)}for(let t of["aria-label","type","name","title","alt"]){let n=e.getAttribute(t);n&&r.push(`[${t}="${n}"]`)}return r.join("")}(a,c),"html"!==r&&(!(i>1)||!(l+3*o.length+r.length>=u)));)o.push(r),l+=r.length,a=a.parentNode;return o.reverse().join(" > ")}catch(e){return"<unknown>"}}function o(){try{return s.document.location.href}catch(e){return""}}function i(e){return s.document&&s.document.querySelector?s.document.querySelector(e):null}function l(e){if(!s.HTMLElement)return null;let t=e;for(let e=0;e<5&&t;e++){if(t instanceof HTMLElement){if(t.dataset.sentryComponent)return t.dataset.sentryComponent;if(t.dataset.sentryElement)return t.dataset.sentryElement}t=t.parentNode}return null}},834529(e,t,r){"use strict";function n(e){let t,r=e[0],n=1;for(;n<e.length;){let s=e[n],a=e[n+1];if(n+=2,("optionalAccess"===s||"optionalCall"===s)&&null==r)return;"access"===s||"optionalAccess"===s?(t=r,r=a(r)):("call"===s||"optionalCall"===s)&&(r=a((...e)=>r.call(t,...e)),t=void 0)}return r}r.d(t,{z:()=>n})},834669(e,t,r){"use strict";r.d(t,{A:()=>a});var n=r(659008),s=r(123628);let a=function(e,t,r){var a=(e=e||{}).random||(e.rng||n.A)();if(a[6]=15&a[6]|64,a[8]=63&a[8]|128,t){r=r||0;for(var o=0;o<16;++o)t[r+o]=a[o];return t}return(0,s.A)(a)}},836164(e,t,r){"use strict";r.d(t,{HW:()=>h,LZ:()=>m,k1:()=>p,lF:()=>d});var n=r(97407),s=r(644094),a=r(276277),o=r(933190),i=r(812863),l=r(777217),c=r(608119);let u="_frozenDsc";function m(e,t){(0,n.my)(e,u,t)}function d(e,t){let r=t.getOptions(),{publicKey:s}=t.getDsn()||{},o=(0,n.Ce)({environment:r.environment||a.U,release:r.release,public_key:s,trace_id:e});return t.emit("createDsc",o),o}function p(e){let t=(0,o.KU)();if(!t)return{};let r=d((0,c.et)(e).trace_id||"",t),n=(0,c.zU)(e),a=n[u];if(a)return a;let m=n.spanContext().traceState,p=m&&m.get("sentry.dsc"),h=p&&(0,s.yD)(p);if(h)return h;let f=(0,c.et)(n),g=f.data||{},y=g[i.sy];null!=y&&(r.sample_rate=`${y}`);let b=g[i.i_],k=f.description;return"url"!==b&&k&&(r.transaction=k),(0,l.w)()&&(r.sampled=String((0,c.pK)(n))),t.emit("createDsc",r,n),r}function h(e){let t=p(e);return(0,s.De)(t)}},837075(e,t,r){"use strict";r.d(t,{t:()=>s});let n=["fatal","error","warning","log","info","debug"];function s(e){return"warn"===e?"warning":n.includes(e)?e:"log"}},837971(e,t,r){"use strict";r.d(t,{Mz:()=>i,T3:()=>l,VZ:()=>u,eG:()=>s,ik:()=>o,tx:()=>a});var n=r(97407);function s(e,t,r,s){let a=Object.entries((0,n.Ce)(s)).sort((e,t)=>e[0].localeCompare(t[0]));return`${e}${t}${r}${a}`}function a(e){let t=0;for(let r=0;r<e.length;r++)t=(t<<5)-t+e.charCodeAt(r),t&=t;return t>>>0}function o(e){let t="";for(let r of e){let e=Object.entries(r.tags),n=e.length>0?`|#${e.map(([e,t])=>`${e}:${t}`).join(",")}`:"";t+=`${r.name}@${r.unit}:${r.metric}|${r.metricType}${n}|T${r.timestamp}
`}return t}function i(e){return e.replace(/[^\w]+/gi,"_")}function l(e){return e.replace(/[^\w\-.]+/gi,"_")}let c=[[`
`,"\\n"],["\r","\\r"],["	","\\t"],["\\","\\\\"],["|","\\u{7c}"],[",","\\u{2c}"]];function u(e){let t={};for(let r in e)Object.prototype.hasOwnProperty.call(e,r)&&(t[r.replace(/[^\w\-./]+/gi,"")]=[...String(e[r])].reduce((e,t)=>e+function(e){for(let[t,r]of c)if(e===t)return r;return e}(t),""));return t}},845226(e,t,r){"use strict";r.d(t,{LV:()=>function e(t,r={},o){if("function"!=typeof t)return t;try{let e=t.__sentry_wrapped__;if(e)if("function"==typeof e)return e;else return t;if((0,l.sp)(t))return t}catch(e){return t}let c=function(){let l=Array.prototype.slice.call(arguments);try{o&&"function"==typeof o&&o.apply(this,arguments);let n=l.map(t=>e(t,r));return t.apply(this,n)}catch(e){throw u++,n(()=>{u--}),(0,a.v4)(t=>{t.addEventProcessor(e=>(r.mechanism&&((0,i.gO)(e,void 0,void 0),(0,i.M6)(e,r.mechanism)),e.extra={...e.extra,arguments:l},e)),(0,s.Cp)(e)}),e}};try{for(let e in t)Object.prototype.hasOwnProperty.call(t,e)&&(c[e]=t[e])}catch(e){}(0,l.pO)(c,t),(0,l.my)(t,"__sentry_wrapped__",c);try{Object.getOwnPropertyDescriptor(c,"name").configurable&&Object.defineProperty(c,"name",{get:()=>t.name})}catch(e){}return c},jN:()=>m,jf:()=>c});var s=r(793111),a=r(933190),o=r(230337),i=r(696294),l=r(97407);let c=o.O,u=0;function m(){return u>0}},848896(e,t,r){"use strict";r.d(t,{_:()=>a});var n=r(47810),s=r(871008);function a(e){return n._(e,async(...e)=>{let t=await (0,s.kS)();if(!t?.completedMetaMetricsOnboarding||!t.optedIn)throw Error("Network request skipped as metrics disabled");return await fetch(...e)})}},851338(e,t,r){"use strict";r.d(t,{wD:()=>a});var n=r(906769),s=r(208835);function a(){return!(0,n.Z)()&&"[object process]"===Object.prototype.toString.call(void 0!==s?s:0)}},851781(e,t,r){"use strict";r.d(t,{n:()=>u});var n=r(793111),s=r(933190),a=r(290264),o=r(230337),i=r(388006);let l=o.O,c=new WeakMap,u=(0,a._C)((e={})=>{let t=e.types||["crash","deprecation","intervention"];function r(e){if(c.has((0,s.KU)()))for(let t of e)(0,s.v4)(e=>{e.setExtra("url",t.url);let r=`ReportingObserver [${t.type}]`,s="No details available";if(t.body){let r={};for(let e in t.body)r[e]=t.body[e];if(e.setExtra("body",r),"crash"===t.type){let e=t.body;s=[e.crashId||"",e.reason||""].join(" ").trim()||s}else s=t.body.message||s}(0,n.wd)(`${r}: ${s}`)})}return{name:"ReportingObserver",setupOnce(){(0,i.vQ)()&&new l.ReportingObserver(r,{buffered:!0,types:t}).observe()},setup(e){c.set(e,!0)}}})},858586(e,t,r){"use strict";r.d(t,{D:()=>u,Kk:()=>i,Tn:()=>l,kD:()=>c,rv:()=>m});var n=r(16686),s=r(933190),a=r(608119),o=r(12796);function i(e){return"number"==typeof e&&isFinite(e)}function l(e,t,r,{...s}){let o=(0,a.et)(e).start_timestamp;return o&&o>t&&"function"==typeof e.updateStartTime&&e.updateStartTime(t),(0,n.hb)(e,()=>{let e=(0,n.Uk)({startTime:t,...s});return e&&e.end(r),e})}function c(e){let t,r=(0,s.KU)();if(!r)return;let{name:a,transaction:i,attributes:l,startTime:c}=e,{release:u,environment:m}=r.getOptions(),d=r.getIntegrationByName("Replay"),p=d&&d.getReplayId(),h=(0,s.o5)(),f=h.getUser(),g=void 0!==f?f.email||f.id||f.ip_address:void 0;try{t=h.getScopeData().contexts.profile.profile_id}catch(e){}let y={release:u,environment:m,user:g||void 0,profile_id:t||void 0,replay_id:p||void 0,transaction:i,"user_agent.original":o.j.navigator&&o.j.navigator.userAgent,...l};return(0,n.Uk)({name:a,attributes:y,startTime:c,experimental:{standalone:!0}})}function u(){return o.j&&o.j.addEventListener&&o.j.performance}function m(e){return e/1e3}},859340(e,t,r){var n;e=r.nmd(e),(function(){var s,a="Expected a function",i="__lodash_hash_undefined__",l="__lodash_placeholder__",c=1/0,u=0/0,m=[["ary",128],["bind",1],["bindKey",2],["curry",8],["curryRight",16],["flip",512],["partial",32],["partialRight",64],["rearg",256]],d="[object Arguments]",p="[object Array]",h="[object Boolean]",f="[object Date]",g="[object Error]",y="[object Function]",b="[object GeneratorFunction]",k="[object Map]",v="[object Number]",_="[object Object]",w="[object Promise]",x="[object RegExp]",S="[object Set]",E="[object String]",j="[object Symbol]",T="[object WeakMap]",A="[object ArrayBuffer]",C="[object DataView]",I="[object Float32Array]",O="[object Float64Array]",M="[object Int8Array]",N="[object Int16Array]",D="[object Int32Array]",R="[object Uint8Array]",L="[object Uint8ClampedArray]",F="[object Uint16Array]",P="[object Uint32Array]",q=/\b__p \+= '';/g,z=/\b(__p \+=) '' \+/g,$=/(__e\(.*?\)|\b__t\)) \+\n'';/g,U=/&(?:amp|lt|gt|quot|#39);/g,B=/[&<>"']/g,W=RegExp(U.source),H=RegExp(B.source),V=/<%-([\s\S]+?)%>/g,Y=/<%([\s\S]+?)%>/g,G=/<%=([\s\S]+?)%>/g,J=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,Z=/^\w*$/,K=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,X=/[\\^$.*+?()[\]{}|]/g,Q=RegExp(X.source),ee=/^\s+/,et=/\s/,er=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,en=/\{\n\/\* \[wrapped with (.+)\] \*/,es=/,? & /,ea=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,eo=/[()=,{}\[\]\/\s]/,ei=/\\(\\)?/g,el=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,ec=/\w*$/,eu=/^[-+]0x[0-9a-f]+$/i,em=/^0b[01]+$/i,ed=/^\[object .+?Constructor\]$/,ep=/^0o[0-7]+$/i,eh=/^(?:0|[1-9]\d*)$/,ef=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,eg=/($^)/,ey=/['\n\r\u2028\u2029\\]/g,eb="\ud800-\udfff",ek="\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff",ev="\\u2700-\\u27bf",e_="a-z\\xdf-\\xf6\\xf8-\\xff",ew="A-Z\\xc0-\\xd6\\xd8-\\xde",ex="\\ufe0e\\ufe0f",eS="\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",eE="['’]",ej="["+eS+"]",eT="["+ek+"]",eA="["+e_+"]",eC="[^"+eb+eS+"\\d+"+ev+e_+ew+"]",eI="\ud83c[\udffb-\udfff]",eO="[^"+eb+"]",eM="(?:\ud83c[\udde6-\uddff]){2}",eN="[\ud800-\udbff][\udc00-\udfff]",eD="["+ew+"]",eR="\\u200d",eL="(?:"+eA+"|"+eC+")",eF="(?:"+eD+"|"+eC+")",eP="(?:"+eE+"(?:d|ll|m|re|s|t|ve))?",eq="(?:"+eE+"(?:D|LL|M|RE|S|T|VE))?",ez="(?:"+eT+"|"+eI+")?",e$="["+ex+"]?",eU="(?:"+eR+"(?:"+[eO,eM,eN].join("|")+")"+e$+ez+")*",eB=e$+ez+eU,eW="(?:"+["["+ev+"]",eM,eN].join("|")+")"+eB,eH="(?:"+[eO+eT+"?",eT,eM,eN,"["+eb+"]"].join("|")+")",eV=RegExp(eE,"g"),eY=RegExp(eT,"g"),eG=RegExp(eI+"(?="+eI+")|"+eH+eB,"g"),eJ=RegExp([eD+"?"+eA+"+"+eP+"(?="+[ej,eD,"$"].join("|")+")",eF+"+"+eq+"(?="+[ej,eD+eL,"$"].join("|")+")",eD+"?"+eL+"+"+eP,eD+"+"+eq,"\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])|\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])|\\d+",eW].join("|"),"g"),eZ=RegExp("["+eR+eb+ek+ex+"]"),eK=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,eX=["Array","Buffer","DataView","Date","Error","Float32Array","Float64Array","Function","Int8Array","Int16Array","Int32Array","Map","Math","Object","Promise","RegExp","Set","String","Symbol","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","_","clearTimeout","isFinite","parseInt","setTimeout"],eQ=-1,e0={};e0[I]=e0[O]=e0[M]=e0[N]=e0[D]=e0[R]=e0[L]=e0[F]=e0[P]=!0,e0[d]=e0[p]=e0[A]=e0[h]=e0[C]=e0[f]=e0[g]=e0[y]=e0[k]=e0[v]=e0[_]=e0[x]=e0[S]=e0[E]=e0[T]=!1;var e1={};e1[d]=e1[p]=e1[A]=e1[C]=e1[h]=e1[f]=e1[I]=e1[O]=e1[M]=e1[N]=e1[D]=e1[k]=e1[v]=e1[_]=e1[x]=e1[S]=e1[E]=e1[j]=e1[R]=e1[L]=e1[F]=e1[P]=!0,e1[g]=e1[y]=e1[T]=!1;var e2={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},e3=parseFloat,e5=parseInt,e6="object"==typeof globalThis&&globalThis&&globalThis.Object===Object&&globalThis,e8="object"==typeof o&&o&&o.Object===Object&&o,e4=e6||e8||Function("return this")(),e9=t&&!t.nodeType&&t,e7=e9&&e&&!e.nodeType&&e,te=e7&&e7.exports===e9,tt=te&&e6.process,tr=function(){try{var e=e7&&e7.require&&e7.require("util").types;if(e)return e;return tt&&tt.binding&&tt.binding("util")}catch(e){}}(),tn=tr&&tr.isArrayBuffer,ts=tr&&tr.isDate,ta=tr&&tr.isMap,to=tr&&tr.isRegExp,ti=tr&&tr.isSet,tl=tr&&tr.isTypedArray;function tc(e,t,r){switch(r.length){case 0:return e.call(t);case 1:return e.call(t,r[0]);case 2:return e.call(t,r[0],r[1]);case 3:return e.call(t,r[0],r[1],r[2])}return e.apply(t,r)}function tu(e,t,r,n){for(var s=-1,a=null==e?0:e.length;++s<a;){var o=e[s];t(n,o,r(o),e)}return n}function tm(e,t){for(var r=-1,n=null==e?0:e.length;++r<n&&!1!==t(e[r],r,e););return e}function td(e,t){for(var r=-1,n=null==e?0:e.length;++r<n;)if(!t(e[r],r,e))return!1;return!0}function tp(e,t){for(var r=-1,n=null==e?0:e.length,s=0,a=[];++r<n;){var o=e[r];t(o,r,e)&&(a[s++]=o)}return a}function th(e,t){return!!(null==e?0:e.length)&&tS(e,t,0)>-1}function tf(e,t,r){for(var n=-1,s=null==e?0:e.length;++n<s;)if(r(t,e[n]))return!0;return!1}function tg(e,t){for(var r=-1,n=null==e?0:e.length,s=Array(n);++r<n;)s[r]=t(e[r],r,e);return s}function ty(e,t){for(var r=-1,n=t.length,s=e.length;++r<n;)e[s+r]=t[r];return e}function tb(e,t,r,n){var s=-1,a=null==e?0:e.length;for(n&&a&&(r=e[++s]);++s<a;)r=t(r,e[s],s,e);return r}function tk(e,t,r,n){var s=null==e?0:e.length;for(n&&s&&(r=e[--s]);s--;)r=t(r,e[s],s,e);return r}function tv(e,t){for(var r=-1,n=null==e?0:e.length;++r<n;)if(t(e[r],r,e))return!0;return!1}var t_=tA("length");function tw(e,t,r){var n;return r(e,function(e,r,s){if(t(e,r,s))return n=r,!1}),n}function tx(e,t,r,n){for(var s=e.length,a=r+(n?1:-1);n?a--:++a<s;)if(t(e[a],a,e))return a;return -1}function tS(e,t,r){return t==t?function(e,t,r){for(var n=r-1,s=e.length;++n<s;)if(e[n]===t)return n;return -1}(e,t,r):tx(e,tj,r)}function tE(e,t,r,n){for(var s=r-1,a=e.length;++s<a;)if(n(e[s],t))return s;return -1}function tj(e){return e!=e}function tT(e,t){var r=null==e?0:e.length;return r?tO(e,t)/r:u}function tA(e){return function(t){return null==t?s:t[e]}}function tC(e){return function(t){return null==e?s:e[t]}}function tI(e,t,r,n,s){return s(e,function(e,s,a){r=n?(n=!1,e):t(r,e,s,a)}),r}function tO(e,t){for(var r,n=-1,a=e.length;++n<a;){var o=t(e[n]);s!==o&&(r=s===r?o:r+o)}return r}function tM(e,t){for(var r=-1,n=Array(e);++r<e;)n[r]=t(r);return n}function tN(e){return e?e.slice(0,tJ(e)+1).replace(ee,""):e}function tD(e){return function(t){return e(t)}}function tR(e,t){return tg(t,function(t){return e[t]})}function tL(e,t){return e.has(t)}function tF(e,t){for(var r=-1,n=e.length;++r<n&&tS(t,e[r],0)>-1;);return r}function tP(e,t){for(var r=e.length;r--&&tS(t,e[r],0)>-1;);return r}var tq=tC({À:"A",Á:"A",Â:"A",Ã:"A",Ä:"A",Å:"A",à:"a",á:"a",â:"a",ã:"a",ä:"a",å:"a",Ç:"C",ç:"c",Ð:"D",ð:"d",È:"E",É:"E",Ê:"E",Ë:"E",è:"e",é:"e",ê:"e",ë:"e",Ì:"I",Í:"I",Î:"I",Ï:"I",ì:"i",í:"i",î:"i",ï:"i",Ñ:"N",ñ:"n",Ò:"O",Ó:"O",Ô:"O",Õ:"O",Ö:"O",Ø:"O",ò:"o",ó:"o",ô:"o",õ:"o",ö:"o",ø:"o",Ù:"U",Ú:"U",Û:"U",Ü:"U",ù:"u",ú:"u",û:"u",ü:"u",Ý:"Y",ý:"y",ÿ:"y",Æ:"Ae",æ:"ae",Þ:"Th",þ:"th",ß:"ss",Ā:"A",Ă:"A",Ą:"A",ā:"a",ă:"a",ą:"a",Ć:"C",Ĉ:"C",Ċ:"C",Č:"C",ć:"c",ĉ:"c",ċ:"c",č:"c",Ď:"D",Đ:"D",ď:"d",đ:"d",Ē:"E",Ĕ:"E",Ė:"E",Ę:"E",Ě:"E",ē:"e",ĕ:"e",ė:"e",ę:"e",ě:"e",Ĝ:"G",Ğ:"G",Ġ:"G",Ģ:"G",ĝ:"g",ğ:"g",ġ:"g",ģ:"g",Ĥ:"H",Ħ:"H",ĥ:"h",ħ:"h",Ĩ:"I",Ī:"I",Ĭ:"I",Į:"I",İ:"I",ĩ:"i",ī:"i",ĭ:"i",į:"i",ı:"i",Ĵ:"J",ĵ:"j",Ķ:"K",ķ:"k",ĸ:"k",Ĺ:"L",Ļ:"L",Ľ:"L",Ŀ:"L",Ł:"L",ĺ:"l",ļ:"l",ľ:"l",ŀ:"l",ł:"l",Ń:"N",Ņ:"N",Ň:"N",Ŋ:"N",ń:"n",ņ:"n",ň:"n",ŋ:"n",Ō:"O",Ŏ:"O",Ő:"O",ō:"o",ŏ:"o",ő:"o",Ŕ:"R",Ŗ:"R",Ř:"R",ŕ:"r",ŗ:"r",ř:"r",Ś:"S",Ŝ:"S",Ş:"S",Š:"S",ś:"s",ŝ:"s",ş:"s",š:"s",Ţ:"T",Ť:"T",Ŧ:"T",ţ:"t",ť:"t",ŧ:"t",Ũ:"U",Ū:"U",Ŭ:"U",Ů:"U",Ű:"U",Ų:"U",ũ:"u",ū:"u",ŭ:"u",ů:"u",ű:"u",ų:"u",Ŵ:"W",ŵ:"w",Ŷ:"Y",ŷ:"y",Ÿ:"Y",Ź:"Z",Ż:"Z",Ž:"Z",ź:"z",ż:"z",ž:"z",Ĳ:"IJ",ĳ:"ij",Œ:"Oe",œ:"oe",ŉ:"'n",ſ:"s"}),tz=tC({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"});function t$(e){return"\\"+e2[e]}function tU(e){return eZ.test(e)}function tB(e){var t=-1,r=Array(e.size);return e.forEach(function(e,n){r[++t]=[n,e]}),r}function tW(e,t){return function(r){return e(t(r))}}function tH(e,t){for(var r=-1,n=e.length,s=0,a=[];++r<n;){var o=e[r];(o===t||o===l)&&(e[r]=l,a[s++]=r)}return a}function tV(e){var t=-1,r=Array(e.size);return e.forEach(function(e){r[++t]=e}),r}function tY(e){return tU(e)?function(e){for(var t=eG.lastIndex=0;eG.test(e);)++t;return t}(e):t_(e)}function tG(e){return tU(e)?e.match(eG)||[]:e.split("")}function tJ(e){for(var t=e.length;t--&&et.test(e.charAt(t)););return t}var tZ=tC({"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"',"&#39;":"'"}),tK=function e(t){var r,n,o,et,eb=(t=null==t?e4:tK.defaults(e4.Object(),t,tK.pick(e4,eX))).Array,ek=t.Date,ev=t.Error,e_=t.Function,ew=t.Math,ex=t.Object,eS=t.RegExp,eE=t.String,ej=t.TypeError,eT=eb.prototype,eA=e_.prototype,eC=ex.prototype,eI=t["__core-js_shared__"],eO=eA.toString,eM=eC.hasOwnProperty,eN=0,eD=(r=/[^.]+$/.exec(eI&&eI.keys&&eI.keys.IE_PROTO||""))?"Symbol(src)_1."+r:"",eR=eC.toString,eL=eO.call(ex),eF=e4._,eP=eS("^"+eO.call(eM).replace(X,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),eq=te?t.Buffer:s,ez=t.Symbol,e$=t.Uint8Array,eU=eq?eq.allocUnsafe:s,eB=tW(ex.getPrototypeOf,ex),eW=ex.create,eH=eC.propertyIsEnumerable,eG=eT.splice,eZ=ez?ez.isConcatSpreadable:s,e2=ez?ez.iterator:s,e6=ez?ez.toStringTag:s,e8=function(){try{var e=sd(ex,"defineProperty");return e({},"",{}),e}catch(e){}}(),e9=t.clearTimeout!==e4.clearTimeout&&t.clearTimeout,e7=ek&&ek.now!==e4.Date.now&&ek.now,tt=t.setTimeout!==e4.setTimeout&&t.setTimeout,tr=ew.ceil,t_=ew.floor,tC=ex.getOwnPropertySymbols,tX=eq?eq.isBuffer:s,tQ=t.isFinite,t0=eT.join,t1=tW(ex.keys,ex),t2=ew.max,t3=ew.min,t5=ek.now,t6=t.parseInt,t8=ew.random,t4=eT.reverse,t9=sd(t,"DataView"),t7=sd(t,"Map"),re=sd(t,"Promise"),rt=sd(t,"Set"),rr=sd(t,"WeakMap"),rn=sd(ex,"create"),rs=rr&&new rr,ra={},ro=sF(t9),ri=sF(t7),rl=sF(re),rc=sF(rt),ru=sF(rr),rm=ez?ez.prototype:s,rd=rm?rm.valueOf:s,rp=rm?rm.toString:s;function rh(e){if(aV(e)&&!aR(e)&&!(e instanceof rb)){if(e instanceof ry)return e;if(eM.call(e,"__wrapped__"))return sP(e)}return new ry(e)}var rf=function(){function e(){}return function(t){if(!aH(t))return{};if(eW)return eW(t);e.prototype=t;var r=new e;return e.prototype=s,r}}();function rg(){}function ry(e,t){this.__wrapped__=e,this.__actions__=[],this.__chain__=!!t,this.__index__=0,this.__values__=s}function rb(e){this.__wrapped__=e,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=0xffffffff,this.__views__=[]}function rk(e){var t=-1,r=null==e?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}function rv(e){var t=-1,r=null==e?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}function r_(e){var t=-1,r=null==e?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}function rw(e){var t=-1,r=null==e?0:e.length;for(this.__data__=new r_;++t<r;)this.add(e[t])}function rx(e){var t=this.__data__=new rv(e);this.size=t.size}function rS(e,t){var r=aR(e),n=!r&&aD(e),s=!r&&!n&&aq(e),a=!r&&!n&&!s&&a0(e),o=r||n||s||a,i=o?tM(e.length,eE):[],l=i.length;for(var c in e)(t||eM.call(e,c))&&!(o&&("length"==c||s&&("offset"==c||"parent"==c)||a&&("buffer"==c||"byteLength"==c||"byteOffset"==c)||sk(c,l)))&&i.push(c);return i}function rE(e){var t=e.length;return t?e[nc(0,t-1)]:s}rh.templateSettings={escape:V,evaluate:Y,interpolate:G,variable:"",imports:{_:rh}},rh.prototype=rg.prototype,rh.prototype.constructor=rh,ry.prototype=rf(rg.prototype),ry.prototype.constructor=ry,rb.prototype=rf(rg.prototype),rb.prototype.constructor=rb,rk.prototype.clear=function(){this.__data__=rn?rn(null):{},this.size=0},rk.prototype.delete=function(e){var t=this.has(e)&&delete this.__data__[e];return this.size-=!!t,t},rk.prototype.get=function(e){var t=this.__data__;if(rn){var r=t[e];return r===i?s:r}return eM.call(t,e)?t[e]:s},rk.prototype.has=function(e){var t=this.__data__;return rn?t[e]!==s:eM.call(t,e)},rk.prototype.set=function(e,t){var r=this.__data__;return this.size+=+!this.has(e),r[e]=rn&&s===t?i:t,this},rv.prototype.clear=function(){this.__data__=[],this.size=0},rv.prototype.delete=function(e){var t=this.__data__,r=rA(t,e);return!(r<0)&&(r==t.length-1?t.pop():eG.call(t,r,1),--this.size,!0)},rv.prototype.get=function(e){var t=this.__data__,r=rA(t,e);return r<0?s:t[r][1]},rv.prototype.has=function(e){return rA(this.__data__,e)>-1},rv.prototype.set=function(e,t){var r=this.__data__,n=rA(r,e);return n<0?(++this.size,r.push([e,t])):r[n][1]=t,this},r_.prototype.clear=function(){this.size=0,this.__data__={hash:new rk,map:new(t7||rv),string:new rk}},r_.prototype.delete=function(e){var t=su(this,e).delete(e);return this.size-=!!t,t},r_.prototype.get=function(e){return su(this,e).get(e)},r_.prototype.has=function(e){return su(this,e).has(e)},r_.prototype.set=function(e,t){var r=su(this,e),n=r.size;return r.set(e,t),this.size+=+(r.size!=n),this},rw.prototype.add=rw.prototype.push=function(e){return this.__data__.set(e,i),this},rw.prototype.has=function(e){return this.__data__.has(e)};function rj(e,t,r){(s===r||aO(e[t],r))&&(s!==r||t in e)||rO(e,t,r)}function rT(e,t,r){var n=e[t];eM.call(e,t)&&aO(n,r)&&(s!==r||t in e)||rO(e,t,r)}function rA(e,t){for(var r=e.length;r--;)if(aO(e[r][0],t))return r;return -1}function rC(e,t,r,n){return rP(e,function(e,s,a){t(n,e,r(e),a)}),n}function rI(e,t){return e&&n$(t,od(t),e)}function rO(e,t,r){"__proto__"==t&&e8?e8(e,t,{configurable:!0,enumerable:!0,value:r,writable:!0}):e[t]=r}function rM(e,t){for(var r=-1,n=t.length,a=eb(n),o=null==e;++r<n;)a[r]=o?s:oi(e,t[r]);return a}function rN(e,t,r){return e==e&&(s!==r&&(e=e<=r?e:r),s!==t&&(e=e>=t?e:t)),e}function rD(e,t,r,n,a,o){var i,l=1&t,c=2&t,u=4&t;if(r&&(i=a?r(e,n,a,o):r(e)),s!==i)return i;if(!aH(e))return e;var m=aR(e);if(m){if(g=(p=e).length,w=new p.constructor(g),g&&"string"==typeof p[0]&&eM.call(p,"index")&&(w.index=p.index,w.input=p.input),i=w,!l)return nz(e,i)}else{var p,g,w,T,q,z,$,U,B=sf(e),W=B==y||B==b;if(aq(e))return nD(e,l);if(B==_||B==d||W&&!a){if(i=c||W?{}:sy(e),!l){return c?(T=e,q=(U=i)&&n$(e,op(e),U),n$(T,sh(T),q)):(z=e,$=rI(i,e),n$(z,sp(z),$))}}else{if(!e1[B])return a?e:{};i=function(e,t,r){var n,s,a=e.constructor;switch(t){case A:return nR(e);case h:case f:return new a(+e);case C:return n=r?nR(e.buffer):e.buffer,new e.constructor(n,e.byteOffset,e.byteLength);case I:case O:case M:case N:case D:case R:case L:case F:case P:return nL(e,r);case k:return new a;case v:case E:return new a(e);case x:return(s=new e.constructor(e.source,ec.exec(e))).lastIndex=e.lastIndex,s;case S:return new a;case j:return rd?ex(rd.call(e)):{}}}(e,B,l)}}o||(o=new rx);var H=o.get(e);if(H)return H;o.set(e,i),aK(e)?e.forEach(function(n){i.add(rD(n,t,r,n,e,o))}):aY(e)&&e.forEach(function(n,s){i.set(s,rD(n,t,r,s,e,o))});var V=u?c?sa:ss:c?op:od,Y=m?s:V(e);return tm(Y||e,function(n,s){Y&&(n=e[s=n]),rT(i,s,rD(n,t,r,s,e,o))}),i}function rR(e,t,r){var n=r.length;if(null==e)return!n;for(e=ex(e);n--;){var a=r[n],o=t[a],i=e[a];if(s===i&&!(a in e)||!o(i))return!1}return!0}function rL(e,t,r){if("function"!=typeof e)throw new ej(a);return sI(function(){e.apply(s,r)},t)}function rF(e,t,r,n){var s=-1,a=th,o=!0,i=e.length,l=[],c=t.length;if(!i)return l;r&&(t=tg(t,tD(r))),n?(a=tf,o=!1):t.length>=200&&(a=tL,o=!1,t=new rw(t));t:for(;++s<i;){var u=e[s],m=null==r?u:r(u);if(u=n||0!==u?u:0,o&&m==m){for(var d=c;d--;)if(t[d]===m)continue t;l.push(u)}else a(t,m,n)||l.push(u)}return l}rx.prototype.clear=function(){this.__data__=new rv,this.size=0},rx.prototype.delete=function(e){var t=this.__data__,r=t.delete(e);return this.size=t.size,r},rx.prototype.get=function(e){return this.__data__.get(e)},rx.prototype.has=function(e){return this.__data__.has(e)},rx.prototype.set=function(e,t){var r=this.__data__;if(r instanceof rv){var n=r.__data__;if(!t7||n.length<199)return n.push([e,t]),this.size=++r.size,this;r=this.__data__=new r_(n)}return r.set(e,t),this.size=r.size,this};var rP=nW(rV),rq=nW(rY,!0);function rz(e,t){var r=!0;return rP(e,function(e,n,s){return r=!!t(e,n,s)}),r}function r$(e,t,r){for(var n=-1,a=e.length;++n<a;){var o=e[n],i=t(o);if(null!=i&&(s===l?i==i&&!aQ(i):r(i,l)))var l=i,c=o}return c}function rU(e,t){var r=[];return rP(e,function(e,n,s){t(e,n,s)&&r.push(e)}),r}function rB(e,t,r,n,s){var a=-1,o=e.length;for(r||(r=sb),s||(s=[]);++a<o;){var i=e[a];t>0&&r(i)?t>1?rB(i,t-1,r,n,s):ty(s,i):n||(s[s.length]=i)}return s}var rW=nH(),rH=nH(!0);function rV(e,t){return e&&rW(e,t,od)}function rY(e,t){return e&&rH(e,t,od)}function rG(e,t){return tp(t,function(t){return aU(e[t])})}function rJ(e,t){t=nO(t,e);for(var r=0,n=t.length;null!=e&&r<n;)e=e[sL(t[r++])];return r&&r==n?e:s}function rZ(e,t,r){var n=t(e);return aR(e)?n:ty(n,r(e))}function rK(e){var t;return null==e?s===e?"[object Undefined]":"[object Null]":e6&&e6 in ex(e)?function(e){var t=eM.call(e,e6),r=e[e6];try{e[e6]=s;var n=!0}catch(e){}var a=eR.call(e);return n&&(t?e[e6]=r:delete e[e6]),a}(e):(t=e,eR.call(t))}function rX(e,t){return e>t}function rQ(e,t){return null!=e&&eM.call(e,t)}function r0(e,t){return null!=e&&t in ex(e)}function r1(e,t,r){for(var n=r?tf:th,a=e[0].length,o=e.length,i=o,l=eb(o),c=1/0,u=[];i--;){var m=e[i];i&&t&&(m=tg(m,tD(t))),c=t3(m.length,c),l[i]=!r&&(t||a>=120&&m.length>=120)?new rw(i&&m):s}m=e[0];var d=-1,p=l[0];t:for(;++d<a&&u.length<c;){var h=m[d],f=t?t(h):h;if(h=r||0!==h?h:0,!(p?tL(p,f):n(u,f,r))){for(i=o;--i;){var g=l[i];if(!(g?tL(g,f):n(e[i],f,r)))continue t}p&&p.push(f),u.push(h)}}return u}function r2(e,t,r){t=nO(t,e);var n=null==(e=sT(e,t))?e:e[sL(sJ(t))];return null==n?s:tc(n,e,r)}function r3(e){return aV(e)&&rK(e)==d}function r5(e,t,r,n,a){return e===t||(null!=e&&null!=t&&(aV(e)||aV(t))?function(e,t,r,n,a,o){var i=aR(e),l=aR(t),c=i?p:sf(e),u=l?p:sf(t);c=c==d?_:c,u=u==d?_:u;var m=c==_,y=u==_,b=c==u;if(b&&aq(e)){if(!aq(t))return!1;i=!0,m=!1}if(b&&!m)return o||(o=new rx),i||a0(e)?sr(e,t,r,n,a,o):function(e,t,r,n,s,a,o){switch(r){case C:if(e.byteLength!=t.byteLength||e.byteOffset!=t.byteOffset)break;e=e.buffer,t=t.buffer;case A:if(e.byteLength!=t.byteLength||!a(new e$(e),new e$(t)))break;return!0;case h:case f:case v:return aO(+e,+t);case g:return e.name==t.name&&e.message==t.message;case x:case E:return e==t+"";case k:var i=tB;case S:var l=1&n;if(i||(i=tV),e.size!=t.size&&!l)break;var c=o.get(e);if(c)return c==t;n|=2,o.set(e,t);var u=sr(i(e),i(t),n,s,a,o);return o.delete(e),u;case j:if(rd)return rd.call(e)==rd.call(t)}return!1}(e,t,c,r,n,a,o);if(!(1&r)){var w=m&&eM.call(e,"__wrapped__"),T=y&&eM.call(t,"__wrapped__");if(w||T){var I=w?e.value():e,O=T?t.value():t;return o||(o=new rx),a(I,O,r,n,o)}}return!!b&&(o||(o=new rx),function(e,t,r,n,a,o){var i=1&r,l=ss(e),c=l.length;if(c!=ss(t).length&&!i)return!1;for(var u=c;u--;){var m=l[u];if(!(i?m in t:eM.call(t,m)))return!1}var d=o.get(e),p=o.get(t);if(d&&p)return d==t&&p==e;var h=!0;o.set(e,t),o.set(t,e);for(var f=i;++u<c;){var g=e[m=l[u]],y=t[m];if(n)var b=i?n(y,g,m,t,e,o):n(g,y,m,e,t,o);if(!(s===b?g===y||a(g,y,r,n,o):b)){h=!1;break}f||(f="constructor"==m)}if(h&&!f){var k=e.constructor,v=t.constructor;k!=v&&"constructor"in e&&"constructor"in t&&!("function"==typeof k&&k instanceof k&&"function"==typeof v&&v instanceof v)&&(h=!1)}return o.delete(e),o.delete(t),h}(e,t,r,n,a,o))}(e,t,r,n,r5,a):e!=e&&t!=t)}function r6(e,t,r,n){var a=r.length,o=a,i=!n;if(null==e)return!o;for(e=ex(e);a--;){var l=r[a];if(i&&l[2]?l[1]!==e[l[0]]:!(l[0]in e))return!1}for(;++a<o;){var c=(l=r[a])[0],u=e[c],m=l[1];if(i&&l[2]){if(s===u&&!(c in e))return!1}else{var d=new rx;if(n)var p=n(u,m,c,e,t,d);if(!(s===p?r5(m,u,3,n,d):p))return!1}}return!0}function r8(e){var t;return!(!aH(e)||(t=e,eD&&eD in t))&&(aU(e)?eP:ed).test(sF(e))}function r4(e){return"function"==typeof e?e:null==e?oP:"object"==typeof e?aR(e)?nr(e[0],e[1]):nt(e):oY(e)}function r9(e){if(!sS(e))return t1(e);var t=[];for(var r in ex(e))eM.call(e,r)&&"constructor"!=r&&t.push(r);return t}function r7(e,t){return e<t}function ne(e,t){var r=-1,n=aF(e)?eb(e.length):[];return rP(e,function(e,s,a){n[++r]=t(e,s,a)}),n}function nt(e){var t=sm(e);return 1==t.length&&t[0][2]?sE(t[0][0],t[0][1]):function(r){return r===e||r6(r,e,t)}}function nr(e,t){var r;return s_(e)&&(r=t)==r&&!aH(r)?sE(sL(e),t):function(r){var n=oi(r,e);return s===n&&n===t?ol(r,e):r5(t,n,3)}}function nn(e,t,r,n,a){e!==t&&rW(t,function(o,i){if(a||(a=new rx),aH(o))!function(e,t,r,n,a,o,i){var l=sA(e,r),c=sA(t,r),u=i.get(c);if(u)return rj(e,r,u);var m=o?o(l,c,r+"",e,t,i):s,d=s===m;if(d){var p=aR(c),h=!p&&aq(c),f=!p&&!h&&a0(c);m=c,p||h||f?aR(l)?m=l:aP(l)?m=nz(l):h?(d=!1,m=nD(c,!0)):f?(d=!1,m=nL(c,!0)):m=[]:aJ(c)||aD(c)?(m=l,aD(l)?m=a9(l):(!aH(l)||aU(l))&&(m=sy(c))):d=!1}d&&(i.set(c,m),a(m,c,n,o,i),i.delete(c)),rj(e,r,m)}(e,t,i,r,nn,n,a);else{var l=n?n(sA(e,i),o,i+"",e,t,a):s;s===l&&(l=o),rj(e,i,l)}},op)}function ns(e,t){var r=e.length;if(r)return sk(t+=t<0?r:0,r)?e[t]:s}function na(e,t,r){t=t.length?tg(t,function(e){return aR(e)?function(t){return rJ(t,1===e.length?e[0]:e)}:e}):[oP];var n=-1;t=tg(t,tD(sc()));var s=ne(e,function(e,r,s){return{criteria:tg(t,function(t){return t(e)}),index:++n,value:e}}),a=s.length;for(s.sort(function(e,t){return function(e,t,r){for(var n=-1,s=e.criteria,a=t.criteria,o=s.length,i=r.length;++n<o;){var l=nF(s[n],a[n]);if(l){if(n>=i)return l;return l*("desc"==r[n]?-1:1)}}return e.index-t.index}(e,t,r)});a--;)s[a]=s[a].value;return s}function no(e,t,r){for(var n=-1,s=t.length,a={};++n<s;){var o=t[n],i=rJ(e,o);r(i,o)&&nd(a,nO(o,e),i)}return a}function ni(e,t,r,n){var s=n?tE:tS,a=-1,o=t.length,i=e;for(e===t&&(t=nz(t)),r&&(i=tg(e,tD(r)));++a<o;)for(var l=0,c=t[a],u=r?r(c):c;(l=s(i,u,l,n))>-1;)i!==e&&eG.call(i,l,1),eG.call(e,l,1);return e}function nl(e,t){for(var r=e?t.length:0,n=r-1;r--;){var s=t[r];if(r==n||s!==a){var a=s;sk(s)?eG.call(e,s,1):nx(e,s)}}return e}function nc(e,t){return e+t_(t8()*(t-e+1))}function nu(e,t){var r="";if(!e||t<1||t>0x1fffffffffffff)return r;do t%2&&(r+=e),(t=t_(t/2))&&(e+=e);while(t)return r}function nm(e,t){return sO(sj(e,t,oP),e+"")}function nd(e,t,r,n){if(!aH(e))return e;t=nO(t,e);for(var a=-1,o=t.length,i=o-1,l=e;null!=l&&++a<o;){var c=sL(t[a]),u=r;if("__proto__"===c||"constructor"===c||"prototype"===c)break;if(a!=i){var m=l[c];u=n?n(m,c,l):s,s===u&&(u=aH(m)?m:sk(t[a+1])?[]:{})}rT(l,c,u),l=l[c]}return e}var np=rs?function(e,t){return rs.set(e,t),e}:oP,nh=e8?function(e,t){return e8(e,"toString",{configurable:!0,enumerable:!1,value:oR(t),writable:!0})}:oP;function nf(e,t,r){var n=-1,s=e.length;t<0&&(t=-t>s?0:s+t),(r=r>s?s:r)<0&&(r+=s),s=t>r?0:r-t>>>0,t>>>=0;for(var a=eb(s);++n<s;)a[n]=e[n+t];return a}function ng(e,t){var r;return rP(e,function(e,n,s){return!(r=t(e,n,s))}),!!r}function ny(e,t,r){var n=0,s=null==e?n:e.length;if("number"==typeof t&&t==t&&s<=0x7fffffff){for(;n<s;){var a=n+s>>>1,o=e[a];null!==o&&!aQ(o)&&(r?o<=t:o<t)?n=a+1:s=a}return s}return nb(e,t,oP,r)}function nb(e,t,r,n){var a=0,o=null==e?0:e.length;if(0===o)return 0;for(var i=(t=r(t))!=t,l=null===t,c=aQ(t),u=s===t;a<o;){var m=t_((a+o)/2),d=r(e[m]),p=s!==d,h=null===d,f=d==d,g=aQ(d);if(i)var y=n||f;else y=u?f&&(n||p):l?f&&p&&(n||!h):c?f&&p&&!h&&(n||!g):!h&&!g&&(n?d<=t:d<t);y?a=m+1:o=m}return t3(o,0xfffffffe)}function nk(e,t){for(var r=-1,n=e.length,s=0,a=[];++r<n;){var o=e[r],i=t?t(o):o;if(!r||!aO(i,l)){var l=i;a[s++]=0===o?0:o}}return a}function nv(e){return"number"==typeof e?e:aQ(e)?u:+e}function n_(e){if("string"==typeof e)return e;if(aR(e))return tg(e,n_)+"";if(aQ(e))return rp?rp.call(e):"";var t=e+"";return"0"==t&&1/e==-c?"-0":t}function nw(e,t,r){var n=-1,s=th,a=e.length,o=!0,i=[],l=i;if(r)o=!1,s=tf;else if(a>=200){var c=t?null:n8(e);if(c)return tV(c);o=!1,s=tL,l=new rw}else l=t?[]:i;t:for(;++n<a;){var u=e[n],m=t?t(u):u;if(u=r||0!==u?u:0,o&&m==m){for(var d=l.length;d--;)if(l[d]===m)continue t;t&&l.push(m),i.push(u)}else s(l,m,r)||(l!==i&&l.push(m),i.push(u))}return i}function nx(e,t){t=nO(t,e);var r=-1,n=t.length;if(!n)return!0;for(;++r<n;){var s=sL(t[r]);if("__proto__"===s&&!eM.call(e,"__proto__")||("constructor"===s||"prototype"===s)&&r<n-1)return!1}var a=sT(e,t);return null==a||delete a[sL(sJ(t))]}function nS(e,t,r,n){return nd(e,t,r(rJ(e,t)),n)}function nE(e,t,r,n){for(var s=e.length,a=n?s:-1;(n?a--:++a<s)&&t(e[a],a,e););return r?nf(e,n?0:a,n?a+1:s):nf(e,n?a+1:0,n?s:a)}function nj(e,t){var r=e;return r instanceof rb&&(r=r.value()),tb(t,function(e,t){return t.func.apply(t.thisArg,ty([e],t.args))},r)}function nT(e,t,r){var n=e.length;if(n<2)return n?nw(e[0]):[];for(var s=-1,a=eb(n);++s<n;)for(var o=e[s],i=-1;++i<n;)i!=s&&(a[s]=rF(a[s]||o,e[i],t,r));return nw(rB(a,1),t,r)}function nA(e,t,r){for(var n=-1,a=e.length,o=t.length,i={};++n<a;){var l=n<o?t[n]:s;r(i,e[n],l)}return i}function nC(e){return aP(e)?e:[]}function nI(e){return"function"==typeof e?e:oP}function nO(e,t){return aR(e)?e:s_(e,t)?[e]:sR(a7(e))}function nM(e,t,r){var n=e.length;return r=s===r?n:r,!t&&r>=n?e:nf(e,t,r)}var nN=e9||function(e){return e4.clearTimeout(e)};function nD(e,t){if(t)return e.slice();var r=e.length,n=eU?eU(r):new e.constructor(r);return e.copy(n),n}function nR(e){var t=new e.constructor(e.byteLength);return new e$(t).set(new e$(e)),t}function nL(e,t){var r=t?nR(e.buffer):e.buffer;return new e.constructor(r,e.byteOffset,e.length)}function nF(e,t){if(e!==t){var r=s!==e,n=null===e,a=e==e,o=aQ(e),i=s!==t,l=null===t,c=t==t,u=aQ(t);if(!l&&!u&&!o&&e>t||o&&i&&c&&!l&&!u||n&&i&&c||!r&&c||!a)return 1;if(!n&&!o&&!u&&e<t||u&&r&&a&&!n&&!o||l&&r&&a||!i&&a||!c)return -1}return 0}function nP(e,t,r,n){for(var s=-1,a=e.length,o=r.length,i=-1,l=t.length,c=t2(a-o,0),u=eb(l+c),m=!n;++i<l;)u[i]=t[i];for(;++s<o;)(m||s<a)&&(u[r[s]]=e[s]);for(;c--;)u[i++]=e[s++];return u}function nq(e,t,r,n){for(var s=-1,a=e.length,o=-1,i=r.length,l=-1,c=t.length,u=t2(a-i,0),m=eb(u+c),d=!n;++s<u;)m[s]=e[s];for(var p=s;++l<c;)m[p+l]=t[l];for(;++o<i;)(d||s<a)&&(m[p+r[o]]=e[s++]);return m}function nz(e,t){var r=-1,n=e.length;for(t||(t=eb(n));++r<n;)t[r]=e[r];return t}function n$(e,t,r,n){var a=!r;r||(r={});for(var o=-1,i=t.length;++o<i;){var l=t[o],c=n?n(r[l],e[l],l,r,e):s;s===c&&(c=e[l]),a?rO(r,l,c):rT(r,l,c)}return r}function nU(e,t){return function(r,n){var s=aR(r)?tu:rC,a=t?t():{};return s(r,e,sc(n,2),a)}}function nB(e){return nm(function(t,r){var n=-1,a=r.length,o=a>1?r[a-1]:s,i=a>2?r[2]:s;for(o=e.length>3&&"function"==typeof o?(a--,o):s,i&&sv(r[0],r[1],i)&&(o=a<3?s:o,a=1),t=ex(t);++n<a;){var l=r[n];l&&e(t,l,n,o)}return t})}function nW(e,t){return function(r,n){if(null==r)return r;if(!aF(r))return e(r,n);for(var s=r.length,a=t?s:-1,o=ex(r);(t?a--:++a<s)&&!1!==n(o[a],a,o););return r}}function nH(e){return function(t,r,n){for(var s=-1,a=ex(t),o=n(t),i=o.length;i--;){var l=o[e?i:++s];if(!1===r(a[l],l,a))break}return t}}function nV(e){return function(t){var r=tU(t=a7(t))?tG(t):s,n=r?r[0]:t.charAt(0),a=r?nM(r,1).join(""):t.slice(1);return n[e]()+a}}function nY(e){return function(t){return tb(oM(oS(t).replace(eV,"")),e,"")}}function nG(e){return function(){var t=arguments;switch(t.length){case 0:return new e;case 1:return new e(t[0]);case 2:return new e(t[0],t[1]);case 3:return new e(t[0],t[1],t[2]);case 4:return new e(t[0],t[1],t[2],t[3]);case 5:return new e(t[0],t[1],t[2],t[3],t[4]);case 6:return new e(t[0],t[1],t[2],t[3],t[4],t[5]);case 7:return new e(t[0],t[1],t[2],t[3],t[4],t[5],t[6])}var r=rf(e.prototype),n=e.apply(r,t);return aH(n)?n:r}}function nJ(e){return function(t,r,n){var a=ex(t);if(!aF(t)){var o=sc(r,3);t=od(t),r=function(e){return o(a[e],e,a)}}var i=e(t,r,n);return i>-1?a[o?t[i]:i]:s}}function nZ(e){return sn(function(t){var r=t.length,n=r,o=ry.prototype.thru;for(e&&t.reverse();n--;){var i=t[n];if("function"!=typeof i)throw new ej(a);if(o&&!l&&"wrapper"==si(i))var l=new ry([],!0)}for(n=l?n:r;++n<r;){var c=si(i=t[n]),u="wrapper"==c?so(i):s;l=u&&sw(u[0])&&424==u[1]&&!u[4].length&&1==u[9]?l[si(u[0])].apply(l,u[3]):1==i.length&&sw(i)?l[c]():l.thru(i)}return function(){var e=arguments,n=e[0];if(l&&1==e.length&&aR(n))return l.plant(n).value();for(var s=0,a=r?t[s].apply(this,e):n;++s<r;)a=t[s].call(this,a);return a}})}function nK(e,t,r,n,a,o,i,l,c,u){var m=128&t,d=1&t,p=2&t,h=24&t,f=512&t,g=p?s:nG(e);function y(){for(var b=arguments.length,k=eb(b),v=b;v--;)k[v]=arguments[v];if(h)var _=sl(y),w=function(e,t){for(var r=e.length,n=0;r--;)e[r]===t&&++n;return n}(k,_);if(n&&(k=nP(k,n,a,h)),o&&(k=nq(k,o,i,h)),b-=w,h&&b<u){var x=tH(k,_);return n5(e,t,nK,y.placeholder,r,k,x,l,c,u-b)}var S=d?r:this,E=p?S[e]:e;return b=k.length,l?k=function(e,t){for(var r=e.length,n=t3(t.length,r),a=nz(e);n--;){var o=t[n];e[n]=sk(o,r)?a[o]:s}return e}(k,l):f&&b>1&&k.reverse(),m&&c<b&&(k.length=c),this&&this!==e4&&this instanceof y&&(E=g||nG(E)),E.apply(S,k)}return y}function nX(e,t){return function(r,n){var s,a;return s=t(n),a={},rV(r,function(t,r,n){e(a,s(t),r,n)}),a}}function nQ(e,t){return function(r,n){var a;if(s===r&&s===n)return t;if(s!==r&&(a=r),s!==n){if(s===a)return n;"string"==typeof r||"string"==typeof n?(r=n_(r),n=n_(n)):(r=nv(r),n=nv(n)),a=e(r,n)}return a}}function n0(e){return sn(function(t){return t=tg(t,tD(sc())),nm(function(r){var n=this;return e(t,function(e){return tc(e,n,r)})})})}function n1(e,t){var r=(t=s===t?" ":n_(t)).length;if(r<2)return r?nu(t,e):t;var n=nu(t,tr(e/tY(t)));return tU(t)?nM(tG(n),0,e).join(""):n.slice(0,e)}function n2(e){return function(t,r,n){n&&"number"!=typeof n&&sv(t,r,n)&&(r=n=s),t=a5(t),s===r?(r=t,t=0):r=a5(r),n=s===n?t<r?1:-1:a5(n);for(var a=t,o=r,i=n,l=-1,c=t2(tr((o-a)/(i||1)),0),u=eb(c);c--;)u[e?c:++l]=a,a+=i;return u}}function n3(e){return function(t,r){return("string"!=typeof t||"string"!=typeof r)&&(t=a4(t),r=a4(r)),e(t,r)}}function n5(e,t,r,n,a,o,i,l,c,u){var m=8&t,d=m?i:s,p=m?s:i,h=m?o:s,f=m?s:o;t|=m?32:64,4&(t&=~(m?64:32))||(t&=-4);var g=[e,t,a,h,d,f,p,l,c,u],y=r.apply(s,g);return sw(e)&&sC(y,g),y.placeholder=n,sM(y,e,t)}function n6(e){var t=ew[e];return function(e,r){if(e=a4(e),(r=null==r?0:t3(a6(r),292))&&tQ(e)){var n=(a7(e)+"e").split("e");return+((n=(a7(t(n[0]+"e"+(+n[1]+r)))+"e").split("e"))[0]+"e"+(n[1]-r))}return t(e)}}var n8=rt&&1/tV(new rt([,-0]))[1]==c?function(e){return new rt(e)}:oB;function n4(e){return function(t){var r,n,s=sf(t);return s==k?tB(t):s==S?(r=-1,n=Array(t.size),t.forEach(function(e){n[++r]=[e,e]}),n):tg(e(t),function(e){return[e,t[e]]})}}function n9(e,t,r,n,o,i,c,u){var m=2&t;if(!m&&"function"!=typeof e)throw new ej(a);var d=n?n.length:0;if(d||(t&=-97,n=o=s),c=s===c?c:t2(a6(c),0),u=s===u?u:a6(u),d-=o?o.length:0,64&t){var p=n,h=o;n=o=s}var f=m?s:so(e),g=[e,t,r,n,o,p,h,i,c,u];if(f&&function(e,t){var r=e[1],n=t[1],s=r|n,a=s<131,o=128==n&&8==r||128==n&&256==r&&e[7].length<=t[8]||384==n&&t[7].length<=t[8]&&8==r;if(a||o){1&n&&(e[2]=t[2],s|=1&r?0:4);var i=t[3];if(i){var c=e[3];e[3]=c?nP(c,i,t[4]):i,e[4]=c?tH(e[3],l):t[4]}(i=t[5])&&(c=e[5],e[5]=c?nq(c,i,t[6]):i,e[6]=c?tH(e[5],l):t[6]),(i=t[7])&&(e[7]=i),128&n&&(e[8]=null==e[8]?t[8]:t3(e[8],t[8])),null==e[9]&&(e[9]=t[9]),e[0]=t[0],e[1]=s}}(g,f),e=g[0],t=g[1],r=g[2],n=g[3],o=g[4],(u=g[9]=g[9]===s?m?0:e.length:t2(g[9]-d,0))||!(24&t)||(t&=-25),t&&1!=t)8==t||16==t?A=function(e,t,r){var n=nG(e);function a(){for(var o=arguments.length,i=eb(o),l=o,c=sl(a);l--;)i[l]=arguments[l];var u=o<3&&i[0]!==c&&i[o-1]!==c?[]:tH(i,c);return(o-=u.length)<r?n5(e,t,nK,a.placeholder,s,i,u,s,s,r-o):tc(this&&this!==e4&&this instanceof a?n:e,this,i)}return a}(e,t,u):32!=t&&33!=t||o.length?A=nK.apply(s,g):(y=e,b=t,k=r,v=n,_=1&b,w=nG(y),A=function e(){for(var t=-1,r=arguments.length,n=-1,s=v.length,a=eb(s+r),o=this&&this!==e4&&this instanceof e?w:y;++n<s;)a[n]=v[n];for(;r--;)a[n++]=arguments[++t];return tc(o,_?k:this,a)});else var y,b,k,v,_,w,x,S,E,j,T,A=(x=e,S=t,E=r,j=1&S,T=nG(x),function e(){return(this&&this!==e4&&this instanceof e?T:x).apply(j?E:this,arguments)});return sM((f?np:sC)(A,g),e,t)}function n7(e,t,r,n){return s===e||aO(e,eC[r])&&!eM.call(n,r)?t:e}function se(e,t,r,n,a,o){return aH(e)&&aH(t)&&(o.set(t,e),nn(e,t,s,se,o),o.delete(t)),e}function st(e){return aJ(e)?s:e}function sr(e,t,r,n,a,o){var i=1&r,l=e.length,c=t.length;if(l!=c&&!(i&&c>l))return!1;var u=o.get(e),m=o.get(t);if(u&&m)return u==t&&m==e;var d=-1,p=!0,h=2&r?new rw:s;for(o.set(e,t),o.set(t,e);++d<l;){var f=e[d],g=t[d];if(n)var y=i?n(g,f,d,t,e,o):n(f,g,d,e,t,o);if(s!==y){if(y)continue;p=!1;break}if(h){if(!tv(t,function(e,t){if(!tL(h,t)&&(f===e||a(f,e,r,n,o)))return h.push(t)})){p=!1;break}}else if(!(f===g||a(f,g,r,n,o))){p=!1;break}}return o.delete(e),o.delete(t),p}function sn(e){return sO(sj(e,s,sW),e+"")}function ss(e){return rZ(e,od,sp)}function sa(e){return rZ(e,op,sh)}var so=rs?function(e){return rs.get(e)}:oB;function si(e){for(var t=e.name+"",r=ra[t],n=eM.call(ra,t)?r.length:0;n--;){var s=r[n],a=s.func;if(null==a||a==e)return s.name}return t}function sl(e){return(eM.call(rh,"placeholder")?rh:e).placeholder}function sc(){var e=rh.iteratee||oq;return e=e===oq?r4:e,arguments.length?e(arguments[0],arguments[1]):e}function su(e,t){var r,n,s=e.__data__;return("string"==(n=typeof(r=t))||"number"==n||"symbol"==n||"boolean"==n?"__proto__"!==r:null===r)?s["string"==typeof t?"string":"hash"]:s.map}function sm(e){for(var t=od(e),r=t.length;r--;){var n,s=t[r],a=e[s];t[r]=[s,a,(n=a)==n&&!aH(n)]}return t}function sd(e,t){var r=null==e?s:e[t];return r8(r)?r:s}var sp=tC?function(e){return null==e?[]:tp(tC(e=ex(e)),function(t){return eH.call(e,t)})}:oZ,sh=tC?function(e){for(var t=[];e;)ty(t,sp(e)),e=eB(e);return t}:oZ,sf=rK;function sg(e,t,r){t=nO(t,e);for(var n=-1,s=t.length,a=!1;++n<s;){var o=sL(t[n]);if(!(a=null!=e&&r(e,o)))break;e=e[o]}return a||++n!=s?a:!!(s=null==e?0:e.length)&&aW(s)&&sk(o,s)&&(aR(e)||aD(e))}function sy(e){return"function"!=typeof e.constructor||sS(e)?{}:rf(eB(e))}function sb(e){return aR(e)||aD(e)||!!(eZ&&e&&e[eZ])}function sk(e,t){var r=typeof e;return!!(t=null==t?0x1fffffffffffff:t)&&("number"==r||"symbol"!=r&&eh.test(e))&&e>-1&&e%1==0&&e<t}function sv(e,t,r){if(!aH(r))return!1;var n=typeof t;return("number"==n?!!(aF(r)&&sk(t,r.length)):"string"==n&&t in r)&&aO(r[t],e)}function s_(e,t){if(aR(e))return!1;var r=typeof e;return!!("number"==r||"symbol"==r||"boolean"==r||null==e||aQ(e))||Z.test(e)||!J.test(e)||null!=t&&e in ex(t)}function sw(e){var t=si(e),r=rh[t];if("function"!=typeof r||!(t in rb.prototype))return!1;if(e===r)return!0;var n=so(r);return!!n&&e===n[0]}(t9&&sf(new t9(new ArrayBuffer(1)))!=C||t7&&sf(new t7)!=k||re&&sf(re.resolve())!=w||rt&&sf(new rt)!=S||rr&&sf(new rr)!=T)&&(sf=function(e){var t=rK(e),r=t==_?e.constructor:s,n=r?sF(r):"";if(n)switch(n){case ro:return C;case ri:return k;case rl:return w;case rc:return S;case ru:return T}return t});var sx=eI?aU:oK;function sS(e){var t=e&&e.constructor;return e===("function"==typeof t&&t.prototype||eC)}function sE(e,t){return function(r){return null!=r&&r[e]===t&&(s!==t||e in ex(r))}}function sj(e,t,r){return t=t2(s===t?e.length-1:t,0),function(){for(var n=arguments,s=-1,a=t2(n.length-t,0),o=eb(a);++s<a;)o[s]=n[t+s];s=-1;for(var i=eb(t+1);++s<t;)i[s]=n[s];return i[t]=r(o),tc(e,this,i)}}function sT(e,t){return t.length<2?e:rJ(e,nf(t,0,-1))}function sA(e,t){if(("constructor"!==t||"function"!=typeof e[t])&&"__proto__"!=t)return e[t]}var sC=sN(np),sI=tt||function(e,t){return e4.setTimeout(e,t)},sO=sN(nh);function sM(e,t,r){var n,s,a,o=t+"";return sO(e,function(e,t){var r=t.length;if(!r)return e;var n=r-1;return t[n]=(r>1?"& ":"")+t[n],t=t.join(r>2?", ":" "),e.replace(er,`{
/* [wrapped with `+t+`] */
`)}(o,(n=(a=o.match(en))?a[1].split(es):[],s=r,tm(m,function(e){var t="_."+e[0];s&e[1]&&!th(n,t)&&n.push(t)}),n.sort())))}function sN(e){var t=0,r=0;return function(){var n=t5(),a=16-(n-r);if(r=n,a>0){if(++t>=800)return arguments[0]}else t=0;return e.apply(s,arguments)}}function sD(e,t){var r=-1,n=e.length,a=n-1;for(t=s===t?n:t;++r<t;){var o=nc(r,a),i=e[o];e[o]=e[r],e[r]=i}return e.length=t,e}var sR=(o=(n=aE(function(e){var t=[];return 46===e.charCodeAt(0)&&t.push(""),e.replace(K,function(e,r,n,s){t.push(n?s.replace(ei,"$1"):r||e)}),t},function(e){return 500===o.size&&o.clear(),e})).cache,n);function sL(e){if("string"==typeof e||aQ(e))return e;var t=e+"";return"0"==t&&1/e==-c?"-0":t}function sF(e){if(null!=e){try{return eO.call(e)}catch(e){}try{return e+""}catch(e){}}return""}function sP(e){if(e instanceof rb)return e.clone();var t=new ry(e.__wrapped__,e.__chain__);return t.__actions__=nz(e.__actions__),t.__index__=e.__index__,t.__values__=e.__values__,t}var sq=nm(function(e,t){return aP(e)?rF(e,rB(t,1,aP,!0)):[]}),sz=nm(function(e,t){var r=sJ(t);return aP(r)&&(r=s),aP(e)?rF(e,rB(t,1,aP,!0),sc(r,2)):[]}),s$=nm(function(e,t){var r=sJ(t);return aP(r)&&(r=s),aP(e)?rF(e,rB(t,1,aP,!0),s,r):[]});function sU(e,t,r){var n=null==e?0:e.length;if(!n)return -1;var s=null==r?0:a6(r);return s<0&&(s=t2(n+s,0)),tx(e,sc(t,3),s)}function sB(e,t,r){var n=null==e?0:e.length;if(!n)return -1;var a=n-1;return s!==r&&(a=a6(r),a=r<0?t2(n+a,0):t3(a,n-1)),tx(e,sc(t,3),a,!0)}function sW(e){return(null==e?0:e.length)?rB(e,1):[]}function sH(e){return e&&e.length?e[0]:s}var sV=nm(function(e){var t=tg(e,nC);return t.length&&t[0]===e[0]?r1(t):[]}),sY=nm(function(e){var t=sJ(e),r=tg(e,nC);return t===sJ(r)?t=s:r.pop(),r.length&&r[0]===e[0]?r1(r,sc(t,2)):[]}),sG=nm(function(e){var t=sJ(e),r=tg(e,nC);return(t="function"==typeof t?t:s)&&r.pop(),r.length&&r[0]===e[0]?r1(r,s,t):[]});function sJ(e){var t=null==e?0:e.length;return t?e[t-1]:s}var sZ=nm(sK);function sK(e,t){return e&&e.length&&t&&t.length?ni(e,t):e}var sX=sn(function(e,t){var r=null==e?0:e.length,n=rM(e,t);return nl(e,tg(t,function(e){return sk(e,r)?+e:e}).sort(nF)),n});function sQ(e){return null==e?e:t4.call(e)}var s0=nm(function(e){return nw(rB(e,1,aP,!0))}),s1=nm(function(e){var t=sJ(e);return aP(t)&&(t=s),nw(rB(e,1,aP,!0),sc(t,2))}),s2=nm(function(e){var t=sJ(e);return t="function"==typeof t?t:s,nw(rB(e,1,aP,!0),s,t)});function s3(e){if(!(e&&e.length))return[];var t=0;return e=tp(e,function(e){if(aP(e))return t=t2(e.length,t),!0}),tM(t,function(t){return tg(e,tA(t))})}function s5(e,t){if(!(e&&e.length))return[];var r=s3(e);return null==t?r:tg(r,function(e){return tc(t,s,e)})}var s6=nm(function(e,t){return aP(e)?rF(e,t):[]}),s8=nm(function(e){return nT(tp(e,aP))}),s4=nm(function(e){var t=sJ(e);return aP(t)&&(t=s),nT(tp(e,aP),sc(t,2))}),s9=nm(function(e){var t=sJ(e);return t="function"==typeof t?t:s,nT(tp(e,aP),s,t)}),s7=nm(s3),ae=nm(function(e){var t=e.length,r=t>1?e[t-1]:s;return r="function"==typeof r?(e.pop(),r):s,s5(e,r)});function at(e){var t=rh(e);return t.__chain__=!0,t}function ar(e,t){return t(e)}var an=sn(function(e){var t=e.length,r=t?e[0]:0,n=this.__wrapped__,a=function(t){return rM(t,e)};return!(t>1)&&!this.__actions__.length&&n instanceof rb&&sk(r)?((n=n.slice(r,+r+ +!!t)).__actions__.push({func:ar,args:[a],thisArg:s}),new ry(n,this.__chain__).thru(function(e){return t&&!e.length&&e.push(s),e})):this.thru(a)}),as=nU(function(e,t,r){eM.call(e,r)?++e[r]:rO(e,r,1)}),aa=nJ(sU),ao=nJ(sB);function ai(e,t){return(aR(e)?tm:rP)(e,sc(t,3))}function al(e,t){return(aR(e)?function(e,t){for(var r=null==e?0:e.length;r--&&!1!==t(e[r],r,e););return e}:rq)(e,sc(t,3))}var ac=nU(function(e,t,r){eM.call(e,r)?e[r].push(t):rO(e,r,[t])}),au=nm(function(e,t,r){var n=-1,s="function"==typeof t,a=aF(e)?eb(e.length):[];return rP(e,function(e){a[++n]=s?tc(t,e,r):r2(e,t,r)}),a}),am=nU(function(e,t,r){rO(e,r,t)});function ad(e,t){return(aR(e)?tg:ne)(e,sc(t,3))}var ap=nU(function(e,t,r){e[+!r].push(t)},function(){return[[],[]]}),ah=nm(function(e,t){if(null==e)return[];var r=t.length;return r>1&&sv(e,t[0],t[1])?t=[]:r>2&&sv(t[0],t[1],t[2])&&(t=[t[0]]),na(e,rB(t,1),[])}),af=e7||function(){return e4.Date.now()};function ag(e,t,r){return t=r?s:t,t=e&&null==t?e.length:t,n9(e,128,s,s,s,s,t)}function ay(e,t){var r;if("function"!=typeof t)throw new ej(a);return e=a6(e),function(){return--e>0&&(r=t.apply(this,arguments)),e<=1&&(t=s),r}}var ab=nm(function(e,t,r){var n=1;if(r.length){var s=tH(r,sl(ab));n|=32}return n9(e,n,t,r,s)}),ak=nm(function(e,t,r){var n=3;if(r.length){var s=tH(r,sl(ak));n|=32}return n9(t,n,e,r,s)});function av(e,t,r){t=r?s:t;var n=n9(e,8,s,s,s,s,s,t);return n.placeholder=av.placeholder,n}function a_(e,t,r){t=r?s:t;var n=n9(e,16,s,s,s,s,s,t);return n.placeholder=a_.placeholder,n}function aw(e,t,r){var n,o,i,l,c,u,m=0,d=!1,p=!1,h=!0;if("function"!=typeof e)throw new ej(a);function f(t){var r=n,a=o;return n=o=s,m=t,l=e.apply(a,r)}function g(e){var r=e-u,n=e-m;return s===u||r>=t||r<0||p&&n>=i}function y(){var e,r,n,s=af();if(g(s))return b(s);c=sI(y,(e=s-u,r=s-m,n=t-e,p?t3(n,i-r):n))}function b(e){return(c=s,h&&n)?f(e):(n=o=s,l)}function k(){var e,r=af(),a=g(r);if(n=arguments,o=this,u=r,a){if(s===c)return m=e=u,c=sI(y,t),d?f(e):l;if(p)return nN(c),c=sI(y,t),f(u)}return s===c&&(c=sI(y,t)),l}return t=a4(t)||0,aH(r)&&(d=!!r.leading,i=(p="maxWait"in r)?t2(a4(r.maxWait)||0,t):i,h="trailing"in r?!!r.trailing:h),k.cancel=function(){s!==c&&nN(c),m=0,n=u=o=c=s},k.flush=function(){return s===c?l:b(af())},k}var ax=nm(function(e,t){return rL(e,1,t)}),aS=nm(function(e,t,r){return rL(e,a4(t)||0,r)});function aE(e,t){if("function"!=typeof e||null!=t&&"function"!=typeof t)throw new ej(a);var r=function(){var n=arguments,s=t?t.apply(this,n):n[0],a=r.cache;if(a.has(s))return a.get(s);var o=e.apply(this,n);return r.cache=a.set(s,o)||a,o};return r.cache=new(aE.Cache||r_),r}function aj(e){if("function"!=typeof e)throw new ej(a);return function(){var t=arguments;switch(t.length){case 0:return!e.call(this);case 1:return!e.call(this,t[0]);case 2:return!e.call(this,t[0],t[1]);case 3:return!e.call(this,t[0],t[1],t[2])}return!e.apply(this,t)}}aE.Cache=r_;var aT=nm(function(e,t){var r=(t=1==t.length&&aR(t[0])?tg(t[0],tD(sc())):tg(rB(t,1),tD(sc()))).length;return nm(function(n){for(var s=-1,a=t3(n.length,r);++s<a;)n[s]=t[s].call(this,n[s]);return tc(e,this,n)})}),aA=nm(function(e,t){var r=tH(t,sl(aA));return n9(e,32,s,t,r)}),aC=nm(function(e,t){var r=tH(t,sl(aC));return n9(e,64,s,t,r)}),aI=sn(function(e,t){return n9(e,256,s,s,s,t)});function aO(e,t){return e===t||e!=e&&t!=t}var aM=n3(rX),aN=n3(function(e,t){return e>=t}),aD=r3(function(){return arguments}())?r3:function(e){return aV(e)&&eM.call(e,"callee")&&!eH.call(e,"callee")},aR=eb.isArray,aL=tn?tD(tn):function(e){return aV(e)&&rK(e)==A};function aF(e){return null!=e&&aW(e.length)&&!aU(e)}function aP(e){return aV(e)&&aF(e)}var aq=tX||oK,az=ts?tD(ts):function(e){return aV(e)&&rK(e)==f};function a$(e){if(!aV(e))return!1;var t=rK(e);return t==g||"[object DOMException]"==t||"string"==typeof e.message&&"string"==typeof e.name&&!aJ(e)}function aU(e){if(!aH(e))return!1;var t=rK(e);return t==y||t==b||"[object AsyncFunction]"==t||"[object Proxy]"==t}function aB(e){return"number"==typeof e&&e==a6(e)}function aW(e){return"number"==typeof e&&e>-1&&e%1==0&&e<=0x1fffffffffffff}function aH(e){var t=typeof e;return null!=e&&("object"==t||"function"==t)}function aV(e){return null!=e&&"object"==typeof e}var aY=ta?tD(ta):function(e){return aV(e)&&sf(e)==k};function aG(e){return"number"==typeof e||aV(e)&&rK(e)==v}function aJ(e){if(!aV(e)||rK(e)!=_)return!1;var t=eB(e);if(null===t)return!0;var r=eM.call(t,"constructor")&&t.constructor;return"function"==typeof r&&r instanceof r&&eO.call(r)==eL}var aZ=to?tD(to):function(e){return aV(e)&&rK(e)==x},aK=ti?tD(ti):function(e){return aV(e)&&sf(e)==S};function aX(e){return"string"==typeof e||!aR(e)&&aV(e)&&rK(e)==E}function aQ(e){return"symbol"==typeof e||aV(e)&&rK(e)==j}var a0=tl?tD(tl):function(e){return aV(e)&&aW(e.length)&&!!e0[rK(e)]},a1=n3(r7),a2=n3(function(e,t){return e<=t});function a3(e){if(!e)return[];if(aF(e))return aX(e)?tG(e):nz(e);if(e2&&e[e2]){for(var t,r=e[e2](),n=[];!(t=r.next()).done;)n.push(t.value);return n}var s=sf(e);return(s==k?tB:s==S?tV:o_)(e)}function a5(e){return e?(e=a4(e))===c||e===-c?(e<0?-1:1)*17976931348623157e292:e==e?e:0:0===e?e:0}function a6(e){var t=a5(e),r=t%1;return t==t?r?t-r:t:0}function a8(e){return e?rN(a6(e),0,0xffffffff):0}function a4(e){if("number"==typeof e)return e;if(aQ(e))return u;if(aH(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=aH(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=tN(e);var r=em.test(e);return r||ep.test(e)?e5(e.slice(2),r?2:8):eu.test(e)?u:+e}function a9(e){return n$(e,op(e))}function a7(e){return null==e?"":n_(e)}var oe=nB(function(e,t){if(sS(t)||aF(t))return void n$(t,od(t),e);for(var r in t)eM.call(t,r)&&rT(e,r,t[r])}),ot=nB(function(e,t){n$(t,op(t),e)}),or=nB(function(e,t,r,n){n$(t,op(t),e,n)}),on=nB(function(e,t,r,n){n$(t,od(t),e,n)}),os=sn(rM),oa=nm(function(e,t){e=ex(e);var r=-1,n=t.length,a=n>2?t[2]:s;for(a&&sv(t[0],t[1],a)&&(n=1);++r<n;)for(var o=t[r],i=op(o),l=-1,c=i.length;++l<c;){var u=i[l],m=e[u];(s===m||aO(m,eC[u])&&!eM.call(e,u))&&(e[u]=o[u])}return e}),oo=nm(function(e){return e.push(s,se),tc(of,s,e)});function oi(e,t,r){var n=null==e?s:rJ(e,t);return s===n?r:n}function ol(e,t){return null!=e&&sg(e,t,r0)}var oc=nX(function(e,t,r){null!=t&&"function"!=typeof t.toString&&(t=eR.call(t)),e[t]=r},oR(oP)),ou=nX(function(e,t,r){null!=t&&"function"!=typeof t.toString&&(t=eR.call(t)),eM.call(e,t)?e[t].push(r):e[t]=[r]},sc),om=nm(r2);function od(e){return aF(e)?rS(e):r9(e)}function op(e){return aF(e)?rS(e,!0):function(e){if(!aH(e)){var t=e,r=[];if(null!=t)for(var n in ex(t))r.push(n);return r}var s=sS(e),a=[];for(var o in e)"constructor"==o&&(s||!eM.call(e,o))||a.push(o);return a}(e)}var oh=nB(function(e,t,r){nn(e,t,r)}),of=nB(function(e,t,r,n){nn(e,t,r,n)}),og=sn(function(e,t){var r={};if(null==e)return r;var n=!1;t=tg(t,function(t){return t=nO(t,e),n||(n=t.length>1),t}),n$(e,sa(e),r),n&&(r=rD(r,7,st));for(var s=t.length;s--;)nx(r,t[s]);return r}),oy=sn(function(e,t){return null==e?{}:no(e,t,function(t,r){return ol(e,r)})});function ob(e,t){if(null==e)return{};var r=tg(sa(e),function(e){return[e]});return t=sc(t),no(e,r,function(e,r){return t(e,r[0])})}var ok=n4(od),ov=n4(op);function o_(e){return null==e?[]:tR(e,od(e))}var ow=nY(function(e,t,r){return t=t.toLowerCase(),e+(r?ox(t):t)});function ox(e){return oO(a7(e).toLowerCase())}function oS(e){return(e=a7(e))&&e.replace(ef,tq).replace(eY,"")}var oE=nY(function(e,t,r){return e+(r?"-":"")+t.toLowerCase()}),oj=nY(function(e,t,r){return e+(r?" ":"")+t.toLowerCase()}),oT=nV("toLowerCase"),oA=nY(function(e,t,r){return e+(r?"_":"")+t.toLowerCase()}),oC=nY(function(e,t,r){return e+(r?" ":"")+oO(t)}),oI=nY(function(e,t,r){return e+(r?" ":"")+t.toUpperCase()}),oO=nV("toUpperCase");function oM(e,t,r){if(e=a7(e),t=r?s:t,s===t){var n;return(n=e,eK.test(n))?e.match(eJ)||[]:e.match(ea)||[]}return e.match(t)||[]}var oN=nm(function(e,t){try{return tc(e,s,t)}catch(e){return a$(e)?e:new ev(e)}}),oD=sn(function(e,t){return tm(t,function(t){rO(e,t=sL(t),ab(e[t],e))}),e});function oR(e){return function(){return e}}var oL=nZ(),oF=nZ(!0);function oP(e){return e}function oq(e){return r4("function"==typeof e?e:rD(e,1))}var oz=nm(function(e,t){return function(r){return r2(r,e,t)}}),o$=nm(function(e,t){return function(r){return r2(e,r,t)}});function oU(e,t,r){var n=od(t),s=rG(t,n);null!=r||aH(t)&&(s.length||!n.length)||(r=t,t=e,e=this,s=rG(t,od(t)));var a=!(aH(r)&&"chain"in r)||!!r.chain,o=aU(e);return tm(s,function(r){var n=t[r];e[r]=n,o&&(e.prototype[r]=function(){var t=this.__chain__;if(a||t){var r=e(this.__wrapped__);return(r.__actions__=nz(this.__actions__)).push({func:n,args:arguments,thisArg:e}),r.__chain__=t,r}return n.apply(e,ty([this.value()],arguments))})}),e}function oB(){}var oW=n0(tg),oH=n0(td),oV=n0(tv);function oY(e){return s_(e)?tA(sL(e)):function(t){return rJ(t,e)}}var oG=n2(),oJ=n2(!0);function oZ(){return[]}function oK(){return!1}var oX=nQ(function(e,t){return e+t},0),oQ=n6("ceil"),o0=nQ(function(e,t){return e/t},1),o1=n6("floor"),o2=nQ(function(e,t){return e*t},1),o3=n6("round"),o5=nQ(function(e,t){return e-t},0);return rh.after=function(e,t){if("function"!=typeof t)throw new ej(a);return e=a6(e),function(){if(--e<1)return t.apply(this,arguments)}},rh.ary=ag,rh.assign=oe,rh.assignIn=ot,rh.assignInWith=or,rh.assignWith=on,rh.at=os,rh.before=ay,rh.bind=ab,rh.bindAll=oD,rh.bindKey=ak,rh.castArray=function(){if(!arguments.length)return[];var e=arguments[0];return aR(e)?e:[e]},rh.chain=at,rh.chunk=function(e,t,r){t=(r?sv(e,t,r):s===t)?1:t2(a6(t),0);var n=null==e?0:e.length;if(!n||t<1)return[];for(var a=0,o=0,i=eb(tr(n/t));a<n;)i[o++]=nf(e,a,a+=t);return i},rh.compact=function(e){for(var t=-1,r=null==e?0:e.length,n=0,s=[];++t<r;){var a=e[t];a&&(s[n++]=a)}return s},rh.concat=function(){var e=arguments.length;if(!e)return[];for(var t=eb(e-1),r=arguments[0],n=e;n--;)t[n-1]=arguments[n];return ty(aR(r)?nz(r):[r],rB(t,1))},rh.cond=function(e){var t=null==e?0:e.length,r=sc();return e=t?tg(e,function(e){if("function"!=typeof e[1])throw new ej(a);return[r(e[0]),e[1]]}):[],nm(function(r){for(var n=-1;++n<t;){var s=e[n];if(tc(s[0],this,r))return tc(s[1],this,r)}})},rh.conforms=function(e){var t,r;return r=od(t=rD(e,1)),function(e){return rR(e,t,r)}},rh.constant=oR,rh.countBy=as,rh.create=function(e,t){var r=rf(e);return null==t?r:rI(r,t)},rh.curry=av,rh.curryRight=a_,rh.debounce=aw,rh.defaults=oa,rh.defaultsDeep=oo,rh.defer=ax,rh.delay=aS,rh.difference=sq,rh.differenceBy=sz,rh.differenceWith=s$,rh.drop=function(e,t,r){var n=null==e?0:e.length;return n?nf(e,(t=r||s===t?1:a6(t))<0?0:t,n):[]},rh.dropRight=function(e,t,r){var n=null==e?0:e.length;return n?nf(e,0,(t=n-(t=r||s===t?1:a6(t)))<0?0:t):[]},rh.dropRightWhile=function(e,t){return e&&e.length?nE(e,sc(t,3),!0,!0):[]},rh.dropWhile=function(e,t){return e&&e.length?nE(e,sc(t,3),!0):[]},rh.fill=function(e,t,r,n){var a=null==e?0:e.length;if(!a)return[];r&&"number"!=typeof r&&sv(e,t,r)&&(r=0,n=a);var o=r,i=n,l=e.length;for((o=a6(o))<0&&(o=-o>l?0:l+o),(i=s===i||i>l?l:a6(i))<0&&(i+=l),i=o>i?0:a8(i);o<i;)e[o++]=t;return e},rh.filter=function(e,t){return(aR(e)?tp:rU)(e,sc(t,3))},rh.flatMap=function(e,t){return rB(ad(e,t),1)},rh.flatMapDeep=function(e,t){return rB(ad(e,t),c)},rh.flatMapDepth=function(e,t,r){return r=s===r?1:a6(r),rB(ad(e,t),r)},rh.flatten=sW,rh.flattenDeep=function(e){return(null==e?0:e.length)?rB(e,c):[]},rh.flattenDepth=function(e,t){return(null==e?0:e.length)?rB(e,t=s===t?1:a6(t)):[]},rh.flip=function(e){return n9(e,512)},rh.flow=oL,rh.flowRight=oF,rh.fromPairs=function(e){for(var t=-1,r=null==e?0:e.length,n={};++t<r;){var s=e[t];rO(n,s[0],s[1])}return n},rh.functions=function(e){return null==e?[]:rG(e,od(e))},rh.functionsIn=function(e){return null==e?[]:rG(e,op(e))},rh.groupBy=ac,rh.initial=function(e){return(null==e?0:e.length)?nf(e,0,-1):[]},rh.intersection=sV,rh.intersectionBy=sY,rh.intersectionWith=sG,rh.invert=oc,rh.invertBy=ou,rh.invokeMap=au,rh.iteratee=oq,rh.keyBy=am,rh.keys=od,rh.keysIn=op,rh.map=ad,rh.mapKeys=function(e,t){var r={};return t=sc(t,3),rV(e,function(e,n,s){rO(r,t(e,n,s),e)}),r},rh.mapValues=function(e,t){var r={};return t=sc(t,3),rV(e,function(e,n,s){rO(r,n,t(e,n,s))}),r},rh.matches=function(e){return nt(rD(e,1))},rh.matchesProperty=function(e,t){return nr(e,rD(t,1))},rh.memoize=aE,rh.merge=oh,rh.mergeWith=of,rh.method=oz,rh.methodOf=o$,rh.mixin=oU,rh.negate=aj,rh.nthArg=function(e){return e=a6(e),nm(function(t){return ns(t,e)})},rh.omit=og,rh.omitBy=function(e,t){return ob(e,aj(sc(t)))},rh.once=function(e){return ay(2,e)},rh.orderBy=function(e,t,r,n){return null==e?[]:(aR(t)||(t=null==t?[]:[t]),aR(r=n?s:r)||(r=null==r?[]:[r]),na(e,t,r))},rh.over=oW,rh.overArgs=aT,rh.overEvery=oH,rh.overSome=oV,rh.partial=aA,rh.partialRight=aC,rh.partition=ap,rh.pick=oy,rh.pickBy=ob,rh.property=oY,rh.propertyOf=function(e){return function(t){return null==e?s:rJ(e,t)}},rh.pull=sZ,rh.pullAll=sK,rh.pullAllBy=function(e,t,r){return e&&e.length&&t&&t.length?ni(e,t,sc(r,2)):e},rh.pullAllWith=function(e,t,r){return e&&e.length&&t&&t.length?ni(e,t,s,r):e},rh.pullAt=sX,rh.range=oG,rh.rangeRight=oJ,rh.rearg=aI,rh.reject=function(e,t){return(aR(e)?tp:rU)(e,aj(sc(t,3)))},rh.remove=function(e,t){var r=[];if(!(e&&e.length))return r;var n=-1,s=[],a=e.length;for(t=sc(t,3);++n<a;){var o=e[n];t(o,n,e)&&(r.push(o),s.push(n))}return nl(e,s),r},rh.rest=function(e,t){if("function"!=typeof e)throw new ej(a);return nm(e,t=s===t?t:a6(t))},rh.reverse=sQ,rh.sampleSize=function(e,t,r){return t=(r?sv(e,t,r):s===t)?1:a6(t),(aR(e)?function(e,t){return sD(nz(e),rN(t,0,e.length))}:function(e,t){var r=o_(e);return sD(r,rN(t,0,r.length))})(e,t)},rh.set=function(e,t,r){return null==e?e:nd(e,t,r)},rh.setWith=function(e,t,r,n){return n="function"==typeof n?n:s,null==e?e:nd(e,t,r,n)},rh.shuffle=function(e){return(aR(e)?function(e){return sD(nz(e))}:function(e){return sD(o_(e))})(e)},rh.slice=function(e,t,r){var n=null==e?0:e.length;return n?(r&&"number"!=typeof r&&sv(e,t,r)?(t=0,r=n):(t=null==t?0:a6(t),r=s===r?n:a6(r)),nf(e,t,r)):[]},rh.sortBy=ah,rh.sortedUniq=function(e){return e&&e.length?nk(e):[]},rh.sortedUniqBy=function(e,t){return e&&e.length?nk(e,sc(t,2)):[]},rh.split=function(e,t,r){return(r&&"number"!=typeof r&&sv(e,t,r)&&(t=r=s),r=s===r?0xffffffff:r>>>0)?(e=a7(e))&&("string"==typeof t||null!=t&&!aZ(t))&&!(t=n_(t))&&tU(e)?nM(tG(e),0,r):e.split(t,r):[]},rh.spread=function(e,t){if("function"!=typeof e)throw new ej(a);return t=null==t?0:t2(a6(t),0),nm(function(r){var n=r[t],s=nM(r,0,t);return n&&ty(s,n),tc(e,this,s)})},rh.tail=function(e){var t=null==e?0:e.length;return t?nf(e,1,t):[]},rh.take=function(e,t,r){return e&&e.length?nf(e,0,(t=r||s===t?1:a6(t))<0?0:t):[]},rh.takeRight=function(e,t,r){var n=null==e?0:e.length;return n?nf(e,(t=n-(t=r||s===t?1:a6(t)))<0?0:t,n):[]},rh.takeRightWhile=function(e,t){return e&&e.length?nE(e,sc(t,3),!1,!0):[]},rh.takeWhile=function(e,t){return e&&e.length?nE(e,sc(t,3)):[]},rh.tap=function(e,t){return t(e),e},rh.throttle=function(e,t,r){var n=!0,s=!0;if("function"!=typeof e)throw new ej(a);return aH(r)&&(n="leading"in r?!!r.leading:n,s="trailing"in r?!!r.trailing:s),aw(e,t,{leading:n,maxWait:t,trailing:s})},rh.thru=ar,rh.toArray=a3,rh.toPairs=ok,rh.toPairsIn=ov,rh.toPath=function(e){return aR(e)?tg(e,sL):aQ(e)?[e]:nz(sR(a7(e)))},rh.toPlainObject=a9,rh.transform=function(e,t,r){var n=aR(e),s=n||aq(e)||a0(e);if(t=sc(t,4),null==r){var a=e&&e.constructor;r=s?n?new a:[]:aH(e)&&aU(a)?rf(eB(e)):{}}return(s?tm:rV)(e,function(e,n,s){return t(r,e,n,s)}),r},rh.unary=function(e){return ag(e,1)},rh.union=s0,rh.unionBy=s1,rh.unionWith=s2,rh.uniq=function(e){return e&&e.length?nw(e):[]},rh.uniqBy=function(e,t){return e&&e.length?nw(e,sc(t,2)):[]},rh.uniqWith=function(e,t){return t="function"==typeof t?t:s,e&&e.length?nw(e,s,t):[]},rh.unset=function(e,t){return null==e||nx(e,t)},rh.unzip=s3,rh.unzipWith=s5,rh.update=function(e,t,r){return null==e?e:nS(e,t,nI(r))},rh.updateWith=function(e,t,r,n){return n="function"==typeof n?n:s,null==e?e:nS(e,t,nI(r),n)},rh.values=o_,rh.valuesIn=function(e){return null==e?[]:tR(e,op(e))},rh.without=s6,rh.words=oM,rh.wrap=function(e,t){return aA(nI(t),e)},rh.xor=s8,rh.xorBy=s4,rh.xorWith=s9,rh.zip=s7,rh.zipObject=function(e,t){return nA(e||[],t||[],rT)},rh.zipObjectDeep=function(e,t){return nA(e||[],t||[],nd)},rh.zipWith=ae,rh.entries=ok,rh.entriesIn=ov,rh.extend=ot,rh.extendWith=or,oU(rh,rh),rh.add=oX,rh.attempt=oN,rh.camelCase=ow,rh.capitalize=ox,rh.ceil=oQ,rh.clamp=function(e,t,r){return s===r&&(r=t,t=s),s!==r&&(r=(r=a4(r))==r?r:0),s!==t&&(t=(t=a4(t))==t?t:0),rN(a4(e),t,r)},rh.clone=function(e){return rD(e,4)},rh.cloneDeep=function(e){return rD(e,5)},rh.cloneDeepWith=function(e,t){return rD(e,5,t="function"==typeof t?t:s)},rh.cloneWith=function(e,t){return rD(e,4,t="function"==typeof t?t:s)},rh.conformsTo=function(e,t){return null==t||rR(e,t,od(t))},rh.deburr=oS,rh.defaultTo=function(e,t){return null==e||e!=e?t:e},rh.divide=o0,rh.endsWith=function(e,t,r){e=a7(e),t=n_(t);var n=e.length,a=r=s===r?n:rN(a6(r),0,n);return(r-=t.length)>=0&&e.slice(r,a)==t},rh.eq=aO,rh.escape=function(e){return(e=a7(e))&&H.test(e)?e.replace(B,tz):e},rh.escapeRegExp=function(e){return(e=a7(e))&&Q.test(e)?e.replace(X,"\\$&"):e},rh.every=function(e,t,r){var n=aR(e)?td:rz;return r&&sv(e,t,r)&&(t=s),n(e,sc(t,3))},rh.find=aa,rh.findIndex=sU,rh.findKey=function(e,t){return tw(e,sc(t,3),rV)},rh.findLast=ao,rh.findLastIndex=sB,rh.findLastKey=function(e,t){return tw(e,sc(t,3),rY)},rh.floor=o1,rh.forEach=ai,rh.forEachRight=al,rh.forIn=function(e,t){return null==e?e:rW(e,sc(t,3),op)},rh.forInRight=function(e,t){return null==e?e:rH(e,sc(t,3),op)},rh.forOwn=function(e,t){return e&&rV(e,sc(t,3))},rh.forOwnRight=function(e,t){return e&&rY(e,sc(t,3))},rh.get=oi,rh.gt=aM,rh.gte=aN,rh.has=function(e,t){return null!=e&&sg(e,t,rQ)},rh.hasIn=ol,rh.head=sH,rh.identity=oP,rh.includes=function(e,t,r,n){e=aF(e)?e:o_(e),r=r&&!n?a6(r):0;var s=e.length;return r<0&&(r=t2(s+r,0)),aX(e)?r<=s&&e.indexOf(t,r)>-1:!!s&&tS(e,t,r)>-1},rh.indexOf=function(e,t,r){var n=null==e?0:e.length;if(!n)return -1;var s=null==r?0:a6(r);return s<0&&(s=t2(n+s,0)),tS(e,t,s)},rh.inRange=function(e,t,r){var n,a,o;return t=a5(t),s===r?(r=t,t=0):r=a5(r),(n=e=a4(e))>=t3(a=t,o=r)&&n<t2(a,o)},rh.invoke=om,rh.isArguments=aD,rh.isArray=aR,rh.isArrayBuffer=aL,rh.isArrayLike=aF,rh.isArrayLikeObject=aP,rh.isBoolean=function(e){return!0===e||!1===e||aV(e)&&rK(e)==h},rh.isBuffer=aq,rh.isDate=az,rh.isElement=function(e){return aV(e)&&1===e.nodeType&&!aJ(e)},rh.isEmpty=function(e){if(null==e)return!0;if(aF(e)&&(aR(e)||"string"==typeof e||"function"==typeof e.splice||aq(e)||a0(e)||aD(e)))return!e.length;var t=sf(e);if(t==k||t==S)return!e.size;if(sS(e))return!r9(e).length;for(var r in e)if(eM.call(e,r))return!1;return!0},rh.isEqual=function(e,t){return r5(e,t)},rh.isEqualWith=function(e,t,r){var n=(r="function"==typeof r?r:s)?r(e,t):s;return s===n?r5(e,t,s,r):!!n},rh.isError=a$,rh.isFinite=function(e){return"number"==typeof e&&tQ(e)},rh.isFunction=aU,rh.isInteger=aB,rh.isLength=aW,rh.isMap=aY,rh.isMatch=function(e,t){return e===t||r6(e,t,sm(t))},rh.isMatchWith=function(e,t,r){return r="function"==typeof r?r:s,r6(e,t,sm(t),r)},rh.isNaN=function(e){return aG(e)&&e!=+e},rh.isNative=function(e){if(sx(e))throw new ev("Unsupported core-js use. Try https://npms.io/search?q=ponyfill.");return r8(e)},rh.isNil=function(e){return null==e},rh.isNull=function(e){return null===e},rh.isNumber=aG,rh.isObject=aH,rh.isObjectLike=aV,rh.isPlainObject=aJ,rh.isRegExp=aZ,rh.isSafeInteger=function(e){return aB(e)&&e>=-0x1fffffffffffff&&e<=0x1fffffffffffff},rh.isSet=aK,rh.isString=aX,rh.isSymbol=aQ,rh.isTypedArray=a0,rh.isUndefined=function(e){return s===e},rh.isWeakMap=function(e){return aV(e)&&sf(e)==T},rh.isWeakSet=function(e){return aV(e)&&"[object WeakSet]"==rK(e)},rh.join=function(e,t){return null==e?"":t0.call(e,t)},rh.kebabCase=oE,rh.last=sJ,rh.lastIndexOf=function(e,t,r){var n=null==e?0:e.length;if(!n)return -1;var a=n;return s!==r&&(a=(a=a6(r))<0?t2(n+a,0):t3(a,n-1)),t==t?function(e,t,r){for(var n=r+1;n--&&e[n]!==t;);return n}(e,t,a):tx(e,tj,a,!0)},rh.lowerCase=oj,rh.lowerFirst=oT,rh.lt=a1,rh.lte=a2,rh.max=function(e){return e&&e.length?r$(e,oP,rX):s},rh.maxBy=function(e,t){return e&&e.length?r$(e,sc(t,2),rX):s},rh.mean=function(e){return tT(e,oP)},rh.meanBy=function(e,t){return tT(e,sc(t,2))},rh.min=function(e){return e&&e.length?r$(e,oP,r7):s},rh.minBy=function(e,t){return e&&e.length?r$(e,sc(t,2),r7):s},rh.stubArray=oZ,rh.stubFalse=oK,rh.stubObject=function(){return{}},rh.stubString=function(){return""},rh.stubTrue=function(){return!0},rh.multiply=o2,rh.nth=function(e,t){return e&&e.length?ns(e,a6(t)):s},rh.noConflict=function(){return e4._===this&&(e4._=eF),this},rh.noop=oB,rh.now=af,rh.pad=function(e,t,r){e=a7(e);var n=(t=a6(t))?tY(e):0;if(!t||n>=t)return e;var s=(t-n)/2;return n1(t_(s),r)+e+n1(tr(s),r)},rh.padEnd=function(e,t,r){e=a7(e);var n=(t=a6(t))?tY(e):0;return t&&n<t?e+n1(t-n,r):e},rh.padStart=function(e,t,r){e=a7(e);var n=(t=a6(t))?tY(e):0;return t&&n<t?n1(t-n,r)+e:e},rh.parseInt=function(e,t,r){return r||null==t?t=0:t&&(t*=1),t6(a7(e).replace(ee,""),t||0)},rh.random=function(e,t,r){if(r&&"boolean"!=typeof r&&sv(e,t,r)&&(t=r=s),s===r&&("boolean"==typeof t?(r=t,t=s):"boolean"==typeof e&&(r=e,e=s)),s===e&&s===t?(e=0,t=1):(e=a5(e),s===t?(t=e,e=0):t=a5(t)),e>t){var n=e;e=t,t=n}if(r||e%1||t%1){var a=t8();return t3(e+a*(t-e+e3("1e-"+((a+"").length-1))),t)}return nc(e,t)},rh.reduce=function(e,t,r){var n=aR(e)?tb:tI,s=arguments.length<3;return n(e,sc(t,4),r,s,rP)},rh.reduceRight=function(e,t,r){var n=aR(e)?tk:tI,s=arguments.length<3;return n(e,sc(t,4),r,s,rq)},rh.repeat=function(e,t,r){return t=(r?sv(e,t,r):s===t)?1:a6(t),nu(a7(e),t)},rh.replace=function(){var e=arguments,t=a7(e[0]);return e.length<3?t:t.replace(e[1],e[2])},rh.result=function(e,t,r){t=nO(t,e);var n=-1,a=t.length;for(a||(a=1,e=s);++n<a;){var o=null==e?s:e[sL(t[n])];s===o&&(n=a,o=r),e=aU(o)?o.call(e):o}return e},rh.round=o3,rh.runInContext=e,rh.sample=function(e){return(aR(e)?rE:function(e){return rE(o_(e))})(e)},rh.size=function(e){if(null==e)return 0;if(aF(e))return aX(e)?tY(e):e.length;var t=sf(e);return t==k||t==S?e.size:r9(e).length},rh.snakeCase=oA,rh.some=function(e,t,r){var n=aR(e)?tv:ng;return r&&sv(e,t,r)&&(t=s),n(e,sc(t,3))},rh.sortedIndex=function(e,t){return ny(e,t)},rh.sortedIndexBy=function(e,t,r){return nb(e,t,sc(r,2))},rh.sortedIndexOf=function(e,t){var r=null==e?0:e.length;if(r){var n=ny(e,t);if(n<r&&aO(e[n],t))return n}return -1},rh.sortedLastIndex=function(e,t){return ny(e,t,!0)},rh.sortedLastIndexBy=function(e,t,r){return nb(e,t,sc(r,2),!0)},rh.sortedLastIndexOf=function(e,t){if(null==e?0:e.length){var r=ny(e,t,!0)-1;if(aO(e[r],t))return r}return -1},rh.startCase=oC,rh.startsWith=function(e,t,r){return e=a7(e),r=null==r?0:rN(a6(r),0,e.length),t=n_(t),e.slice(r,r+t.length)==t},rh.subtract=o5,rh.sum=function(e){return e&&e.length?tO(e,oP):0},rh.sumBy=function(e,t){return e&&e.length?tO(e,sc(t,2)):0},rh.template=function(e,t,r){var n=rh.templateSettings;r&&sv(e,t,r)&&(t=s),e=a7(e),t=on({},t,n,n7);var a=on({},t.imports,n.imports,n7),o=od(a),i=tR(a,o);tm(o,function(e){if(eo.test(e))throw new ev("Invalid `imports` option passed into `_.template`")});var l,c,u=0,m=t.interpolate||eg,d="__p += '",p=eS((t.escape||eg).source+"|"+m.source+"|"+(m===G?el:eg).source+"|"+(t.evaluate||eg).source+"|$","g"),h="//# sourceURL="+(eM.call(t,"sourceURL")?(t.sourceURL+"").replace(/\s/g," "):"lodash.templateSources["+ ++eQ+"]")+`
`;e.replace(p,function(t,r,n,s,a,o){return n||(n=s),d+=e.slice(u,o).replace(ey,t$),r&&(l=!0,d+=`' +
__e(`+r+`) +
'`),a&&(c=!0,d+=`';
`+a+`;
__p += '`),n&&(d+=`' +
((__t = (`+n+`)) == null ? '' : __t) +
'`),u=o+t.length,t}),d+=`';
`;var f=eM.call(t,"variable")&&t.variable;if(f){if(eo.test(f))throw new ev("Invalid `variable` option passed into `_.template`")}else d=`with (obj) {
`+d+`
}
`;d=(c?d.replace(q,""):d).replace(z,"$1").replace($,"$1;"),d="function("+(f||"obj")+`) {
`+(f?"":`obj || (obj = {});
`)+"var __t, __p = ''"+(l?", __e = _.escape":"")+(c?`, __j = Array.prototype.join;
function print() { __p += __j.call(arguments, '') }
`:`;
`)+d+`return __p
}`;var g=oN(function(){return e_(o,h+"return "+d).apply(s,i)});if(g.source=d,a$(g))throw g;return g},rh.times=function(e,t){if((e=a6(e))<1||e>0x1fffffffffffff)return[];var r=0xffffffff,n=t3(e,0xffffffff);t=sc(t),e-=0xffffffff;for(var s=tM(n,t);++r<e;)t(r);return s},rh.toFinite=a5,rh.toInteger=a6,rh.toLength=a8,rh.toLower=function(e){return a7(e).toLowerCase()},rh.toNumber=a4,rh.toSafeInteger=function(e){return e?rN(a6(e),-0x1fffffffffffff,0x1fffffffffffff):0===e?e:0},rh.toString=a7,rh.toUpper=function(e){return a7(e).toUpperCase()},rh.trim=function(e,t,r){if((e=a7(e))&&(r||s===t))return tN(e);if(!e||!(t=n_(t)))return e;var n=tG(e),a=tG(t),o=tF(n,a),i=tP(n,a)+1;return nM(n,o,i).join("")},rh.trimEnd=function(e,t,r){if((e=a7(e))&&(r||s===t))return e.slice(0,tJ(e)+1);if(!e||!(t=n_(t)))return e;var n=tG(e),a=tP(n,tG(t))+1;return nM(n,0,a).join("")},rh.trimStart=function(e,t,r){if((e=a7(e))&&(r||s===t))return e.replace(ee,"");if(!e||!(t=n_(t)))return e;var n=tG(e),a=tF(n,tG(t));return nM(n,a).join("")},rh.truncate=function(e,t){var r=30,n="...";if(aH(t)){var a="separator"in t?t.separator:a;r="length"in t?a6(t.length):r,n="omission"in t?n_(t.omission):n}var o=(e=a7(e)).length;if(tU(e)){var i=tG(e);o=i.length}if(r>=o)return e;var l=r-tY(n);if(l<1)return n;var c=i?nM(i,0,l).join(""):e.slice(0,l);if(s===a)return c+n;if(i&&(l+=c.length-l),aZ(a)){if(e.slice(l).search(a)){var u,m=c;for(a.global||(a=eS(a.source,a7(ec.exec(a))+"g")),a.lastIndex=0;u=a.exec(m);)var d=u.index;c=c.slice(0,s===d?l:d)}}else if(e.indexOf(n_(a),l)!=l){var p=c.lastIndexOf(a);p>-1&&(c=c.slice(0,p))}return c+n},rh.unescape=function(e){return(e=a7(e))&&W.test(e)?e.replace(U,tZ):e},rh.uniqueId=function(e){var t=++eN;return a7(e)+t},rh.upperCase=oI,rh.upperFirst=oO,rh.each=ai,rh.eachRight=al,rh.first=sH,oU(rh,(et={},rV(rh,function(e,t){eM.call(rh.prototype,t)||(et[t]=e)}),et),{chain:!1}),rh.VERSION="4.18.1",tm(["bind","bindKey","curry","curryRight","partial","partialRight"],function(e){rh[e].placeholder=rh}),tm(["drop","take"],function(e,t){rb.prototype[e]=function(r){r=s===r?1:t2(a6(r),0);var n=this.__filtered__&&!t?new rb(this):this.clone();return n.__filtered__?n.__takeCount__=t3(r,n.__takeCount__):n.__views__.push({size:t3(r,0xffffffff),type:e+(n.__dir__<0?"Right":"")}),n},rb.prototype[e+"Right"]=function(t){return this.reverse()[e](t).reverse()}}),tm(["filter","map","takeWhile"],function(e,t){var r=t+1,n=1==r||3==r;rb.prototype[e]=function(e){var t=this.clone();return t.__iteratees__.push({iteratee:sc(e,3),type:r}),t.__filtered__=t.__filtered__||n,t}}),tm(["head","last"],function(e,t){var r="take"+(t?"Right":"");rb.prototype[e]=function(){return this[r](1).value()[0]}}),tm(["initial","tail"],function(e,t){var r="drop"+(t?"":"Right");rb.prototype[e]=function(){return this.__filtered__?new rb(this):this[r](1)}}),rb.prototype.compact=function(){return this.filter(oP)},rb.prototype.find=function(e){return this.filter(e).head()},rb.prototype.findLast=function(e){return this.reverse().find(e)},rb.prototype.invokeMap=nm(function(e,t){return"function"==typeof e?new rb(this):this.map(function(r){return r2(r,e,t)})}),rb.prototype.reject=function(e){return this.filter(aj(sc(e)))},rb.prototype.slice=function(e,t){e=a6(e);var r=this;return r.__filtered__&&(e>0||t<0)?new rb(r):(e<0?r=r.takeRight(-e):e&&(r=r.drop(e)),s!==t&&(r=(t=a6(t))<0?r.dropRight(-t):r.take(t-e)),r)},rb.prototype.takeRightWhile=function(e){return this.reverse().takeWhile(e).reverse()},rb.prototype.toArray=function(){return this.take(0xffffffff)},rV(rb.prototype,function(e,t){var r=/^(?:filter|find|map|reject)|While$/.test(t),n=/^(?:head|last)$/.test(t),a=rh[n?"take"+("last"==t?"Right":""):t],o=n||/^find/.test(t);a&&(rh.prototype[t]=function(){var t=this.__wrapped__,i=n?[1]:arguments,l=t instanceof rb,c=i[0],u=l||aR(t),m=function(e){var t=a.apply(rh,ty([e],i));return n&&d?t[0]:t};u&&r&&"function"==typeof c&&1!=c.length&&(l=u=!1);var d=this.__chain__,p=!!this.__actions__.length,h=o&&!d,f=l&&!p;if(!o&&u){t=f?t:new rb(this);var g=e.apply(t,i);return g.__actions__.push({func:ar,args:[m],thisArg:s}),new ry(g,d)}return h&&f?e.apply(this,i):(g=this.thru(m),h?n?g.value()[0]:g.value():g)})}),tm(["pop","push","shift","sort","splice","unshift"],function(e){var t=eT[e],r=/^(?:push|sort|unshift)$/.test(e)?"tap":"thru",n=/^(?:pop|shift)$/.test(e);rh.prototype[e]=function(){var e=arguments;if(n&&!this.__chain__){var s=this.value();return t.apply(aR(s)?s:[],e)}return this[r](function(r){return t.apply(aR(r)?r:[],e)})}}),rV(rb.prototype,function(e,t){var r=rh[t];if(r){var n=r.name+"";eM.call(ra,n)||(ra[n]=[]),ra[n].push({name:t,func:r})}}),ra[nK(s,2).name]=[{name:"wrapper",func:s}],rb.prototype.clone=function(){var e=new rb(this.__wrapped__);return e.__actions__=nz(this.__actions__),e.__dir__=this.__dir__,e.__filtered__=this.__filtered__,e.__iteratees__=nz(this.__iteratees__),e.__takeCount__=this.__takeCount__,e.__views__=nz(this.__views__),e},rb.prototype.reverse=function(){if(this.__filtered__){var e=new rb(this);e.__dir__=-1,e.__filtered__=!0}else e=this.clone(),e.__dir__*=-1;return e},rb.prototype.value=function(){var e=this.__wrapped__.value(),t=this.__dir__,r=aR(e),n=t<0,s=r?e.length:0,a=function(e,t,r){for(var n=-1,s=r.length;++n<s;){var a=r[n],o=a.size;switch(a.type){case"drop":e+=o;break;case"dropRight":t-=o;break;case"take":t=t3(t,e+o);break;case"takeRight":e=t2(e,t-o)}}return{start:e,end:t}}(0,s,this.__views__),o=a.start,i=a.end,l=i-o,c=n?i:o-1,u=this.__iteratees__,m=u.length,d=0,p=t3(l,this.__takeCount__);if(!r||!n&&s==l&&p==l)return nj(e,this.__actions__);var h=[];t:for(;l--&&d<p;){for(var f=-1,g=e[c+=t];++f<m;){var y=u[f],b=y.iteratee,k=y.type,v=b(g);if(2==k)g=v;else if(!v)if(1==k)continue t;else break t}h[d++]=g}return h},rh.prototype.at=an,rh.prototype.chain=function(){return at(this)},rh.prototype.commit=function(){return new ry(this.value(),this.__chain__)},rh.prototype.next=function(){this.__values__===s&&(this.__values__=a3(this.value()));var e=this.__index__>=this.__values__.length,t=e?s:this.__values__[this.__index__++];return{done:e,value:t}},rh.prototype.plant=function(e){for(var t,r=this;r instanceof rg;){var n=sP(r);n.__index__=0,n.__values__=s,t?a.__wrapped__=n:t=n;var a=n;r=r.__wrapped__}return a.__wrapped__=e,t},rh.prototype.reverse=function(){var e=this.__wrapped__;if(e instanceof rb){var t=e;return this.__actions__.length&&(t=new rb(this)),(t=t.reverse()).__actions__.push({func:ar,args:[sQ],thisArg:s}),new ry(t,this.__chain__)}return this.thru(sQ)},rh.prototype.toJSON=rh.prototype.valueOf=rh.prototype.value=function(){return nj(this.__wrapped__,this.__actions__)},rh.prototype.first=rh.prototype.head,e2&&(rh.prototype[e2]=function(){return this}),rh}();e4._=tK,s===(n=(function(){return tK}).call(t,r,t,e))||(e.exports=n)}).call(this)},863531(e,t,r){"use strict";let n;r.d(t,{D:()=>u,O:()=>c});var s=r(898026);let a=0,o=1/0,i=0,l=e=>{e.forEach(e=>{e.interactionId&&(o=Math.min(o,e.interactionId),a=(i=Math.max(i,e.interactionId))?(i-o)/7+1:0)})},c=()=>n?a:performance.interactionCount||0,u=()=>{"interactionCount"in performance||n||(n=(0,s.l)("event",l,{type:"event",buffered:!0,durationThreshold:0}))}},868888(e,t,r){"use strict";r.d(t,{G:()=>l});var n=r(290264),s=r(97407),a=r(680985),o=r(845226);let i=["EventTarget","Window","Node","ApplicationCache","AudioTrackList","BroadcastChannel","ChannelMergerNode","CryptoOperation","EventSource","FileReader","HTMLUnknownElement","IDBDatabase","IDBRequest","IDBTransaction","KeyOperation","MediaController","MessagePort","ModalWindow","Notification","SVGElementInstance","Screen","SharedWorker","TextTrack","TextTrackCue","TextTrackList","WebSocket","WebSocketWorker","Worker","XMLHttpRequest","XMLHttpRequestEventTarget","XMLHttpRequestUpload"],l=(0,n._C)((e={})=>{let t={XMLHttpRequest:!0,eventTarget:!0,requestAnimationFrame:!0,setInterval:!0,setTimeout:!0,...e};return{name:"BrowserApiErrors",setupOnce(){t.setTimeout&&(0,s.GS)(o.jf,"setTimeout",c),t.setInterval&&(0,s.GS)(o.jf,"setInterval",c),t.requestAnimationFrame&&(0,s.GS)(o.jf,"requestAnimationFrame",u),t.XMLHttpRequest&&"XMLHttpRequest"in o.jf&&(0,s.GS)(XMLHttpRequest.prototype,"send",m);let e=t.eventTarget;e&&(Array.isArray(e)?e:i).forEach(d)}}});function c(e){return function(...t){let r=t[0];return t[0]=(0,o.LV)(r,{mechanism:{data:{function:(0,a.qQ)(e)},handled:!1,type:"instrument"}}),e.apply(this,t)}}function u(e){return function(t){return e.apply(this,[(0,o.LV)(t,{mechanism:{data:{function:"requestAnimationFrame",handler:(0,a.qQ)(e)},handled:!1,type:"instrument"}})])}}function m(e){return function(...t){let r=this;return["onload","onerror","onprogress","onreadystatechange"].forEach(e=>{e in r&&"function"==typeof r[e]&&(0,s.GS)(r,e,function(t){let r={mechanism:{data:{function:e,handler:(0,a.qQ)(t)},handled:!1,type:"instrument"}},n=(0,s.sp)(t);return n&&(r.mechanism.data.handler=(0,a.qQ)(n)),(0,o.LV)(t,r)})}),e.apply(this,t)}}function d(e){let t=o.jf,r=t[e]&&t[e].prototype;r&&r.hasOwnProperty&&r.hasOwnProperty("addEventListener")&&((0,s.GS)(r,"addEventListener",function(t){return function(r,n,s){try{"function"==typeof n.handleEvent&&(n.handleEvent=(0,o.LV)(n.handleEvent,{mechanism:{data:{function:"handleEvent",handler:(0,a.qQ)(n),target:e},handled:!1,type:"instrument"}}))}catch(e){}return t.apply(this,[r,(0,o.LV)(n,{mechanism:{data:{function:"addEventListener",handler:(0,a.qQ)(n),target:e},handled:!1,type:"instrument"}}),s])}}),(0,s.GS)(r,"removeEventListener",function(e){return function(t,r,n){try{let s=r&&r.__sentry_wrapped__;s&&e.call(this,t,s,n)}catch(e){}return e.call(this,t,r,n)}}))}},869864(e,t,r){"use strict";r.d(t,{A:()=>l});var n=r(290266),s=r(545203),a=r(973594),o=r(728195),i=r(157392);let l=(0,s.kp)(i.Tl,(0,n.Ik)({type:(0,o.eu)(i.Z6.Address),value:a.UG}))},869949(e,t,r){"use strict";function n(e,t){return`${"production"===e?"metamask-extension":"metamask-extension-test"}@${t}`}r.d(t,{n:()=>n})},871008(e,t,r){"use strict";r.d(t,{Gu:()=>a,eR:()=>i,kS:()=>o});var n=r(520803),s=r(671054);function a(){return globalThis.stateHooks?.getSentryState?.()||{}}async function o(){var e,t;let r=(0,n.P)();if(r.ci&&r.sentry?.forceEnable)return{analyticsId:void 0,optedIn:!0,completedMetaMetricsOnboarding:!0};let o=a();if(o.state||o.persistedState)return i(o);try{return e=await globalThis.stateHooks.getPersistedState({reportErrors:!1}),l(e?.data)}catch(e){(0,s.wQ)("Error retrieving persisted state, falling back to backup",e);try{let{getBackupState:e}=globalThis.stateHooks;if(!e)return null;return t=await e(),l(t)}catch(e){return(0,s.wQ)("Error retrieving backup state",e),null}}}function i(e){if(e.persistedState){var t;return t=e.persistedState,l(t?.data)}if(e.state){let t=e.state;return"metamask"in t&&void 0!==t.metamask?function(e){let{analyticsId:t,completedMetaMetricsOnboarding:r,optedIn:n}=e;return{analyticsId:"string"==typeof t?t:void 0,optedIn:!0===n,completedMetaMetricsOnboarding:!0===r}}(t.metamask):l(t)}return null}function l(e){let t=u(e)?e:{},r=c(t.AnalyticsController),n=c(t.MetaMetricsController),{analyticsId:s,optedIn:a}=r??{};return{analyticsId:"string"==typeof s?s:void 0,optedIn:!0===a,completedMetaMetricsOnboarding:n?.completedMetaMetricsOnboarding===!0}}function c(e){return u(e)?e:void 0}function u(e){return!!e&&"object"==typeof e}},879516(e,t,r){"use strict";r.d(t,{u1:()=>s});var n=r(812805);function s(e){return function(e,t,r=String(e)){let s=function(e,t,r=null){return(0,n.Gv)(e)&&(0,n.i5)(e,t)?e[t]:r}(e,t);return"string"==typeof s?s:r}(e,"message")}},882555(e,t,r){"use strict";r.d(t,{W:()=>n});let n=()=>`v3-${Date.now()}-${Math.floor(Math.random()*(9e12-1))+1e12}`},884405(e,t,r){"use strict";r.d(t,{li:()=>f,mG:()=>p});var n=r(230337),s=r(696294),a=r(654761),o=r(40209),i=r(37853),l=r(276277),c=r(933190),u=r(125617),m=r(973234),d=r(719149);function p(e,t,r,p,f,g){var y,b;let{normalizeDepth:k=3,normalizeMaxBreadth:v=1e3}=e,_={...t,event_id:t.event_id||r.event_id||(0,s.eJ)(),timestamp:t.timestamp||(0,i.lu)()},w=r.integrations||e.integrations.map(e=>e.name);(function(e,t){let{environment:r,release:n,dist:s,maxValueLength:a=250}=t;"environment"in e||(e.environment="environment"in t?r:l.U),void 0===e.release&&void 0!==n&&(e.release=n),void 0===e.dist&&void 0!==s&&(e.dist=s),e.message&&(e.message=(0,o.xv)(e.message,a));let i=e.exception&&e.exception.values&&e.exception.values[0];i&&i.value&&(i.value=(0,o.xv)(i.value,a));let c=e.request;c&&c.url&&(c.url=(0,o.xv)(c.url,a))})(_,e),y=_,(b=w).length>0&&(y.sdk=y.sdk||{},y.sdk.integrations=[...y.sdk.integrations||[],...b]),f&&f.emit("applyFrameMetadata",t),void 0===t.type&&function(e,t){let r,s=n.O._sentryDebugIds;if(!s)return;let a=h.get(t);a?r=a:(r=new Map,h.set(t,r));let o=Object.entries(s).reduce((e,[n,s])=>{let a,o=r.get(n);o?a=o:(a=t(n),r.set(n,a));for(let t=a.length-1;t>=0;t--){let r=a[t];if(r.filename){e[r.filename]=s;break}}return e},{});try{e.exception.values.forEach(e=>{e.stacktrace.frames.forEach(e=>{e.filename&&(e.debug_id=o[e.filename])})})}catch(e){}}(_,e.stackParser);let x=function(e,t){if(!t)return e;let r=e?e.clone():new m.H;return r.update(t),r}(p,r.captureContext);r.mechanism&&(0,s.M6)(_,r.mechanism);let S=f?f.getEventProcessors():[],E=(0,c.m6)().getScopeData();if(g){let e=g.getScopeData();(0,d.Rg)(E,e)}if(x){let e=x.getScopeData();(0,d.Rg)(E,e)}let j=[...r.attachments||[],...E.attachments];j.length&&(r.attachments=j),(0,d.e2)(_,E);let T=[...S,...E.eventProcessors];return(0,u.j)(T,_,r).then(e=>(e&&function(e){let t={};try{e.exception.values.forEach(e=>{e.stacktrace.frames.forEach(e=>{e.debug_id&&(e.abs_path?t[e.abs_path]=e.debug_id:e.filename&&(t[e.filename]=e.debug_id),delete e.debug_id)})})}catch(e){}if(0===Object.keys(t).length)return;e.debug_meta=e.debug_meta||{},e.debug_meta.images=e.debug_meta.images||[];let r=e.debug_meta.images;Object.entries(t).forEach(([e,t])=>{r.push({type:"sourcemap",code_file:e,debug_id:t})})}(e),"number"==typeof k&&k>0)?function(e,t,r){if(!e)return null;let n={...e,...e.breadcrumbs&&{breadcrumbs:e.breadcrumbs.map(e=>({...e,...e.data&&{data:(0,a.S8)(e.data,t,r)}}))},...e.user&&{user:(0,a.S8)(e.user,t,r)},...e.contexts&&{contexts:(0,a.S8)(e.contexts,t,r)},...e.extra&&{extra:(0,a.S8)(e.extra,t,r)}};return e.contexts&&e.contexts.trace&&n.contexts&&(n.contexts.trace=e.contexts.trace,e.contexts.trace.data&&(n.contexts.trace.data=(0,a.S8)(e.contexts.trace.data,t,r))),e.spans&&(n.spans=e.spans.map(e=>({...e,...e.data&&{data:(0,a.S8)(e.data,t,r)}}))),n}(e,k,v):e)}let h=new WeakMap;function f(e){if(e){var t;return(t=e)instanceof m.H||"function"==typeof t||Object.keys(e).some(e=>g.includes(e))?{captureContext:e}:e}}let g=["user","level","extra","contexts","tags","fingerprint","requestSession","propagationContext"]},884488(e,t,r){"use strict";r.d(t,{v:()=>c});var n=r(37853),s=r(608119),a=r(137891),o=r(901814),i=r(153839),l=r(837971);class c{constructor(e){this._client=e,this._buckets=new Map,this._interval=setInterval(()=>this.flush(),a.yQ)}add(e,t,r,o="none",c={},u=(0,n.zf)()){let m=Math.floor(u),d=(0,l.T3)(t),p=(0,l.VZ)(c),h=(0,l.Mz)(o),f=(0,l.eG)(e,d,h,p),g=this._buckets.get(f),y=g&&e===a.fN?g.metric.weight:0;g?(g.metric.add(r),g.timestamp<m&&(g.timestamp=m)):(g={metric:new i.wz[e](r),timestamp:m,metricType:e,name:d,unit:h,tags:p},this._buckets.set(f,g));let b="string"==typeof r?g.metric.weight-y:r;(0,s.r2)(e,d,b,h,c,f)}flush(){if(0===this._buckets.size)return;let e=Array.from(this._buckets.values());(0,o.$)(this._client,e),this._buckets.clear()}close(){clearInterval(this._interval),this.flush()}}},895315(e,t,r){"use strict";r.d(t,{AD:()=>c,SB:()=>o,hH:()=>i});var n=r(562298),s=r(107842);let a=/^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;function o(e,t=!1){let{host:r,path:n,pass:s,port:a,projectId:i,protocol:l,publicKey:c}=e;return`${l}://${c}${t&&s?`:${s}`:""}@${r}${a?`:${a}`:""}/${n?`${n}/`:n}${i}`}function i(e){let t=a.exec(e);if(!t)return void(0,s.pq)(()=>{console.error(`Invalid Sentry Dsn: ${e}`)});let[r,n,o="",i="",c="",u=""]=t.slice(1),m="",d=u,p=d.split("/");if(p.length>1&&(m=p.slice(0,-1).join("/"),d=p.pop()),d){let e=d.match(/^\d+/);e&&(d=e[0])}return l({host:i,pass:o,path:m,projectId:d,port:c,protocol:r,publicKey:n})}function l(e){return{protocol:e.protocol,publicKey:e.publicKey||"",pass:e.pass||"",host:e.host,port:e.port||"",path:e.path||"",projectId:e.projectId}}function c(e){let t="string"==typeof e?i(e):l(e);if(t&&function(e){if(!n.T)return!0;let{port:t,projectId:r,protocol:a}=e;return!["protocol","publicKey","host","projectId"].find(t=>!e[t]&&(s.vF.error(`Invalid Sentry Dsn: ${t} missing`),!0))&&(r.match(/^\d+$/)?"http"!==a&&"https"!==a?(s.vF.error(`Invalid Sentry Dsn: Invalid protocol ${a}`),!1):!(t&&isNaN(parseInt(t,10)))||(s.vF.error(`Invalid Sentry Dsn: Invalid port ${t}`),!1):(s.vF.error(`Invalid Sentry Dsn: Invalid projectId ${r}`),!1))}(t))return t}},898026(e,t,r){"use strict";r.d(t,{l:()=>n});let n=(e,t,r)=>{try{if(PerformanceObserver.supportedEntryTypes.includes(e)){let n=new PerformanceObserver(e=>{Promise.resolve().then(()=>{t(e.getEntries())})});return n.observe(Object.assign({type:e,buffered:!0},r||{})),n}}catch(e){}}},901814(e,t,r){"use strict";r.d(t,{$:()=>i});var n=r(895315),s=r(107842),a=r(85182),o=r(837971);function i(e,t){s.vF.log(`Flushing aggregated metrics, number of metrics: ${t.length}`);let r=e.getDsn(),i=function(e,t,r,s){let i={sent_at:new Date().toISOString()};r&&r.sdk&&(i.sdk={name:r.sdk.name,version:r.sdk.version}),s&&t&&(i.dsn=(0,n.SB)(t));let l=function(e){let t=(0,o.ik)(e);return[{type:"statsd",length:t.length},t]}(e);return(0,a.h4)(i,[l])}(t,r,e.getSdkMetadata(),e.getOptions().tunnel);e.sendEnvelope(i)}},902419(e,t,r){"use strict";r.d(t,{T:()=>n});let n="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__},903226(e,t,r){"use strict";r.d(t,{BP:()=>c});var a=r(107842),o=r(85182),i=r(425535),l=r(67904);function c(e){function t(...e){l.T&&a.vF.info("[Offline]:",...e)}return r=>{let a,l=e(r);if(!r.createStore)throw Error("No `createStore` function was provided");let c=r.createStore(r),u=5e3;function m(e){a&&s(a),"number"!=typeof(a=n(async()=>{a=void 0;let e=await c.shift();e&&(t("Attempting to send previously queued event"),e[0].sent_at=new Date().toISOString(),p(e,!0).catch(e=>{t("Failed to retry sending",e)}))},e))&&a.unref&&a.unref()}function d(){a||(m(u),u=Math.min(2*u,36e5))}async function p(e,n=!1){if(!n&&(0,o.hP)(e,["replay_event","replay_recording"]))return await c.push(e),m(100),{};try{let t=await l.send(e),r=100;if(t){if(t.headers&&t.headers["retry-after"])r=(0,i.FA)(t.headers["retry-after"]);else if(t.headers&&t.headers["x-sentry-rate-limits"])r=6e4;else if((t.statusCode||0)>=400)return t}return m(r),u=5e3,t}catch(a){var s;if(await (s=u,!(0,o.hP)(e,["client_report"])&&(!r.shouldStore||r.shouldStore(e,a,s))))return n?await c.unshift(e):await c.push(e),d(),t("Error sending. Event queued.",a),{};throw a}}return r.flushAtStartup&&d(),{send:p,flush:e=>l.flush(e)}}}},906769(e,t,r){"use strict";function n(){return"undefined"!=typeof __SENTRY_BROWSER_BUNDLE__&&!!__SENTRY_BROWSER_BUNDLE__}function s(){return"npm"}r.d(t,{Z:()=>n,e:()=>s})},921766(e,t,r){"use strict";r.d(t,{A:()=>n});let n=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i},925752(e,t,r){"use strict";r.d(t,{A:()=>l});var n=r(208570),s=r(951906),a=r(316244);function o(e,t){let r="";for(let n of e)n.literal?r+=n.val:r+=t(n.val);return r}let i={D:s.aY,DD:s.g5,DDD:s.Rb,DDDD:s.d6,t:s.dz,tt:s.hF,ttt:s.oq,tttt:s.o,T:s.My,TT:s.cE,TTT:s.dO,TTTT:s.FX,f:s.DN,ff:s.pM,fff:s.Al,ffff:s.MC,F:s.h0,FF:s.AX,FFF:s.h3,FFFF:s.nt};class l{static create(e,t={}){return new l(e,t)}static parseFormat(e){let t=null,r="",n=!1,s=[];for(let a=0;a<e.length;a++){let o=e.charAt(a);"'"===o?(r.length>0&&s.push({literal:n||/^\s+$/.test(r),val:r}),t=null,r="",n=!n):n||o===t?r+=o:(r.length>0&&s.push({literal:/^\s+$/.test(r),val:r}),r=o,t=o)}return r.length>0&&s.push({literal:n||/^\s+$/.test(r),val:r}),s}static macroTokenToFormatOpts(e){return i[e]}constructor(e,t){this.opts=t,this.loc=e,this.systemLoc=null}formatWithSystemDefault(e,t){return null===this.systemLoc&&(this.systemLoc=this.loc.redefaultToSystem()),this.systemLoc.dtFormatter(e,{...this.opts,...t}).format()}dtFormatter(e,t={}){return this.loc.dtFormatter(e,{...this.opts,...t})}formatDateTime(e,t){return this.dtFormatter(e,t).format()}formatDateTimeParts(e,t){return this.dtFormatter(e,t).formatToParts()}formatInterval(e,t){return this.dtFormatter(e.start,t).dtf.formatRange(e.start.toJSDate(),e.end.toJSDate())}resolvedOptions(e,t){return this.dtFormatter(e,t).resolvedOptions()}num(e,t=0){if(this.opts.forceSimple)return(0,a.CF)(e,t);let r={...this.opts};return t>0&&(r.padTo=t),this.loc.numberFormatter(r).format(e)}formatDateTimeFromString(e,t){let r="en"===this.loc.listingMode(),s=this.loc.outputCalendar&&"gregory"!==this.loc.outputCalendar,a=(t,r)=>this.loc.extract(e,t,r),i=t=>e.isOffsetFixed&&0===e.offset&&t.allowZ?"Z":e.isValid?e.zone.formatOffset(e.ts,t.format):"",c=(t,s)=>r?n.zH(e,t):a(s?{month:t}:{month:t,day:"numeric"},"month"),u=(t,s)=>r?n.DJ(e,t):a(s?{weekday:t}:{weekday:t,month:"long",day:"numeric"},"weekday"),m=t=>{let r=l.macroTokenToFormatOpts(t);return r?this.formatWithSystemDefault(e,r):t},d=t=>r?n.xS(e,t):a({era:t},"era"),p=t=>{switch(t){case"S":return this.num(e.millisecond);case"u":case"SSS":return this.num(e.millisecond,3);case"s":return this.num(e.second);case"ss":return this.num(e.second,2);case"uu":return this.num(Math.floor(e.millisecond/10),2);case"uuu":return this.num(Math.floor(e.millisecond/100));case"m":return this.num(e.minute);case"mm":return this.num(e.minute,2);case"h":return this.num(e.hour%12==0?12:e.hour%12);case"hh":return this.num(e.hour%12==0?12:e.hour%12,2);case"H":return this.num(e.hour);case"HH":return this.num(e.hour,2);case"Z":return i({format:"narrow",allowZ:this.opts.allowZ});case"ZZ":return i({format:"short",allowZ:this.opts.allowZ});case"ZZZ":return i({format:"techie",allowZ:this.opts.allowZ});case"ZZZZ":return e.zone.offsetName(e.ts,{format:"short",locale:this.loc.locale});case"ZZZZZ":return e.zone.offsetName(e.ts,{format:"long",locale:this.loc.locale});case"z":return e.zoneName;case"a":return r?n.tz(e):a({hour:"numeric",hourCycle:"h12"},"dayperiod");case"d":return s?a({day:"numeric"},"day"):this.num(e.day);case"dd":return s?a({day:"2-digit"},"day"):this.num(e.day,2);case"c":case"E":return this.num(e.weekday);case"ccc":return u("short",!0);case"cccc":return u("long",!0);case"ccccc":return u("narrow",!0);case"EEE":return u("short",!1);case"EEEE":return u("long",!1);case"EEEEE":return u("narrow",!1);case"L":return s?a({month:"numeric",day:"numeric"},"month"):this.num(e.month);case"LL":return s?a({month:"2-digit",day:"numeric"},"month"):this.num(e.month,2);case"LLL":return c("short",!0);case"LLLL":return c("long",!0);case"LLLLL":return c("narrow",!0);case"M":return s?a({month:"numeric"},"month"):this.num(e.month);case"MM":return s?a({month:"2-digit"},"month"):this.num(e.month,2);case"MMM":return c("short",!1);case"MMMM":return c("long",!1);case"MMMMM":return c("narrow",!1);case"y":return s?a({year:"numeric"},"year"):this.num(e.year);case"yy":return s?a({year:"2-digit"},"year"):this.num(e.year.toString().slice(-2),2);case"yyyy":return s?a({year:"numeric"},"year"):this.num(e.year,4);case"yyyyyy":return s?a({year:"numeric"},"year"):this.num(e.year,6);case"G":return d("short");case"GG":return d("long");case"GGGGG":return d("narrow");case"kk":return this.num(e.weekYear.toString().slice(-2),2);case"kkkk":return this.num(e.weekYear,4);case"W":return this.num(e.weekNumber);case"WW":return this.num(e.weekNumber,2);case"n":return this.num(e.localWeekNumber);case"nn":return this.num(e.localWeekNumber,2);case"ii":return this.num(e.localWeekYear.toString().slice(-2),2);case"iiii":return this.num(e.localWeekYear,4);case"o":return this.num(e.ordinal);case"ooo":return this.num(e.ordinal,3);case"q":return this.num(e.quarter);case"qq":return this.num(e.quarter,2);case"X":return this.num(Math.floor(e.ts/1e3));case"x":return this.num(e.ts);default:return m(t)}};return o(l.parseFormat(t),p)}formatDurationFromString(e,t){let r=e=>{switch(e[0]){case"S":return"millisecond";case"s":return"second";case"m":return"minute";case"h":return"hour";case"d":return"day";case"w":return"week";case"M":return"month";case"y":return"year";default:return null}},n=e=>t=>{let n=r(t);return n?this.num(e.get(n),t.length):t},s=l.parseFormat(t),a=s.reduce((e,{literal:t,val:r})=>t?e:e.concat(r),[]);return o(s,n(e.shiftTo(...a.map(r).filter(e=>e))))}}},928535(e,t,r){"use strict";let n;r.d(t,{y:()=>D});var s,a,o,i=r(834529),l=r(290264);function c(e,t,r=1/0,n=0){return!e||e.nodeType!==e.ELEMENT_NODE||n>r?-1:t(e)?n:c(e.parentNode,t,r,n+1)}function u(e,t){return r=>{if(null===r)return!1;try{if(e){if("string"==typeof e){if(r.matches(`.${e}`))return!0}else if(function(e,t){for(let r=e.classList.length;r--;){let n=e.classList[r];if(t.test(n))return!0}return!1}(r,e))return!0}if(t&&r.matches(t))return!0;return!1}catch(e){return!1}}}(s=o||(o={}))[s.Document=0]="Document",s[s.DocumentType=1]="DocumentType",s[s.Element=2]="Element",s[s.Text=3]="Text",s[s.CDATA=4]="CDATA",s[s.Comment=5]="Comment";let m=`Please stop import mirror directly. Instead of that,\r
now you can use replayer.getMirror() to access the mirror instance of a replayer,\r
or you can use record.mirror to access the mirror instance during recording.`,d={map:{},getId:()=>(console.error(m),-1),getNode:()=>(console.error(m),null),removeNodeFromMap(){console.error(m)},has:()=>(console.error(m),!1),reset(){console.error(m)}};function p(e,t,r,n,s=window){let a=s.Object.getOwnPropertyDescriptor(e,t);return s.Object.defineProperty(e,t,n?r:{set(e){k(()=>{r.set.call(this,e)},0),a&&a.set&&a.set.call(this,e)}}),()=>p(e,t,a||{},!0)}function h(e,t,r){try{if(!(t in e))return()=>{};let n=e[t],s=r(n);return"function"==typeof s&&(s.prototype=s.prototype||{},Object.defineProperties(s,{__rrweb_original__:{enumerable:!1,value:n}})),e[t]=s,()=>{e[t]=n}}catch(e){return()=>{}}}function f(e,t,r,n,s){if(!e)return!1;let a=e?e.nodeType===e.ELEMENT_NODE?e:e.parentElement:null;if(!a)return!1;let o=u(t,r);if(!s){let e=n&&a.matches(n);return o(a)&&!e}let i=c(a,o),l=-1;return!(i<0)&&(n&&(l=c(a,u(null,n))),i>-1&&l<0||i<l)}"undefined"!=typeof window&&window.Proxy&&window.Reflect&&(d=new Proxy(d,{get:(e,t,r)=>("map"===t&&console.error(m),Reflect.get(e,t,r))})),/[1-9][0-9]{12}/.test(Date.now().toString());let g={};function y(e){let t=g[e];if(t)return t;let r=window.document,n=window[e];if(r&&"function"==typeof r.createElement)try{let t=r.createElement("iframe");t.hidden=!0,r.head.appendChild(t);let s=t.contentWindow;s&&s[e]&&(n=s[e]),r.head.removeChild(t)}catch(e){}return g[e]=n.bind(window)}function b(...e){return y("requestAnimationFrame")(...e)}function k(...e){return y("setTimeout")(...e)}var v=((a=v||{})[a["2D"]=0]="2D",a[a.WebGL=1]="WebGL",a[a.WebGL2=2]="WebGL2",a);let _=e=>n?(...t)=>{try{return e(...t)}catch(e){if(n&&!0===n(e))return()=>{};throw e}}:e;for(var w="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",x="undefined"==typeof Uint8Array?[]:new Uint8Array(256),S=0;S<w.length;S++)x[w.charCodeAt(S)]=S;var E=function(e){var t,r=new Uint8Array(e),n=r.length,s="";for(t=0;t<n;t+=3)s+=w[r[t]>>2],s+=w[(3&r[t])<<4|r[t+1]>>4],s+=w[(15&r[t+1])<<2|r[t+2]>>6],s+=w[63&r[t+2]];return n%3==2?s=s.substring(0,s.length-1)+"=":n%3==1&&(s=s.substring(0,s.length-2)+"=="),s};let j=new Map,T=(e,t,r)=>{let n;if(!e||!(C(e,t)||"object"==typeof e))return;let s=e.constructor.name,a=((n=j.get(r))||(n=new Map,j.set(r,n)),n.has(s)||n.set(s,[]),n.get(s)),o=a.indexOf(e);return -1===o&&(o=a.length,a.push(e)),o},A=(e,t,r)=>e.map(e=>(function e(t,r,n){if(t instanceof Array)return t.map(t=>e(t,r,n));if(null===t);else if(t instanceof Float32Array||t instanceof Float64Array||t instanceof Int32Array||t instanceof Uint32Array||t instanceof Uint8Array||t instanceof Uint16Array||t instanceof Int16Array||t instanceof Int8Array||t instanceof Uint8ClampedArray)return{rr_type:t.constructor.name,args:[Object.values(t)]};else if(t instanceof ArrayBuffer)return{rr_type:t.constructor.name,base64:E(t)};else if(t instanceof DataView)return{rr_type:t.constructor.name,args:[e(t.buffer,r,n),t.byteOffset,t.byteLength]};else if(t instanceof HTMLImageElement){let e=t.constructor.name,{src:r}=t;return{rr_type:e,src:r}}else if(t instanceof HTMLCanvasElement)return{rr_type:"HTMLImageElement",src:t.toDataURL()};else if(t instanceof ImageData)return{rr_type:t.constructor.name,args:[e(t.data,r,n),t.width,t.height]};else if(C(t,r)||"object"==typeof t)return{rr_type:t.constructor.name,index:T(t,r,n)};return t})(e,t,r)),C=(e,t)=>!!["WebGLActiveInfo","WebGLBuffer","WebGLFramebuffer","WebGLProgram","WebGLRenderbuffer","WebGLShader","WebGLShaderPrecisionFormat","WebGLTexture","WebGLUniformLocation","WebGLVertexArrayObject","WebGLVertexArrayObjectOES"].filter(e=>"function"==typeof t[e]).find(r=>e instanceof t[r]);function I(e,t,r,n,s){let a=[];try{let o=h(e.HTMLCanvasElement.prototype,"getContext",function(e){return function(a,...o){if(!f(this,t,r,n,!0)){let e="experimental-webgl"===a?"webgl":a;if("__context"in this||(this.__context=e),s&&["webgl","webgl2"].includes(e))if(o[0]&&"object"==typeof o[0]){let e=o[0];e.preserveDrawingBuffer||(e.preserveDrawingBuffer=!0)}else o.splice(0,1,{preserveDrawingBuffer:!0})}return e.apply(this,[a,...o])}});a.push(o)}catch(e){console.error("failed to patch HTMLCanvasElement.prototype.getContext")}return()=>{a.forEach(e=>e())}}function O(e,t,r,n,s,a,o,i){let l=[];for(let o of Object.getOwnPropertyNames(e))if(!["isContextLost","canvas","drawingBufferWidth","drawingBufferHeight"].includes(o))try{if("function"!=typeof e[o])continue;let c=h(e,o,function(e){return function(...l){let c=e.apply(this,l);if(T(c,i,this),"tagName"in this.canvas&&!f(this.canvas,n,s,a,!0)){let e=A(l,i,this),n={type:t,property:o,args:e};r(this.canvas,n)}return c}});l.push(c)}catch(s){let n=p(e,o,{set(e){r(this.canvas,{type:t,property:o,args:[e],setter:!0})}});l.push(n)}return l}class M{reset(){this.pendingCanvasMutations.clear(),this.restoreHandlers.forEach(e=>{try{e()}catch(e){}}),this.restoreHandlers=[],this.windowsSet=new WeakSet,this.windows=[],this.shadowDoms=new Set,(0,i.z)([this,"access",e=>e.worker,"optionalAccess",e=>e.terminate,"call",e=>e()]),this.worker=null,this.snapshotInProgressMap=new Map,(this.options.recordCanvas&&"number"==typeof this.options.sampling||this.options.enableManualSnapshot)&&(this.worker=this.initFPSWorker())}freeze(){this.frozen=!0}unfreeze(){this.frozen=!1}lock(){this.locked=!0}unlock(){this.locked=!1}constructor(e){this.pendingCanvasMutations=new Map,this.rafStamps={latestId:0,invokeId:null},this.shadowDoms=new Set,this.windowsSet=new WeakSet,this.windows=[],this.restoreHandlers=[],this.frozen=!1,this.locked=!1,this.snapshotInProgressMap=new Map,this.worker=null,this.processMutation=(e,t)=>{(this.rafStamps.invokeId&&this.rafStamps.latestId!==this.rafStamps.invokeId||!this.rafStamps.invokeId)&&(this.rafStamps.invokeId=this.rafStamps.latestId),this.pendingCanvasMutations.has(e)||this.pendingCanvasMutations.set(e,[]),this.pendingCanvasMutations.get(e).push(t)};let{sampling:t="all",win:r,blockClass:s,blockSelector:a,unblockSelector:o,maxCanvasSize:i,recordCanvas:l,dataURLOptions:c,errorHandler:u}=e;if(this.mutationCb=e.mutationCb,this.mirror=e.mirror,this.options=e,u&&(n=u),(l&&"number"==typeof t||e.enableManualSnapshot)&&(this.worker=this.initFPSWorker()),this.addWindow(r),e.enableManualSnapshot)return;_(()=>{l&&"all"===t&&(this.startRAFTimestamping(),this.startPendingCanvasMutationFlusher()),l&&"number"==typeof t&&this.initCanvasFPSObserver(t,s,a,o,i,{dataURLOptions:c})})()}addWindow(e){let{sampling:t="all",blockClass:r,blockSelector:n,unblockSelector:s,recordCanvas:a,enableManualSnapshot:o}=this.options;if(!this.windowsSet.has(e)){if(o){this.windowsSet.add(e),this.windows.push(new WeakRef(e));return}_(()=>{if(a&&"all"===t&&this.initCanvasMutationObserver(e,r,n,s),a&&"number"==typeof t){let t=I(e,r,n,s,!0);this.restoreHandlers.push(()=>{t()})}})(),this.windowsSet.add(e),this.windows.push(new WeakRef(e))}}addShadowRoot(e){this.shadowDoms.add(new WeakRef(e))}resetShadowRoots(){this.shadowDoms=new Set}initFPSWorker(){let e=new Worker(function(){let e=new Blob(['for(var e="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",t="undefined"==typeof Uint8Array?[]:new Uint8Array(256),a=0;a<64;a++)t[e.charCodeAt(a)]=a;var n=function(t){var a,n=new Uint8Array(t),r=n.length,s="";for(a=0;a<r;a+=3)s+=e[n[a]>>2],s+=e[(3&n[a])<<4|n[a+1]>>4],s+=e[(15&n[a+1])<<2|n[a+2]>>6],s+=e[63&n[a+2]];return r%3==2?s=s.substring(0,s.length-1)+"=":r%3==1&&(s=s.substring(0,s.length-2)+"=="),s};const r=new Map,s=new Map;const i=self;i.onmessage=async function(e){if(!("OffscreenCanvas"in globalThis))return i.postMessage({id:e.data.id});{const{id:t,bitmap:a,width:o,height:f,maxCanvasSize:c,dataURLOptions:g}=e.data,u=async function(e,t,a){const r=e+"-"+t;if("OffscreenCanvas"in globalThis){if(s.has(r))return s.get(r);const i=new OffscreenCanvas(e,t);i.getContext("2d");const o=await i.convertToBlob(a),f=await o.arrayBuffer(),c=n(f);return s.set(r,c),c}return""}(o,f,g),[h,d]=function(e,t,a){if(!a)return[e,t];const[n,r]=a;if(e<=n&&t<=r)return[e,t];let s=e,i=t;return s>n&&(i=Math.floor(n*t/e),s=n),i>r&&(s=Math.floor(r*e/t),i=r),[s,i]}(o,f,c),l=new OffscreenCanvas(h,d),w=l.getContext("bitmaprenderer"),p=h===o&&d===f?a:await createImageBitmap(a,{resizeWidth:h,resizeHeight:d,resizeQuality:"low"});w.transferFromImageBitmap(p),a.close();const y=await l.convertToBlob(g),v=y.type,b=await y.arrayBuffer(),m=n(b);if(p.close(),!r.has(t)&&await u===m)return r.set(t,m),i.postMessage({id:t});if(r.get(t)===m)return i.postMessage({id:t});i.postMessage({id:t,type:v,base64:m,width:o,height:f}),r.set(t,m)}};']);return URL.createObjectURL(e)}());return e.onmessage=e=>{let t=e.data,{id:r}=t;if(this.snapshotInProgressMap.set(r,!1),!("base64"in t))return;let{base64:n,type:s,width:a,height:o}=t;this.mutationCb({id:r,type:v["2D"],commands:[{property:"clearRect",args:[0,0,a,o]},{property:"drawImage",args:[{rr_type:"ImageBitmap",args:[{rr_type:"Blob",data:[{rr_type:"ArrayBuffer",base64:n}],type:s}]},0,0,a,o]}]})},e}initCanvasFPSObserver(e,t,r,n,s,a){let o=this.takeSnapshot(!1,e,t,r,n,s,a.dataURLOptions);this.restoreHandlers.push(()=>{cancelAnimationFrame(o)})}initCanvasMutationObserver(e,t,r,n){let s=I(e,t,r,n,!1),a=function(e,t,r,n,s){let a=[];for(let o of Object.getOwnPropertyNames(t.CanvasRenderingContext2D.prototype))try{if("function"!=typeof t.CanvasRenderingContext2D.prototype[o])continue;let i=h(t.CanvasRenderingContext2D.prototype,o,function(a){return function(...i){return f(this.canvas,r,n,s,!0)||k(()=>{let r=A(i,t,this);e(this.canvas,{type:v["2D"],property:o,args:r})},0),a.apply(this,i)}});a.push(i)}catch(n){let r=p(t.CanvasRenderingContext2D.prototype,o,{set(t){e(this.canvas,{type:v["2D"],property:o,args:[t],setter:!0})}});a.push(r)}return()=>{a.forEach(e=>e())}}(this.processMutation.bind(this),e,t,r,n),o=function(e,t,r,n,s,a){let o=[];return o.push(...O(t.WebGLRenderingContext.prototype,v.WebGL,e,r,n,s,a,t)),void 0!==t.WebGL2RenderingContext&&o.push(...O(t.WebGL2RenderingContext.prototype,v.WebGL2,e,r,n,s,a,t)),()=>{o.forEach(e=>e())}}(this.processMutation.bind(this),e,t,r,n,this.mirror);this.restoreHandlers.push(()=>{s(),a(),o()})}snapshot(e){let{options:t}=this,r=this.takeSnapshot(!0,"all"===t.sampling?2:t.sampling||2,t.blockClass,t.blockSelector,t.unblockSelector,t.maxCanvasSize,t.dataURLOptions,e);this.restoreHandlers.push(()=>{cancelAnimationFrame(r)})}takeSnapshot(e,t,r,n,s,a,o,l){let c=1e3/t,u=0,m=e=>{if(e)return[e];let t=[],a=e=>{e.querySelectorAll("canvas").forEach(e=>{f(e,r,n,s,!0)||t.push(e)})};for(let e of this.windows){let t=e.deref();t&&a(t.document)}for(let e of this.shadowDoms){let t=e.deref();t&&a(t)}return t},d=t=>{if(this.windows.length){if(u&&t-u<c)return void b(d);u=t,m(l).forEach(t=>{if(!this.mirror.hasNode(t))return;let r=this.mirror.getId(t);if(!this.snapshotInProgressMap.get(r)&&t.width&&t.height){if(this.snapshotInProgressMap.set(r,!0),!e&&["webgl","webgl2"].includes(t.__context)){let e=t.getContext(t.__context);!1===(0,i.z)([e,"optionalAccess",e=>e.getContextAttributes,"call",e=>e(),"optionalAccess",e=>e.preserveDrawingBuffer])&&e.clear(e.COLOR_BUFFER_BIT)}createImageBitmap(t).then(e=>{(0,i.z)([this,"access",e=>e.worker,"optionalAccess",e=>e.postMessage,"call",n=>n({id:r,bitmap:e,width:t.width,height:t.height,dataURLOptions:o,maxCanvasSize:a},[e])])}).catch(e=>{_(()=>{throw e})()})}}),e||b(d)}};return b(d)}startPendingCanvasMutationFlusher(){b(()=>this.flushPendingCanvasMutations())}startRAFTimestamping(){let e=t=>{this.rafStamps.latestId=t,b(e)};b(e)}flushPendingCanvasMutations(){this.pendingCanvasMutations.forEach((e,t)=>{let r=this.mirror.getId(t);this.flushPendingCanvasMutationFor(t,r)}),b(()=>this.flushPendingCanvasMutations())}flushPendingCanvasMutationFor(e,t){if(this.frozen||this.locked)return;let r=this.pendingCanvasMutations.get(e);if(!r||-1===t)return;let n=r.map(e=>{let{type:t,...r}=e;return r}),{type:s}=r[0];this.mutationCb({id:t,type:s,commands:n}),this.pendingCanvasMutations.delete(e)}}let N={low:{sampling:{canvas:1},dataURLOptions:{type:"image/webp",quality:.25}},medium:{sampling:{canvas:2},dataURLOptions:{type:"image/webp",quality:.4}},high:{sampling:{canvas:4},dataURLOptions:{type:"image/webp",quality:.5}}},D=(0,l._C)((e={})=>{let t,[r,n]=e.maxCanvasSize||[],s={quality:e.quality||"medium",enableManualSnapshot:e.enableManualSnapshot,maxCanvasSize:[r?Math.min(r,1280):1280,n?Math.min(n,1280):1280]},a=new Promise(e=>t=e);return{name:"ReplayCanvas",getOptions(){let{quality:e,enableManualSnapshot:r,maxCanvasSize:n}=s;return{enableManualSnapshot:r,recordCanvas:!0,getCanvasManager:e=>{let s=new M({...e,enableManualSnapshot:r,maxCanvasSize:n,errorHandler:e=>{try{"object"==typeof e&&(e.__rrweb__=!0)}catch(e){}}});return t(s),s},...N[e||"medium"]||N.medium}},async snapshot(e){(await a).snapshot(e)}}})},932294(e,t,r){"use strict";let n,s,a,o,i;r.d(t,{Pt:()=>v,T5:()=>_,YG:()=>w,a9:()=>k,hT:()=>x,tC:()=>D,wv:()=>S});var l=r(107842),c=r(680985),u=r(756025),m=r(417860),d=r(406097),p=r(764651),h=r(459517),f=r(898026),g=r(185335);let y={},b={};function k(e,t=!1){return O("cls",e,j,n,t)}function v(e,t=!1){return O("lcp",e,A,a,t)}function _(e){return O("fid",e,T,s)}function w(e){return O("ttfb",e,C,o)}function x(e){return O("inp",e,I,i)}function S(e,t){return M(e,t),b[e]||(function(e){let t={};"event"===e&&(t.durationThreshold=0),(0,f.l)(e,t=>{E(e,{entries:t})},t)}(e),b[e]=!0),N(e,t)}function E(e,t){let r=y[e];if(r&&r.length)for(let n of r)try{n(t)}catch(t){u.T&&l.vF.error(`Error while triggering instrumentation handler.
Type: ${e}
Name: ${(0,c.qQ)(n)}
Error:`,t)}}function j(){return(0,m.I)(e=>{E("cls",{metric:e}),n=e},{reportAllChanges:!0})}function T(){return(0,d.l)(e=>{E("fid",{metric:e}),s=e})}function A(){return(0,h.f)(e=>{E("lcp",{metric:e}),a=e},{reportAllChanges:!0})}function C(){return(0,g.C)(e=>{E("ttfb",{metric:e}),o=e})}function I(){return(0,p.r)(e=>{E("inp",{metric:e}),i=e})}function O(e,t,r,n,s=!1){let a;return M(e,t),b[e]||(a=r(),b[e]=!0),n&&t({metric:n}),N(e,t,s?a:void 0)}function M(e,t){y[e]=y[e]||[],y[e].push(t)}function N(e,t,r){return()=>{r&&r();let n=y[e];if(!n)return;let s=n.indexOf(t);-1!==s&&n.splice(s,1)}}function D(e){return"duration"in e}},933190(e,t,r){"use strict";r.d(t,{KU:()=>d,m6:()=>c,o5:()=>i,rB:()=>m,rm:()=>l,v4:()=>u});var n=r(230337),s=r(960196),a=r(16278),o=r(973234);function i(){let e=(0,a.E)();return(0,s.h)(e).getCurrentScope()}function l(){let e=(0,a.E)();return(0,s.h)(e).getIsolationScope()}function c(){return(0,n.B)("globalScope",()=>new o.H)}function u(...e){let t=(0,a.E)(),r=(0,s.h)(t);if(2===e.length){let[t,n]=e;return t?r.withSetScope(t,n):r.withScope(n)}return r.withScope(e[0])}function m(...e){let t=(0,a.E)(),r=(0,s.h)(t);if(2===e.length){let[t,n]=e;return t?r.withSetIsolationScope(t,n):r.withIsolationScope(n)}return r.withIsolationScope(e[0])}function d(){return i().getClient()}},936435(e,t,r){"use strict";r.d(t,{z:()=>i});var n=r(290266),s=r(545203),a=r(728195),o=r(157392);let i=(0,s.kp)(o.Tl,(0,n.Ik)({type:(0,a.eu)(o.Z6.Text),value:(0,n.Yj)(),markdown:(0,n.lq)((0,n.zM)())}))},938102(e,t,r){"use strict";r.d(t,{dO:()=>c,o_:()=>o,wO:()=>l});let n={arab:"[٠-٩]",arabext:"[۰-۹]",bali:"[᭐-᭙]",beng:"[০-৯]",deva:"[०-९]",fullwide:"[０-９]",gujr:"[૦-૯]",hanidec:"[〇|一|二|三|四|五|六|七|八|九]",khmr:"[០-៩]",knda:"[೦-೯]",laoo:"[໐-໙]",limb:"[᥆-᥏]",mlym:"[൦-൯]",mong:"[᠐-᠙]",mymr:"[၀-၉]",orya:"[୦-୯]",tamldec:"[௦-௯]",telu:"[౦-౯]",thai:"[๐-๙]",tibt:"[༠-༩]",latn:"\\d"},s={arab:[1632,1641],arabext:[1776,1785],bali:[6992,7001],beng:[2534,2543],deva:[2406,2415],fullwide:[65296,65303],gujr:[2790,2799],khmr:[6112,6121],knda:[3302,3311],laoo:[3792,3801],limb:[6470,6479],mlym:[3430,3439],mong:[6160,6169],mymr:[4160,4169],orya:[2918,2927],tamldec:[3046,3055],telu:[3174,3183],thai:[3664,3673],tibt:[3872,3881]},a=n.hanidec.replace(/[\[|\]]/g,"").split("");function o(e){let t=parseInt(e,10);if(!isNaN(t))return t;t="";for(let r=0;r<e.length;r++){let o=e.charCodeAt(r);if(-1!==e[r].search(n.hanidec))t+=a.indexOf(e[r]);else for(let e in s){let[r,n]=s[e];o>=r&&o<=n&&(t+=o-r)}}return parseInt(t,10)}let i={};function l(){i={}}function c({numberingSystem:e},t=""){let r=e||"latn";return i[r]||(i[r]={}),i[r][t]||(i[r][t]=RegExp(`${n[r]}${t}`)),i[r][t]}},940344(e,t,r){"use strict";function n(){let e="function"==typeof WeakSet,t=e?new WeakSet:[];return[function(r){if(e)return!!t.has(r)||(t.add(r),!1);for(let e=0;e<t.length;e++)if(t[e]===r)return!0;return t.push(r),!1},function(r){if(e)t.delete(r);else for(let e=0;e<t.length;e++)if(t[e]===r){t.splice(e,1);break}}]}r.d(t,{s:()=>n})},943544(e,t,r){"use strict";r.d(t,{H7:()=>f,K8:()=>c,qv:()=>h,u:()=>p});var n=r(933190),s=r(397718),a=r(696294),o=r(654761),i=r(97407),l=r(586312);function c(e,t){let r=m(e,t),n={type:t&&t.name,value:function(e){let t=e&&e.message;return t?t.error&&"string"==typeof t.error.message?t.error.message:t:"No error message"}(t)};return r.length&&(n.stacktrace={frames:r}),void 0===n.type&&""===n.value&&(n.value="Unrecoverable error caught"),n}function u(e,t){return{exception:{values:[c(e,t)]}}}function m(e,t){var r,n;let s=t.stacktrace||t.stack||"",a=(r=t)&&d.test(r.message)?1:0,o="number"==typeof(n=t).framesToPop?n.framesToPop:0;try{return e(s,a,o)}catch(e){}return[]}let d=/Minified React error #\d+;/i;function p(e,t,r,n){let s=f(e,t,r&&r.syntheticException||void 0,n);return(0,a.M6)(s),s.level="error",r&&r.event_id&&(s.event_id=r.event_id),(0,l.XW)(s)}function h(e,t,r="info",n,s){let a=g(e,t,n&&n.syntheticException||void 0,s);return a.level=r,n&&n.event_id&&(a.event_id=n.event_id),(0,l.XW)(a)}function f(e,t,r,l,d){let p;if((0,s.T2)(t)&&t.error)return u(e,t.error);if((0,s.BD)(t)||(0,s.W6)(t)){if("stack"in t)p=u(e,t);else{let n=t.name||((0,s.BD)(t)?"DOMError":"DOMException"),o=t.message?`${n}: ${t.message}`:n;p=g(e,o,r,l),(0,a.gO)(p,o)}return"code"in t&&(p.tags={...p.tags,"DOMException.code":`${t.code}`}),p}return(0,s.bJ)(t)?u(e,t):((0,s.Qd)(t)||(0,s.xH)(t)?p=function(e,t,r,a){let l=(0,n.KU)(),u=l&&l.getOptions().normalizeDepth,d=function(e){for(let t in e)if(Object.prototype.hasOwnProperty.call(e,t)){let r=e[t];if(r instanceof Error)return r}}(t),p={__serialized__:(0,o.cd)(t,u)};if(d)return{exception:{values:[c(e,d)]},extra:p};let h={exception:{values:[{type:(0,s.xH)(t)?t.constructor.name:a?"UnhandledRejection":"Error",value:function(e,{isUnhandledRejection:t}){let r=(0,i.HF)(e),n=t?"promise rejection":"exception";if((0,s.T2)(e))return`Event \`ErrorEvent\` captured as ${n} with message \`${e.message}\``;if((0,s.xH)(e)){let t=function(e){try{let t=Object.getPrototypeOf(e);return t?t.constructor.name:void 0}catch(e){}}(e);return`Event \`${t}\` (type=${e.type}) captured as ${n}`}return`Object captured as ${n} with keys: ${r}`}(t,{isUnhandledRejection:a})}]},extra:p};if(r){let t=m(e,r);t.length&&(h.exception.values[0].stacktrace={frames:t})}return h}(e,t,r,d):(p=g(e,t,r,l),(0,a.gO)(p,`${t}`,void 0)),(0,a.M6)(p,{synthetic:!0}),p)}function g(e,t,r,n){let a={};if(n&&r){let n=m(e,r);n.length&&(a.exception={values:[{value:t,stacktrace:{frames:n}}]})}if((0,s.NF)(t)){let{__sentry_template_string__:e,__sentry_template_values__:r}=t;return a.logentry={message:e,params:r},a}return a.message=t,a}},943940(e,t,r){"use strict";r.d(t,{lY:()=>v});var n=r(975651),s=r(716070);let a=BigInt(0),o=BigInt(1),i=BigInt(2),l=BigInt(7),c=BigInt(256),u=BigInt(113),m=[],d=[],p=[];for(let e=0,t=o,r=1,n=0;e<24;e++){[r,n]=[n,(2*r+3*n)%5],m.push(2*(5*n+r)),d.push((e+1)*(e+2)/2%64);let s=a;for(let e=0;e<7;e++)(t=(t<<o^(t>>l)*u)%c)&i&&(s^=o<<(o<<BigInt(e))-o);p.push(s)}let h=(0,n.lD)(p,!0),f=h[0],g=h[1],y=(e,t,r)=>r>32?(0,n.WM)(e,t,r):(0,n.P5)(e,t,r),b=(e,t,r)=>r>32?(0,n.im)(e,t,r):(0,n.B4)(e,t,r);class k extends s.Vw{constructor(e,t,r,n=!1,a=24){if(super(),this.pos=0,this.posOut=0,this.finished=!1,this.destroyed=!1,this.enableXOF=!1,this.blockLen=e,this.suffix=t,this.outputLen=r,this.enableXOF=n,this.rounds=a,(0,s.Fe)(r),!(0<e&&e<200))throw Error("only keccak-f1600 function is supported");this.state=new Uint8Array(200),this.state32=(0,s.DH)(this.state)}clone(){return this._cloneInto()}keccak(){(0,s.fd)(this.state32),function(e,t=24){let r=new Uint32Array(10);for(let n=24-t;n<24;n++){for(let t=0;t<10;t++)r[t]=e[t]^e[t+10]^e[t+20]^e[t+30]^e[t+40];for(let t=0;t<10;t+=2){let n=(t+8)%10,s=(t+2)%10,a=r[s],o=r[s+1],i=y(a,o,1)^r[n],l=b(a,o,1)^r[n+1];for(let r=0;r<50;r+=10)e[t+r]^=i,e[t+r+1]^=l}let t=e[2],s=e[3];for(let r=0;r<24;r++){let n=d[r],a=y(t,s,n),o=b(t,s,n),i=m[r];t=e[i],s=e[i+1],e[i]=a,e[i+1]=o}for(let t=0;t<50;t+=10){for(let n=0;n<10;n++)r[n]=e[t+n];for(let n=0;n<10;n++)e[t+n]^=~r[(n+2)%10]&r[(n+4)%10]}e[0]^=f[n],e[1]^=g[n]}(0,s.uH)(r)}(this.state32,this.rounds),(0,s.fd)(this.state32),this.posOut=0,this.pos=0}update(e){(0,s.CC)(this),e=(0,s.ZJ)(e),(0,s.DO)(e);let{blockLen:t,state:r}=this,n=e.length;for(let s=0;s<n;){let a=Math.min(t-this.pos,n-s);for(let t=0;t<a;t++)r[this.pos++]^=e[s++];this.pos===t&&this.keccak()}return this}finish(){if(this.finished)return;this.finished=!0;let{state:e,suffix:t,pos:r,blockLen:n}=this;e[r]^=t,(128&t)!=0&&r===n-1&&this.keccak(),e[n-1]^=128,this.keccak()}writeInto(e){(0,s.CC)(this,!1),(0,s.DO)(e),this.finish();let t=this.state,{blockLen:r}=this;for(let n=0,s=e.length;n<s;){this.posOut>=r&&this.keccak();let a=Math.min(r-this.posOut,s-n);e.set(t.subarray(this.posOut,this.posOut+a),n),this.posOut+=a,n+=a}return e}xofInto(e){if(!this.enableXOF)throw Error("XOF is not possible for this instance");return this.writeInto(e)}xof(e){return(0,s.Fe)(e),this.xofInto(new Uint8Array(e))}digestInto(e){if((0,s.Ht)(e,this),this.finished)throw Error("digest() was already called");return this.writeInto(e),this.destroy(),e}digest(){return this.digestInto(new Uint8Array(this.outputLen))}destroy(){this.destroyed=!0,(0,s.uH)(this.state)}_cloneInto(e){let{blockLen:t,suffix:r,outputLen:n,rounds:s,enableXOF:a}=this;return e||(e=new k(t,r,n,a,s)),e.state32.set(this.state32),e.pos=this.pos,e.posOut=this.posOut,e.finished=this.finished,e.rounds=s,e.suffix=r,e.outputLen=n,e.enableXOF=a,e.destroyed=this.destroyed,e}}let v=(0,s.qj)(()=>new k(136,1,32))},950515(e,t,r){"use strict";function n(e){for(var t=arguments.length,r=Array(t>1?t-1:0),n=1;n<t;n++)r[n-1]=arguments[n];throw Error("[Immer] minified error nr: "+e+(r.length?" "+r.map(function(e){return"'"+e+"'"}).join(","):"")+". Find the full error at: https://bit.ly/3cXEKWf")}function s(e){return!!e&&!!e[B]}function a(e){var t;return!!e&&(function(e){if(!e||"object"!=typeof e)return!1;var t=Object.getPrototypeOf(e);if(null===t)return!0;var r=Object.hasOwnProperty.call(t,"constructor")&&t.constructor;return r===Object||"function"==typeof r&&Function.toString.call(r)===W}(e)||Array.isArray(e)||!!e[U]||!!(null==(t=e.constructor)?void 0:t[U])||m(e)||d(e))}function o(e,t,r){void 0===r&&(r=!1),0===i(e)?(r?Object.keys:H)(e).forEach(function(n){r&&"symbol"==typeof n||t(n,e[n],e)}):e.forEach(function(r,n){return t(n,r,e)})}function i(e){var t=e[B];return t?t.i>3?t.i-4:t.i:Array.isArray(e)?1:m(e)?2:3*!!d(e)}function l(e,t){return 2===i(e)?e.has(t):Object.prototype.hasOwnProperty.call(e,t)}function c(e,t){return 2===i(e)?e.get(t):e[t]}function u(e,t,r){var n=i(e);2===n?e.set(t,r):3===n?e.add(r):e[t]=r}function m(e){return P&&e instanceof Map}function d(e){return q&&e instanceof Set}function p(e){return e.o||e.t}function h(e){if(Array.isArray(e))return Array.prototype.slice.call(e);var t=V(e);delete t[B];for(var r=H(t),n=0;n<r.length;n++){var s=r[n],a=t[s];!1===a.writable&&(a.writable=!0,a.configurable=!0),(a.get||a.set)&&(t[s]={configurable:!0,writable:!0,enumerable:a.enumerable,value:e[s]})}return Object.create(Object.getPrototypeOf(e),t)}function f(e,t){return void 0===t&&(t=!1),y(e)||s(e)||!a(e)||(i(e)>1&&(e.set=e.add=e.clear=e.delete=g),Object.freeze(e),t&&o(e,function(e,t){return f(t,!0)},!0)),e}function g(){n(2)}function y(e){return null==e||"object"!=typeof e||Object.isFrozen(e)}function b(e){var t=Y[e];return t||n(18,e),t}r.d(t,{$i:()=>X,CN:()=>f,YT:()=>D,vI:()=>K});function k(e,t){t&&(b("Patches"),e.u=[],e.s=[],e.v=t)}function v(e){_(e),e.p.forEach(x),e.p=null}function _(e){e===L&&(L=e.l)}function w(e){return L={p:[],l:L,h:e,m:!0,_:0}}function x(e){var t=e[B];0===t.i||1===t.i?t.j():t.g=!0}function S(e,t){t._=t.p.length;var r=t.p[0],s=void 0!==e&&e!==r;return t.h.O||b("ES5").S(t,e,s),s?(r[B].P&&(v(t),n(4)),a(e)&&(e=E(t,e),t.l||T(t,e)),t.u&&b("Patches").M(r[B].t,e,t.u,t.s)):e=E(t,r,[]),v(t),t.u&&t.v(t.u,t.s),e!==$?e:void 0}function E(e,t,r){if(y(t))return t;var n=t[B];if(!n)return o(t,function(s,a){return j(e,n,t,s,a,r)},!0),t;if(n.A!==e)return t;if(!n.P)return T(e,n.t,!0),n.t;if(!n.I){n.I=!0,n.A._--;var s=4===n.i||5===n.i?n.o=h(n.k):n.o,a=s,i=!1;3===n.i&&(a=new Set(s),s.clear(),i=!0),o(a,function(t,a){return j(e,n,s,t,a,r,i)}),T(e,s,!1),r&&e.u&&b("Patches").N(n,r,e.u,e.s)}return n.o}function j(e,t,r,n,o,i,c){if(s(o)){var m=E(e,o,i&&t&&3!==t.i&&!l(t.R,n)?i.concat(n):void 0);if(u(r,n,m),!s(m))return;e.m=!1}else c&&r.add(o);if(a(o)&&!y(o)){if(!e.h.D&&e._<1)return;E(e,o),t&&t.A.l||T(e,o)}}function T(e,t,r){void 0===r&&(r=!1),!e.l&&e.h.D&&e.m&&f(t,r)}function A(e,t){var r=e[B];return(r?p(r):e)[t]}function C(e,t){if(t in e)for(var r=Object.getPrototypeOf(e);r;){var n=Object.getOwnPropertyDescriptor(r,t);if(n)return n;r=Object.getPrototypeOf(r)}}function I(e){e.P||(e.P=!0,e.l&&I(e.l))}function O(e){e.o||(e.o=h(e.t))}function M(e,t,r){var n,s,a,o,i,l,c,u=m(t)?b("MapSet").F(t,r):d(t)?b("MapSet").T(t,r):e.O?(a=s={i:+!!(n=Array.isArray(t)),A:r?r.A:L,P:!1,I:!1,R:{},l:r,t:t,k:null,o:null,j:null,C:!1},o=G,n&&(a=[s],o=J),l=(i=Proxy.revocable(a,o)).revoke,s.k=c=i.proxy,s.j=l,c):b("ES5").J(t,r);return(r?r.A:L).p.push(u),u}function N(e,t){switch(t){case 2:return new Map(e);case 3:return Array.from(e)}return h(e)}function D(){function e(t){if(!a(t))return t;if(Array.isArray(t))return t.map(e);if(m(t))return new Map(Array.from(t.entries()).map(function(t){return[t[0],e(t[1])]}));if(d(t))return new Set(Array.from(t).map(e));var r=Object.create(Object.getPrototypeOf(t));for(var n in t)r[n]=e(t[n]);return l(t,U)&&(r[U]=t[U]),r}function t(t){return s(t)?e(t):t}Y.Patches||(Y.Patches={$:function(t,r){return r.forEach(function(r){for(var s=r.path,a=r.op,o=t,l=0;l<s.length-1;l++){var u=i(o),m=s[l];"string"!=typeof m&&"number"!=typeof m&&(m=""+m),0!==u&&1!==u||"__proto__"!==m&&"constructor"!==m||n(24),"function"==typeof o&&"prototype"===m&&n(24),"object"!=typeof(o=c(o,m))&&n(15,s.join("/"))}var d=i(o),p=e(r.value),h=s[s.length-1];switch(a){case"replace":switch(d){case 2:return o.set(h,p);case 3:n(16);default:return o[h]=p}case"add":switch(d){case 1:return"-"===h?o.push(p):o.splice(h,0,p);case 2:return o.set(h,p);case 3:return o.add(p);default:return o[h]=p}case"remove":switch(d){case 1:return o.splice(h,1);case 2:return o.delete(h);case 3:return o.delete(r.value);default:return delete o[h]}default:n(17,a)}}),t},N:function(e,r,n,s){var a,i,u,m,d;switch(e.i){case 0:case 4:case 2:return a=e.t,i=e.o,void o(e.R,function(e,o){var u=c(a,e),m=c(i,e),d=o?l(a,e)?"replace":"add":"remove";if(u!==m||"replace"!==d){var p=r.concat(e);n.push("remove"===d?{op:d,path:p}:{op:d,path:p,value:m}),s.push("add"===d?{op:"remove",path:p}:"remove"===d?{op:"add",path:p,value:t(u)}:{op:"replace",path:p,value:t(u)})}});case 5:case 1:return function(e,r,n,s){var a=e.t,o=e.R,i=e.o;if(i.length<a.length){var l=[i,a];a=l[0],i=l[1];var c=[s,n];n=c[0],s=c[1]}for(var u=0;u<a.length;u++)if(o[u]&&i[u]!==a[u]){var m=r.concat([u]);n.push({op:"replace",path:m,value:t(i[u])}),s.push({op:"replace",path:m,value:t(a[u])})}for(var d=a.length;d<i.length;d++){var p=r.concat([d]);n.push({op:"add",path:p,value:t(i[d])})}a.length<i.length&&s.push({op:"replace",path:r.concat(["length"]),value:a.length})}(e,r,n,s);case 3:return u=e.t,m=e.o,d=0,void(u.forEach(function(e){if(!m.has(e)){var t=r.concat([d]);n.push({op:"remove",path:t,value:e}),s.unshift({op:"add",path:t,value:e})}d++}),d=0,m.forEach(function(e){if(!u.has(e)){var t=r.concat([d]);n.push({op:"add",path:t,value:e}),s.unshift({op:"remove",path:t,value:e})}d++}))}},M:function(e,t,r,n){r.push({op:"replace",path:[],value:t===$?void 0:t}),n.push({op:"replace",path:[],value:e})}})}var R,L,F="undefined"!=typeof Symbol&&"symbol"==typeof Symbol("x"),P="undefined"!=typeof Map,q="undefined"!=typeof Set,z="undefined"!=typeof Proxy&&void 0!==Proxy.revocable&&"undefined"!=typeof Reflect,$=F?Symbol.for("immer-nothing"):((R={})["immer-nothing"]=!0,R),U=F?Symbol.for("immer-draftable"):"__$immer_draftable",B=F?Symbol.for("immer-state"):"__$immer_state",W=""+Object.prototype.constructor,H="undefined"!=typeof Reflect&&Reflect.ownKeys?Reflect.ownKeys:void 0!==Object.getOwnPropertySymbols?function(e){return Object.getOwnPropertyNames(e).concat(Object.getOwnPropertySymbols(e))}:Object.getOwnPropertyNames,V=Object.getOwnPropertyDescriptors||function(e){var t={};return H(e).forEach(function(r){t[r]=Object.getOwnPropertyDescriptor(e,r)}),t},Y={},G={get:function(e,t){if(t===B)return e;var r,n,s=p(e);if(!l(s,t))return(n=C(s,t))?"value"in n?n.value:null==(r=n.get)?void 0:r.call(e.k):void 0;var o=s[t];return e.I||!a(o)?o:o===A(e.t,t)?(O(e),e.o[t]=M(e.A.h,o,e)):o},has:function(e,t){return t in p(e)},ownKeys:function(e){return Reflect.ownKeys(p(e))},set:function(e,t,r){var n=C(p(e),t);if(null==n?void 0:n.set)return n.set.call(e.k,r),!0;if(!e.P){var s=A(p(e),t),a=null==s?void 0:s[B];if(a&&a.t===r)return e.o[t]=r,e.R[t]=!1,!0;if((r===s?0!==r||1/r==1/s:r!=r&&s!=s)&&(void 0!==r||l(e.t,t)))return!0;O(e),I(e)}return e.o[t]===r&&(void 0!==r||t in e.o)||Number.isNaN(r)&&Number.isNaN(e.o[t])||(e.o[t]=r,e.R[t]=!0),!0},deleteProperty:function(e,t){return void 0!==A(e.t,t)||t in e.t?(e.R[t]=!1,O(e),I(e)):delete e.R[t],e.o&&delete e.o[t],!0},getOwnPropertyDescriptor:function(e,t){var r=p(e),n=Reflect.getOwnPropertyDescriptor(r,t);return n?{writable:!0,configurable:1!==e.i||"length"!==t,enumerable:n.enumerable,value:r[t]}:n},defineProperty:function(){n(11)},getPrototypeOf:function(e){return Object.getPrototypeOf(e.t)},setPrototypeOf:function(){n(12)}},J={};o(G,function(e,t){J[e]=function(){return arguments[0]=arguments[0][0],t.apply(this,arguments)}}),J.deleteProperty=function(e,t){return J.set.call(this,e,t,void 0)},J.set=function(e,t,r){return G.set.call(this,e[0],t,r,e[0])};var Z=new(function(){function e(e){var t=this;this.O=z,this.D=!0,this.produce=function(e,r,s){if("function"==typeof e&&"function"!=typeof r){var o,i=r;return r=e,function(e){var n=this;void 0===e&&(e=i);for(var s=arguments.length,a=Array(s>1?s-1:0),o=1;o<s;o++)a[o-1]=arguments[o];return t.produce(e,function(e){var t;return(t=r).call.apply(t,[n,e].concat(a))})}}if("function"!=typeof r&&n(6),void 0!==s&&"function"!=typeof s&&n(7),a(e)){var l=w(t),c=M(t,e,void 0),u=!0;try{o=r(c),u=!1}finally{u?v(l):_(l)}return"undefined"!=typeof Promise&&o instanceof Promise?o.then(function(e){return k(l,s),S(e,l)},function(e){throw v(l),e}):(k(l,s),S(o,l))}if(!e||"object"!=typeof e){if(void 0===(o=r(e))&&(o=e),o===$&&(o=void 0),t.D&&f(o,!0),s){var m=[],d=[];b("Patches").M(e,o,m,d),s(m,d)}return o}n(21,e)},this.produceWithPatches=function(e,r){if("function"==typeof e)return function(r){for(var n=arguments.length,s=Array(n>1?n-1:0),a=1;a<n;a++)s[a-1]=arguments[a];return t.produceWithPatches(r,function(t){return e.apply(void 0,[t].concat(s))})};var n,s,a=t.produce(e,r,function(e,t){n=e,s=t});return"undefined"!=typeof Promise&&a instanceof Promise?a.then(function(e){return[e,n,s]}):[a,n,s]},"boolean"==typeof(null==e?void 0:e.useProxies)&&this.setUseProxies(e.useProxies),"boolean"==typeof(null==e?void 0:e.autoFreeze)&&this.setAutoFreeze(e.autoFreeze)}var t=e.prototype;return t.createDraft=function(e){a(e)||n(8),s(e)&&(s(t=e)||n(22,t),e=function e(t){if(!a(t))return t;var r,n=t[B],s=i(t);if(n){if(!n.P&&(n.i<4||!b("ES5").K(n)))return n.t;n.I=!0,r=N(t,s),n.I=!1}else r=N(t,s);return o(r,function(t,s){n&&c(n.t,t)===s||u(r,t,e(s))}),3===s?new Set(r):r}(t));var t,r=w(this),l=M(this,e,void 0);return l[B].C=!0,_(r),l},t.finishDraft=function(e,t){var r=(e&&e[B]).A;return k(r,t),S(void 0,r)},t.setAutoFreeze=function(e){this.D=e},t.setUseProxies=function(e){e&&!z&&n(20),this.O=e},t.applyPatches=function(e,t){for(r=t.length-1;r>=0;r--){var r,n=t[r];if(0===n.path.length&&"replace"===n.op){e=n.value;break}}r>-1&&(t=t.slice(r+1));var a=b("Patches").$;return s(e)?a(e,t):this.produce(e,function(e){return a(e,t)})},e}()),K=(Z.produce,Z.produceWithPatches.bind(Z)),X=(Z.setAutoFreeze.bind(Z),Z.setUseProxies.bind(Z),Z.applyPatches.bind(Z));Z.createDraft.bind(Z),Z.finishDraft.bind(Z)},951545(e,t,r){"use strict";r.d(t,{A:()=>s});var n=r(921766);let s=function(e){return"string"==typeof e&&n.A.test(e)}},951906(e,t,r){"use strict";r.d(t,{AX:()=>w,Al:()=>S,DN:()=>k,FX:()=>b,M$:()=>l,MC:()=>j,My:()=>f,Rb:()=>c,aY:()=>o,cE:()=>g,d6:()=>u,dO:()=>y,dz:()=>m,fO:()=>x,g5:()=>i,h0:()=>v,h3:()=>E,hF:()=>d,nt:()=>T,o:()=>h,oq:()=>p,pM:()=>_});let n="numeric",s="short",a="long",o={year:n,month:n,day:n},i={year:n,month:s,day:n},l={year:n,month:s,day:n,weekday:s},c={year:n,month:a,day:n},u={year:n,month:a,day:n,weekday:a},m={hour:n,minute:n},d={hour:n,minute:n,second:n},p={hour:n,minute:n,second:n,timeZoneName:s},h={hour:n,minute:n,second:n,timeZoneName:a},f={hour:n,minute:n,hourCycle:"h23"},g={hour:n,minute:n,second:n,hourCycle:"h23"},y={hour:n,minute:n,second:n,hourCycle:"h23",timeZoneName:s},b={hour:n,minute:n,second:n,hourCycle:"h23",timeZoneName:a},k={year:n,month:n,day:n,hour:n,minute:n},v={year:n,month:n,day:n,hour:n,minute:n,second:n},_={year:n,month:s,day:n,hour:n,minute:n},w={year:n,month:s,day:n,hour:n,minute:n,second:n},x={year:n,month:s,day:n,weekday:s,hour:n,minute:n},S={year:n,month:a,day:n,hour:n,minute:n,timeZoneName:s},E={year:n,month:a,day:n,hour:n,minute:n,second:n,timeZoneName:s},j={year:n,month:a,day:n,weekday:a,hour:n,minute:n,timeZoneName:a},T={year:n,month:a,day:n,weekday:a,hour:n,minute:n,second:n,timeZoneName:a}},952574(e,t,r){let n;var s=r(208835);t.formatArgs=function(t){if(t[0]=(this.useColors?"%c":"")+this.namespace+(this.useColors?" %c":" ")+t[0]+(this.useColors?"%c ":" ")+"+"+e.exports.humanize(this.diff),!this.useColors)return;let r="color: "+this.color;t.splice(1,0,r,"color: inherit");let n=0,s=0;t[0].replace(/%[a-zA-Z%]/g,e=>{"%%"!==e&&(n++,"%c"===e&&(s=n))}),t.splice(s,0,r)},t.save=function(e){try{e?t.storage.setItem("debug",e):t.storage.removeItem("debug")}catch(e){}},t.load=function(){let e;try{e=t.storage.getItem("debug")||t.storage.getItem("DEBUG")}catch(e){}return!e&&void 0!==s&&"env"in s&&(e=s.env.DEBUG),e},t.useColors=function(){let e;return"undefined"!=typeof window&&!!window.process&&("renderer"===window.process.type||!!window.process.__nwjs)||!("undefined"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/))&&(void 0!==a&&a.documentElement&&a.documentElement.style&&a.documentElement.style.WebkitAppearance||"undefined"!=typeof window&&window.console&&(window.console.firebug||window.console.exception&&window.console.table)||"undefined"!=typeof navigator&&navigator.userAgent&&(e=navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/))&&parseInt(e[1],10)>=31||"undefined"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/))},t.storage=function(){try{return localStorage}catch(e){}}(),n=!1,t.destroy=()=>{n||(n=!0,console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."))},t.colors=["#0000CC","#0000FF","#0033CC","#0033FF","#0066CC","#0066FF","#0099CC","#0099FF","#00CC00","#00CC33","#00CC66","#00CC99","#00CCCC","#00CCFF","#3300CC","#3300FF","#3333CC","#3333FF","#3366CC","#3366FF","#3399CC","#3399FF","#33CC00","#33CC33","#33CC66","#33CC99","#33CCCC","#33CCFF","#6600CC","#6600FF","#6633CC","#6633FF","#66CC00","#66CC33","#9900CC","#9900FF","#9933CC","#9933FF","#99CC00","#99CC33","#CC0000","#CC0033","#CC0066","#CC0099","#CC00CC","#CC00FF","#CC3300","#CC3333","#CC3366","#CC3399","#CC33CC","#CC33FF","#CC6600","#CC6633","#CC9900","#CC9933","#CCCC00","#CCCC33","#FF0000","#FF0033","#FF0066","#FF0099","#FF00CC","#FF00FF","#FF3300","#FF3333","#FF3366","#FF3399","#FF33CC","#FF33FF","#FF6600","#FF6633","#FF9900","#FF9933","#FFCC00","#FFCC33"],t.log=console.debug||console.log||(()=>{}),e.exports=r(683075)(t);let{formatters:o}=e.exports;o.j=function(e){try{return JSON.stringify(e)}catch(e){return"[UnexpectedJSONParseError]: "+e.message}}},956742(e,t,r){"use strict";r.d(t,{R:()=>n});let n=(e,t,r,n)=>{let s,a;return o=>{if(t.value>=0&&(o||n)&&((a=t.value-(s||0))||void 0===s)){var i;s=t.value,t.delta=a,i=t.value,t.rating=i>r[1]?"poor":i>r[0]?"needs-improvement":"good",e(t)}}}},960196(e,t,r){"use strict";r.d(t,{h:()=>a});var n=r(16278),s=r(818747);function a(e){let t=(0,n.S)(e);return t.acs?t.acs:(0,s.z)()}},961520(e,t,r){"use strict";r.d(t,{Di:()=>c,Op:()=>o,gN:()=>i,hq:()=>a,iq:()=>l,jP:()=>u,t:()=>s});class n extends Error{}class s extends n{constructor(e){super(`Invalid DateTime: ${e.toMessage()}`)}}class a extends n{constructor(e){super(`Invalid Interval: ${e.toMessage()}`)}}class o extends n{constructor(e){super(`Invalid Duration: ${e.toMessage()}`)}}class i extends n{}class l extends n{constructor(e){super(`Invalid unit ${e}`)}}class c extends n{}class u extends n{constructor(){super("Zone is an abstract class")}}},967746(e,t,r){"use strict";function n({getAnalyticsState:e,log:t}){return{name:"MetaMetrics",processEvent:async(r,n,s)=>{let a=await e();return a?.completedMetaMetricsOnboarding&&a.optedIn?(a.analyticsId&&(r.user={...r.user,id:a.analyticsId}),r):(t("Event dropped as metrics disabled"),null)}}}r.d(t,{t:()=>n})},969210(e,t,r){"use strict";r.d(t,{Vu:()=>u,dm:()=>i});var n=r(933190),s=r(608119),a=r(821016),o=r(834669);let i=[/^https:\/\/[a-z0-9.-]+\.(?:[a-z0-9]+-)?api\.cx\.metamask\.io(?:[/?#]|$)/u],l=new Map;function c(e){let t=new Headers;if(!e)return t;if("undefined"!=typeof Headers&&e instanceof Headers)e.forEach((e,r)=>t.append(r,e));else if(Array.isArray(e))for(let r of e){let[e,n]=r;null!=n&&t.append(e,String(n))}else if("object"==typeof e)for(let[r,n]of Object.entries(e))null!=n&&t.append(r,String(n));return t}function u({log:e}){return{name:"ConsensysTracePropagation",afterAllSetup:()=>{(0,a.ur)(t=>{if(void 0!==t.endTimestamp)return;let r=t.fetchData?.url;if(r&&i.some(e=>e.test(r)))try{let e=(0,o.A)(),r=function(){try{let e=(0,s.Bk)();if(e){let{traceId:t,spanId:r,traceFlags:n}=e.spanContext();if(!t||!r)return;return`00-${t}-${r}-${(n??1)%2==1?"01":"00"}`}let{traceId:t,spanId:r,sampled:a}={...(0,n.rm)().getPropagationContext(),...(0,n.o5)().getPropagationContext()};if(!t||!r)return;return`00-${t}-${r}-${!1===a?"00":"01"}`}catch{return}}();if(r){let t=function(e){let[,t]=e.split("-");return t||void 0}(r);t&&function(e,t){if(l.has(e)){l.get(e)!==t&&l.set(e,null);return}if(l.set(e,t),l.size<=100)return;let r=l.keys().next().value;r&&l.delete(r)}(t,e)}let a=function(e,{traceparent:t,requestId:r}){let[n,s]=e,a=c("undefined"!=typeof Request&&n instanceof Request?n.headers:void 0);return c(s?.headers).forEach((e,t)=>{a.set(t,e)}),t&&!a.has("traceparent")&&a.set("traceparent",t),a.append("baggage",`consensys-request-id=${r},consensys-application=metamask-extension`),a}(t.args,{traceparent:r,requestId:e});t.args[1]=t.args[1]||{},t.args[1].headers=a}catch(t){e("Failed to propagate trace headers",t)}})},processEvent:(e,t,r)=>{let n=e.contexts?.trace?.trace_id;if(n){e.tags={...e.tags,otelTraceId:n};let t=l.get(n);t&&(e.tags={...e.tags,consensysRequestId:t})}return e}}}},971188(e,t,r){"use strict";r.d(t,{J:()=>s});var n=r(728195);function s(e){return(0,n.KC)(e)}},973149(e,t,r){"use strict";r.d(t,{X:()=>o,g:()=>a});var n=r(97407);let s="_sentryMetrics";function a(e){let t=e[s];if(!t)return;let r={};for(let[,[e,s]]of t)(r[e]||(r[e]=[])).push((0,n.Ce)(s));return r}function o(e,t,r,n,a,o,i){let l=e[s]||(e[s]=new Map),c=`${t}:${r}@${a}`,u=l.get(i);if(u){let[,e]=u;l.set(i,[c,{min:Math.min(e.min,n),max:Math.max(e.max,n),count:e.count+=1,sum:e.sum+=n,tags:e.tags}])}else l.set(i,[c,{min:n,max:n,count:1,sum:n,tags:o}])}},973234(e,t,r){"use strict";r.d(t,{H:()=>m});var n=r(397718),s=r(107842),a=r(696294),o=r(37853),i=r(620209),l=r(597014),c=r(71409);class u{constructor(){this._notifyingListeners=!1,this._scopeListeners=[],this._eventProcessors=[],this._breadcrumbs=[],this._attachments=[],this._user={},this._tags={},this._extra={},this._contexts={},this._sdkProcessingMetadata={},this._propagationContext=(0,i.J)()}clone(){let e=new u;return e._breadcrumbs=[...this._breadcrumbs],e._tags={...this._tags},e._extra={...this._extra},e._contexts={...this._contexts},e._user=this._user,e._level=this._level,e._session=this._session,e._transactionName=this._transactionName,e._fingerprint=this._fingerprint,e._eventProcessors=[...this._eventProcessors],e._requestSession=this._requestSession,e._attachments=[...this._attachments],e._sdkProcessingMetadata={...this._sdkProcessingMetadata},e._propagationContext={...this._propagationContext},e._client=this._client,e._lastEventId=this._lastEventId,(0,c.r)(e,(0,c.f)(this)),e}setClient(e){this._client=e}setLastEventId(e){this._lastEventId=e}getClient(){return this._client}lastEventId(){return this._lastEventId}addScopeListener(e){this._scopeListeners.push(e)}addEventProcessor(e){return this._eventProcessors.push(e),this}setUser(e){return this._user=e||{email:void 0,id:void 0,ip_address:void 0,username:void 0},this._session&&(0,l.qO)(this._session,{user:e}),this._notifyScopeListeners(),this}getUser(){return this._user}getRequestSession(){return this._requestSession}setRequestSession(e){return this._requestSession=e,this}setTags(e){return this._tags={...this._tags,...e},this._notifyScopeListeners(),this}setTag(e,t){return this._tags={...this._tags,[e]:t},this._notifyScopeListeners(),this}setExtras(e){return this._extra={...this._extra,...e},this._notifyScopeListeners(),this}setExtra(e,t){return this._extra={...this._extra,[e]:t},this._notifyScopeListeners(),this}setFingerprint(e){return this._fingerprint=e,this._notifyScopeListeners(),this}setLevel(e){return this._level=e,this._notifyScopeListeners(),this}setTransactionName(e){return this._transactionName=e,this._notifyScopeListeners(),this}setContext(e,t){return null===t?delete this._contexts[e]:this._contexts[e]=t,this._notifyScopeListeners(),this}setSession(e){return e?this._session=e:delete this._session,this._notifyScopeListeners(),this}getSession(){return this._session}update(e){if(!e)return this;let t="function"==typeof e?e(this):e,[r,s]=t instanceof m?[t.getScopeData(),t.getRequestSession()]:(0,n.Qd)(t)?[e,e.requestSession]:[],{tags:a,extra:o,user:i,contexts:l,level:c,fingerprint:u=[],propagationContext:d}=r||{};return this._tags={...this._tags,...a},this._extra={...this._extra,...o},this._contexts={...this._contexts,...l},i&&Object.keys(i).length&&(this._user=i),c&&(this._level=c),u.length&&(this._fingerprint=u),d&&(this._propagationContext=d),s&&(this._requestSession=s),this}clear(){return this._breadcrumbs=[],this._tags={},this._extra={},this._user={},this._contexts={},this._level=void 0,this._transactionName=void 0,this._fingerprint=void 0,this._requestSession=void 0,this._session=void 0,(0,c.r)(this,void 0),this._attachments=[],this._propagationContext=(0,i.J)(),this._notifyScopeListeners(),this}addBreadcrumb(e,t){let r="number"==typeof t?t:100;if(r<=0)return this;let n={timestamp:(0,o.lu)(),...e},s=this._breadcrumbs;return s.push(n),this._breadcrumbs=s.length>r?s.slice(-r):s,this._notifyScopeListeners(),this}getLastBreadcrumb(){return this._breadcrumbs[this._breadcrumbs.length-1]}clearBreadcrumbs(){return this._breadcrumbs=[],this._notifyScopeListeners(),this}addAttachment(e){return this._attachments.push(e),this}clearAttachments(){return this._attachments=[],this}getScopeData(){return{breadcrumbs:this._breadcrumbs,attachments:this._attachments,contexts:this._contexts,tags:this._tags,extra:this._extra,user:this._user,level:this._level,fingerprint:this._fingerprint||[],eventProcessors:this._eventProcessors,propagationContext:this._propagationContext,sdkProcessingMetadata:this._sdkProcessingMetadata,transactionName:this._transactionName,span:(0,c.f)(this)}}setSDKProcessingMetadata(e){return this._sdkProcessingMetadata={...this._sdkProcessingMetadata,...e},this}setPropagationContext(e){return this._propagationContext=e,this}getPropagationContext(){return this._propagationContext}captureException(e,t){let r=t&&t.event_id?t.event_id:(0,a.eJ)();if(!this._client)return s.vF.warn("No client configured on scope - will not capture exception!"),r;let n=Error("Sentry syntheticException");return this._client.captureException(e,{originalException:e,syntheticException:n,...t,event_id:r},this),r}captureMessage(e,t,r){let n=r&&r.event_id?r.event_id:(0,a.eJ)();if(!this._client)return s.vF.warn("No client configured on scope - will not capture message!"),n;let o=Error(e);return this._client.captureMessage(e,t,{originalException:e,syntheticException:o,...r,event_id:n},this),n}captureEvent(e,t){let r=t&&t.event_id?t.event_id:(0,a.eJ)();return this._client?this._client.captureEvent(e,{...t,event_id:r},this):s.vF.warn("No client configured on scope - will not capture event!"),r}_notifyScopeListeners(){this._notifyingListeners||(this._notifyingListeners=!0,this._scopeListeners.forEach(e=>{e(this)}),this._notifyingListeners=!1)}}let m=u},973594(e,t,r){"use strict";r.d(t,{UG:()=>m});var n=r(652825),s=r(290266),a=r(943940),o=r(859340),i=r(554839);let{memoize:l}=o,c=/^0x[0-9a-f]{40}$/u,u=/^0x[0-9a-fA-F]{40}$/u;(0,n.T1)((0,s.Yj)(),/^(?:0x)?[0-9a-f]+$/iu),(0,n.T1)((0,s.Yj)(),/^0x[0-9a-f]+$/iu),(0,n.T1)((0,s.Yj)(),c);let m=(0,n.T1)((0,s.Yj)(),u);function d(e){return"string"==typeof e&&u.test(e)}let p=l(function(e){var t;(0,i.vA)(d(e),"Invalid hex address.");let r=((t=e).startsWith("0x")||t.startsWith("0X")?t.substring(2):t).toLowerCase(),n=(0,a.lY)(r),{length:s}=r,o=Array(s);for(let e=0;e<s;e++){let t=e>>1,s=1&e,a=n[t],i=0===s?a>>4:15&a;o[e]=i>=8?r[e].toUpperCase():r[e]}return`0x${o.join("")}`}),h=l(function(e){return!!d(e)&&p(e)===e});l(function(e){var t;return"string"==typeof(t=e)&&c.test(t)||h(e)})},975651(e,t,r){"use strict";r.d(t,{B4:()=>i,P5:()=>o,WM:()=>l,im:()=>c,lD:()=>a});let n=BigInt(0x100000000-1),s=BigInt(32);function a(e,t=!1){let r=e.length,o=new Uint32Array(r),i=new Uint32Array(r);for(let a=0;a<r;a++){let{h:r,l}=function(e,t=!1){return t?{h:Number(e&n),l:Number(e>>s&n)}:{h:0|Number(e>>s&n),l:0|Number(e&n)}}(e[a],t);[o[a],i[a]]=[r,l]}return[o,i]}let o=(e,t,r)=>e<<r|t>>>32-r,i=(e,t,r)=>t<<r|e>>>32-r,l=(e,t,r)=>t<<r-32|e>>>64-r,c=(e,t,r)=>e<<r-32|t>>>64-r},982944(e,t,r){"use strict";r.d(t,{C:()=>n});class n extends TypeError{constructor(e,t){let r,{message:n,explanation:s,...a}=e,{path:o}=e,i=0===o.length?n:`At path: ${o.join(".")} -- ${n}`;super(s??i),null!=s&&(this.cause=i),Object.assign(this,a),this.name=this.constructor.name,this.failures=()=>r??(r=[e,...t()])}}},984524(e,t,r){"use strict";r.d(t,{s3:()=>m});var n,s,a,o,i=r(290266),l=r(545203),c=r(728195),u=r(157392);(n=a||(a={})).Primary="primary",n.Secondary="secondary",(s=o||(o={})).Button="button",s.Submit="submit";let m=(0,l.kp)(u.Tl,(0,i.Ik)({type:(0,c.eu)(u.Z6.Button),value:(0,i.Yj)(),variant:(0,i.lq)((0,i.KC)([(0,c.$9)(a.Primary),(0,c.$9)(a.Secondary)])),buttonType:(0,i.lq)((0,i.KC)([(0,c.$9)(o.Button),(0,c.$9)(o.Submit)])),name:(0,i.lq)((0,i.Yj)())}))},986746(e,t,r){"use strict";r.d(t,{X:()=>u});var n=r(397718),s=r(107842),a=r(654761),o=r(97407),i=r(40209),l=r(290264),c=r(67904);let u=(0,l._C)((e={})=>{let{depth:t=3,captureErrorCause:r=!0}=e;return{name:"ExtraErrorData",processEvent(e,l,u){let{maxValueLength:m=250}=u.getOptions();return function(e,t={},r,l,u){if(!t.originalException||!(0,n.bJ)(t.originalException))return e;let m=t.originalException.name||t.originalException.constructor.name,d=function(e,t,r){try{let s=["name","message","stack","line","column","fileName","lineNumber","columnNumber","toJSON"],a={};for(let t of Object.keys(e)){if(-1!==s.indexOf(t))continue;let o=e[t];a[t]=(0,n.bJ)(o)||"string"==typeof o?(0,i.xv)(`${o}`,r):o}if(t&&void 0!==e.cause&&(a.cause=(0,n.bJ)(e.cause)?e.cause.toString():e.cause),"function"==typeof e.toJSON){let t=e.toJSON();for(let e of Object.keys(t)){let r=t[e];a[e]=(0,n.bJ)(r)?r.toString():r}}return a}catch(e){c.T&&s.vF.error("Unable to extract extra data from the Error object:",e)}return null}(t.originalException,l,u);if(d){let t={...e.contexts},s=(0,a.S8)(d,r);return(0,n.Qd)(s)&&((0,o.my)(s,"__sentry_skip_normalization__",!0),t[m]=s),{...e,contexts:t}}return e}(e,l,t,r,m)}}})},988068(e,t,r){"use strict";r.d(t,{y:()=>c});var n,s,a=r(290266),o=r(545203),i=r(728195),l=r(157392);(n=s||(s={})).Text="text",n.Number="number",n.Password="password";let c=(0,o.kp)(l.Tl,(0,a.Ik)({type:(0,i.eu)(l.Z6.Input),value:(0,a.lq)((0,a.Yj)()),name:(0,a.Yj)(),inputType:(0,a.lq)((0,a.KC)([(0,i.$9)(s.Text),(0,i.$9)(s.Password),(0,i.$9)(s.Number)])),placeholder:(0,a.lq)((0,a.Yj)()),label:(0,a.lq)((0,a.Yj)()),error:(0,a.lq)((0,a.Yj)())}))},988217(e,t,r){"use strict";r.d(t,{L:()=>o});var n=r(230337),s=r(25605);let a=null;function o(e){let t="error";(0,s.s5)(t,e),(0,s.AS)(t,i)}function i(){a=n.O.onerror,n.O.onerror=function(e,t,r,n,o){return(0,s.aj)("error",{column:n,error:o,line:r,msg:e,url:t}),!!a&&!a.__SENTRY_LOADER__&&a.apply(this,arguments)},n.O.onerror.__SENTRY_INSTRUMENTED__=!0}}},t={};function r(n){var s=t[n];if(void 0!==s)return s.exports;var a=t[n]={id:n,loaded:!1,exports:{}};return e[n].call(a.exports,a,a.exports,r),a.loaded=!0,a.exports}r.m=e,globalThis.location;var n=globalThis.setTimeout,s=globalThis.clearTimeout,a=globalThis.document,o=(globalThis.trustedTypes,globalThis.self);let i=[];r.amdO={},r.n=e=>{var t=e&&e.__esModule?()=>e.default:()=>e;return r.d(t,{a:t}),t},r.d=(e,t)=>{for(var n in t)r.o(t,n)&&!r.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:t[n]})},r.f={},r.e=e=>Promise.all(Object.keys(r.f).reduce((t,n)=>(r.f[n](e,t),t),[])),r.u=e=>""+e+"."+({74:"2f4da58abd21446a0549",388:"4b1fe83c1ba7576637d3",392:"c4e3f9d3caa804f5e274",1620:"add3d7734acea47e5756",2040:"0c2cbdf653c846252700",2806:"4ea305ef638e0fb17430",2913:"51d5728debd7a47dfacf",3288:"6b2cf8f8a8dd94e7c626",4633:"19b2a93f7a84c291db73",4813:"3ec32cb29a52f1af9a66",5580:"e0d76348cca2bc70571f",5917:"bdb1bb99df56cde420fc",6428:"ee478bb587fa9834115a",6714:"70ace14e466faa21fece",6843:"8bd902221d9fb7517949",7354:"583acfec5d7eeb2eab6e",7568:"867d15e5ddee383de6d1",8190:"dc21b27490bf1e985182",8790:"ab9f2f15c7e14b80cdd8",9171:"573e20216581d08eb625",9424:"b2cc51a903d3cac5ea2b",9523:"20b0c3ff281a8506ac51"})[e]+".js",r.hmd=e=>((e=Object.create(e)).children||(e.children=[]),Object.defineProperty(e,"exports",{enumerable:!0,set:()=>{throw Error("ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: "+e.id)}}),e),r.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),r.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.nmd=e=>(e.paths=[],e.children||(e.children=[]),e),r.p="",(()=>{r.b=o.location+"";var e={5864:1,7547:1};r.f.i=(t,n)=>{e[t]||importScripts(r.p+r.u(t))};var t=globalThis.webpackChunk=globalThis.webpackChunk||[],n=t.push.bind(t);t.push=t=>{var[s,a,o]=t;for(var i in a)r.o(a,i)&&(r.m[i]=a[i]);for(o&&o(r);s.length;)e[s.pop()]=1;n(t)}})(),(()=>{let e=Object.create(null);e.root="$root$",e.idmap=[["$root$",[100008,100573,101148,101278,101611,101885,10217,102190,102320,102482,102609,102905,102985,103261,103321,103651,104231,104429,104758,105049,105474,105522,105557,106105,106356,106828,107230,107272,107381,107502,107580,107804,107874,107886,108116,108120,108178,108439,108474,108775,108933,109117,109242,109835,110010,110303,110407,110814,110927,111644,111985,112094,11212,112225,11253,112604,112652,113337,113366,11353,113602,114168,114174,114274,114675,115319,115346,115408,115726,115884,116048,116242,116255,116372,116456,116882,117253,117567,117699,11775,117903,11795,118055,118202,118670,118707,118834,118997,119023,119278,119681,120054,120584,120925,121216,121854,122175,122536,122626,123231,123391,123455,123556,12376,123784,123799,123827,124397,124599,124935,125027,125091,12523,125393,12569,12573,125894,126142,126177,126660,127015,127388,127565,128019,128364,128567,130331,130413,130428,130780,130920,131115,13126,131666,13176,131811,132019,132516,132544,13296,13304,133195,133284,133714,133791,134236,134429,134727,135047,136088,136272,136372,136399,136426,136447,136862,136948,137557,137622,137937,138247,138409,138623,138865,138915,13927,139284,139354,139742,139833,139842,139969,139976,14029,140456,140775,140778,141057,141188,141382,141573,142014,143195,143373,143394,143472,143918,144586,144944,144988,145034,145102,145502,145657,145865,14600,14611,146188,146194,146659,146759,146802,146806,146869,147133,147143,147278,147597,147599,148249,148496,148887,149040,149177,149235,149235,149235,149235,149861,150350,151243,151327,15151,152256,152336,15250,15289,153059,153068,15319,153197,153294,153692,153753,153875,15392,154404,154565,154862,155180,155246,155862,156265,156323,156540,156549,156760,156762,156852,157068,157234,157310,157395,157479,157794,157944,157960,157962,157966,158093,158175,158221,158259,158265,158308,158332,158374,158637,158792,159163,15923,159307,159315,159472,159629,159768,1598,159815,160087,160099,16026,160461,160873,160917,160920,161236,161356,161413,16179,161839,161863,162444,162560,163305,163310,163636,163723,16415,16467,164684,164698,164899,164983,16512,165304,165851,165937,165972,166133,166455,166879,167290,167344,167472,16750,167643,16809,168671,168798,16930,169727,16979,169889,17e4,170232,170237,170455,170524,17079,170904,170951,171229,17198,172013,172142,172153,173030,173156,173611,174199,174465,174520,174869,174885,174954,17513,175150,175320,175436,175449,175537,176118,176171,176651,176827,17691,177505,177540,177540,177994,178100,178121,17856,178665,178712,17894,179113,1792,179408,179508,17967,179829,179913,179946,180415,180582,181064,181231,181283,181443,181726,181743,181768,182020,182237,182321,182711,182721,182747,182824,183126,183492,18361,183876,184183,184415,184790,18485,184899,185127,185164,185331,185433,185458,185517,185615,185734,185878,186050,186339,186362,186495,186644,186943,187090,187196,187306,188175,188189,188221,18866,189109,18921,189241,189332,189383,189596,189692,189726,189751,190001,190032,190636,191091,19122,192449,192502,19253,193035,193055,193296,19374,193945,193969,194181,194351,194510,194735,195360,195439,195603,195919,195993,196201,196358,196411,196425,196496,19684,196906,197067,197434,197434,197852,197875,198339,198444,198588,199238,199448,199715,199852,200006,200266,201242,201249,201631,201686,202015,202064,202284,202431,202561,202565,202646,20317,20343,203531,20429,204427,20450,204502,204582,205009,205009,205009,205009,205038,205136,205756,205818,206252,206436,206538,20760,207984,208015,208459,208566,209039,209053,209062,209234,209284,209380,209839,210462,210509,210693,210771,211157,212290,212528,212814,212971,213227,213619,213650,213666,213751,214200,214592,214597,214990,215353,216272,216415,216648,216919,217361,217702,217768,217768,217865,218033,218033,218033,218033,218033,218606,218639,21873,218924,219115,21920,219336,219500,21969,220202,220236,220313,220372,220464,220562,220566,220693,220893,221349,221475,221526,221527,221628,221656,221677,222236,222256,222455,22249,222841,223047,22335,223630,224052,224610,224929,225087,225133,225446,225761,225813,226183,226535,226535,226535,226535,22677,226919,227323,227481,227598,227662,227858,227894,22793,227980,228153,228394,228677,228816,229326,229494,229540,22958,229640,229880,2299,230027,230053,231663,231728,231769,232068,232894,232989,23299,233479,23355,233651,23414,234288,234587,234852,234939,234958,235019,235029,235378,23560,23565,235807,236123,236538,236622,236669,236940,237095,237106,237154,237219,237403,23741,237430,237500,237758,237837,237997,23811,238175,238304,238886,239128,239231,239492,239914,240066,240314,240497,240541,240735,240854,24094,241185,241573,241912,242100,242326,24296,243160,243176,243403,243549,243562,243645,243654,243961,244174,244475,244894,244970,245486,245647,245806,24609,246534,24701,247342,247392,247404,247423,247435,247507,247722,247755,247786,247924,247938,24809,248313,248463,248550,248736,248866,249257,250095,250286,250323,25038,250594,250670,250864,250896,25102,251087,251239,251474,25183,251845,252552,253042,253127,253529,253573,253628,253639,2537,253707,253782,253814,254042,254518,25456,254629,254735,254737,255018,255301,255544,255734,256080,256638,256688,256931,257192,257375,258380,25860,258833,259016,25965,259874,25990,260105,260184,260199,260263,260677,260723,26133,261523,261645,261650,261818,262164,262371,262541,262667,263022,26319,263294,263880,264013,264070,264198,264607,264727,266180,266391,266452,266692,266892,266923,267208,267782,268241,268282,268857,268916,268992,26900,269185,269243,269256,269296,26956,269627,26973,270006,270204,27057,270642,270692,271077,271326,271525,271641,272,27223,272323,272342,272491,272703,272721,272849,273136,27335,273370,273404,273573,273978,274306,274584,274709,275024,275059,275148,27633,276814,277121,277315,277336,277727,277933,278072,278332,278441,278457,278827,27906,27916,279237,279323,279623,279856,280560,280821,280838,280889,280916,281351,281753,281995,282078,282835,283003,283042,283323,283756,283875,2844,284500,284523,284687,28469,284999,284999,284999,284999,285053,28508,285133,285217,285412,285749,286418,286434,286524,286545,286831,286873,287108,287731,287838,287867,287961,288157,288166,288516,288563,28865,288827,288885,289015,289561,289750,2899,290185,290194,290254,290944,291319,291323,291517,291680,2920,292106,292485,293460,293463,294150,294151,294180,29438,294585,29472,294777,294935,294938,295494,295580,295627,29563,295857,296053,296260,296311,29667,296780,297075,297292,298079,298136,298191,298298,298789,299150,299150,299211,299248,299401,299539,29963,299871,300046,300047,300110,300268,300306,300425,300519,300652,300652,300833,301622,301865,302684,302764,302876,30294,303124,303374,303643,303727,303879,304002,304473,304614,305220,306073,306075,306179,306214,306294,30642,306585,306639,306650,306814,307136,307201,307486,307553,307685,307944,30799,308203,308206,308515,308734,309037,309114,309172,309198,309281,30943,30943,30943,30943,309724,309750,309950,310311,310728,311441,311455,311734,311734,311736,31213,312332,31234,312584,312641,312680,312710,312787,31309,313400,313418,31342,313484,313535,313666,313847,3139,314793,314876,315282,315313,315439,315723,316221,316358,317021,317095,317161,317678,317689,318338,318443,318630,318768,318808,318993,319381,319424,319555,319961,320059,320091,320337,32052,320599,320765,320821,320850,321194,321505,321602,322064,322244,323291,324039,324143,324357,32441,324457,325135,325657,326162,326325,326563,32667,32667,32667,32667,327253,327563,328436,32851,328746,328861,329444,329904,330771,330965,331134,331276,331351,331629,331651,331722,331822,331855,332028,332414,332427,332471,332647,332764,333332,333459,333530,333592,33397,334111,334205,334265,334823,334836,334990,335270,335517,335683,335725,335784,336576,336680,336742,336795,337208,337214,337735,337736,337938,338028,338184,338488,338865,338917,339169,33922,339251,339566,339745,339829,34045,340687,340737,34121,34125,341441,341595,341616,341695,342466,342598,342902,343415,344531,344617,34474,344807,344827,344931,345297,345661,345791,345949,346375,346667,347343,348228,348264,348826,348826,348826,348826,348826,34899,349028,349450,349465,349723,350072,350241,35091,351309,351794,351806,352088,352136,352489,352996,353183,353660,354250,354699,354779,355123,355816,355852,355933,356545,356743,357470,357594,357801,358254,358343,358623,358736,358805,35986,360402,360448,361507,361705,361713,361719,361734,361783,361890,362254,362418,362705,362705,363198,363910,364289,364425,364679,364756,365161,365337,365377,365521,365919,366260,366546,366756,366919,367058,367075,367149,367611,367699,367760,367806,36842,368648,368656,368872,368997,36915,36915,369436,369436,369436,369436,369920,369981,370236,370517,370689,37083,371011,371052,371314,372171,372363,372494,372587,372908,37315,373177,373472,373492,373748,373889,374046,374064,37408,374195,374470,374631,374753,375185,37557,376012,376127,37615,376213,376577,376594,376906,377109,377163,377495,377558,377652,377803,377946,378033,378247,378456,37855,378831,378831,37902,379049,379277,379738,380127,380643,380781,380855,381122,381265,381739,382043,382045,382158,38235,382583,383010,383026,383046,383073,383145,383280,383506,383687,384043,384168,38439,384455,38493,385672,386019,386522,386645,386691,387131,387192,387311,387517,387651,38780,387831,387892,387942,388064,388205,388296,38893,389097,389129,389316,389345,389461,389610,389726,389902,390340,390764,391163,391214,391327,391614,391677,392667,392705,392838,392968,39321,393740,39377,393824,393980,394251,394435,394468,394579,394749,394810,395006,395134,395244,395947,395962,396132,396602,397171,39719,397361,397773,397881,397937,398011,39847,398612,398778,398785,398991,399151,399431,399451,399475,399695,399835,400566,401135,401138,401379,401515,401781,401864,401870,402458,402735,403225,403416,403485,403619,403634,403803,404186,404499,404945,405970,406370,406515,406639,406861,407227,407711,408514,408537,409325,409493,409629,409787,409823,410006,410111,410327,410716,41073,410767,410931,411290,411360,411419,411449,41189,411926,411969,412522,412532,412974,413100,413246,41348,413700,4142,414410,414454,414580,414744,414774,415221,415344,41601,416352,416998,417893,418004,418308,418363,41849,418635,419309,419362,41937,419654,420142,420151,420322,420736,420765,420959,421008,421203,421584,422113,422132,42250,422607,422638,422909,423262,423533,423694,42395,424068,424073,424075,424696,424727,424731,42475,424898,425195,425348,425462,425715,425784,426021,426171,426195,426439,426613,426639,426898,426939,426959,42768,428050,428386,428484,429120,429184,429589,429758,429780,429866,429891,430167,430560,430679,43073,430801,43089,430900,431218,431319,431423,431625,43186,431877,431973,432121,432514,433285,433570,434024,434062,434062,434062,434062,434268,434296,434424,434663,434718,434768,435e3,435210,435464,435602,435766,43588,435956,435964,436199,436232,436861,436892,436954,437054,43710,437165,437173,437313,4374,437622,437628,438174,438376,438749,438797,438835,438839,439113,439117,439122,439281,439728,439748,439786,439984,440193,440369,440473,440490,440676,440770,440776,440900,440952,440976,441,44135,441670,442326,442535,442722,442801,442938,443068,443543,443634,443780,443820,443900,444504,444837,444868,445272,445274,445495,44585,446068,446078,446084,446353,446649,447068,447213,447238,447614,448138,448139,448350,448557,4486,448849,449024,449098,449367,449570,44970,450060,450295,45062,450861,451069,451083,451249,451305,45181,451881,452038,452272,452489,452614,452797,45294,453189,453248,453450,453643,454050,454293,454444,45452,454587,454704,454735,454744,45519,455478,455581,456401,456614,456641,4568,456825,456827,45779,457965,458156,458261,458403,458416,458417,458446,458544,458606,458726,459059,459766,459837,459979,460333,460383,461052,461104,46127,461297,461386,461487,46164,462893,463885,464183,464478,465188,465243,465412,465594,466213,466808,466817,46754,467648,467835,467907,468303,46847,468528,469104,469496,469910,469951,469964,470072,470797,471326,471620,471641,471865,472037,472961,473025,473377,473385,473543,473625,473907,474185,474666,474787,475112,475252,475274,475281,475308,475993,476407,476637,476857,477055,477082,477164,477232,477305,477479,477738,478106,478110,478367,478420,478976,47913,479248,479343,479376,479447,479731,480021,480031,480130,480242,480480,480907,481108,481343,481382,481394,481654,482118,482133,482442,482465,482730,482747,482903,482903,483064,483388,483405,483596,483625,483801,483885,484157,484302,484332,48529,485516,48569,485789,486840,487115,487135,487208,487429,48750,488669,48873,488862,488951,489019,489060,489076,489220,489871,490319,490335,490388,491305,491576,491698,492807,492949,4930,493059,493063,493070,493332,493404,493816,493860,493999,494142,494329,494750,495749,495958,496017,496324,496775,496920,497023,497305,497325,497432,497825,497946,498103,498387,498603,498624,498784,499749,499985,500023,500855,501047,501056,501100,50133,501662,502459,503157,503344,503968,504222,504423,504507,504580,504622,50468,504732,504782,505071,505270,505478,50550,506484,506652,507003,507096,507206,507307,507321,507335,507408,507475,507837,507850,508112,508406,508538,5092,509289,509486,509910,510172,510353,510995,511357,512494,512664,512755,513853,514715,514753,514800,514919,514981,515232,515405,515672,515835,515850,515923,516020,516452,516776,517186,517299,517452,517846,517899,518128,518176,518307,518332,518684,518706,518805,518833,518992,519136,51953,519632,51966,519740,520124,520143,520169,520425,520769,520803,520803,520989,521112,521128,521276,521282,521308,521607,521640,521751,521981,52212,522317,522442,522855,523162,523311,523315,523391,523414,523891,524278,524512,524670,524814,525721,52599,526049,526721,527011,527122,527160,528804,529,529023,52918,529244,529247,529711,529944,530690,530932,530953,530953,530980,531004,531325,531728,531871,531888,532115,532203,532632,532690,532747,532912,533132,533193,533770,5338,534115,534863,535177,535411,535726,536006,536028,536084,536112,536188,536266,536529,536687,536827,537127,537238,537324,537366,537610,538093,538710,538874,539322,539355,539518,539778,540137,540603,540866,541417,541909,542159,542386,542429,5427,542780,542824,542967,543007,54318,543246,543427,543603,543918,543942,543960,544187,544323,545149,545423,545791,546053,546219,546243,546690,54675,546766,546938,54724,547950,548764,549169,549991,550141,550315,55035,551044,551895,552299,55273,553038,553346,553607,553827,553926,554218,554322,554376,554606,554807,555426,555765,555974,55604,556097,556109,556354,55638,556888,557213,557309,55744,55768,557768,557788,558203,558262,558306,558348,558726,559131,559133,559167,559620,559873,560304,560661,560670,561012,561092,561459,561864,562421,562719,563451,563632,563712,564039,564199,564260,564463,564570,564993,565128,565478,565654,565861,565941,566622,56675,567064,567087,567230,567637,567995,568432,5685,568515,568615,568696,568873,568893,569337,569524,5696,5696,57027,570330,570601,571483,571745,572213,572330,572356,57260,572640,572791,573139,573630,573713,573873,574193,574211,574356,574618,575131,575214,575483,575510,575619,57562,575774,575790,57593,576384,576693,576988,576994,577205,577237,577279,577300,577576,577683,577779,578279,578423,578926,579065,579303,579358,579763,579847,580253,580445,580585,580610,580802,580832,581207,581339,581716,581831,581843,582250,582304,583064,583078,583737,584243,584358,584444,585134,585152,585445,585453,585670,58568,585761,585844,585928,586048,586143,586240,586297,586297,586297,586297,58631,586577,586614,586677,587,587279,587295,587383,588095,588176,588298,588320,58836,588398,588498,588575,588917,589022,58925,589562,589569,589628,589642,590151,590343,590446,591049,591058,591105,591197,591425,592181,592235,592492,59293,592990,593130,593226,593258,593457,593631,593704,594060,594108,594450,594768,595440,595468,595502,59555,59555,596271,596364,596396,596414,596472,596790,596829,597106,597416,597436,598328,598525,598667,599e3,599224,59939,599425,599475,599645,599948,599962,600193,60046,600540,600831,60088,601504,601592,601647,60192,602084,602532,602665,603139,603343,603534,603735,603742,603826,604087,604239,60593,606122,606173,606308,606464,606760,606807,606965,606984,607335,607420,608182,608305,608416,60872,608960,608972,609654,609670,609949,609989,610332,610378,610696,610820,610923,611770,6121,612650,61283,613559,614323,614737,614781,614821,614852,614855,615605,615924,616212,616245,61625,616310,616713,617209,617318,617651,617936,618052,618096,618277,618693,618932,619232,619454,619470,619486,619745,620329,62037,620955,621287,621358,621902,622305,622713,622784,622922,623315,623654,623735,623935,624250,624404,624720,625338,625526,625564,626041,626438,626481,627009,627038,627326,6280,628367,628478,628530,629265,629273,629456,629909,630496,630841,630949,631254,631275,631442,632316,63260,632690,632817,633090,633193,63342,633683,633690,633785,634120,634419,634547,634660,635237,635299,635349,635607,635876,636447,636579,63681,63682,636925,636925,636925,636925,637134,637241,637312,637330,637778,637861,638063,638162,638228,638846,638927,638940,639036,639049,639362,639498,639698,639898,64006,640421,640469,640469,640469,640469,640655,640758,640901,64119,641315,641316,641334,641538,641762,642112,642181,64235,642350,642371,642540,643053,643132,643246,644757,644847,644854,645086,645770,646117,646178,646241,64625,646289,646552,646826,647168,647731,648210,648273,64858,648954,649050,649071,64950,649564,649614,649853,649943,650,65068,650710,650756,650836,651095,651564,651571,651980,652119,652167,652318,652499,652782,653098,654153,654352,654487,654639,655204,655319,655335,655340,655850,656054,656230,656252,656317,656615,656685,657218,65725,657700,657754,657872,658152,658157,658684,658718,658764,658805,658904,658924,65896,659173,659195,659212,659579,659677,659714,660063,66010,660332,660955,661287,661329,661377,661692,661796,662067,662090,662304,662509,662664,66305,663870,664254,665028,665309,665541,666011,666015,666499,666766,666771,66681,666989,667202,667436,667551,66760,667629,667855,66822,668636,668673,668751,668795,668852,6690,669110,669165,669217,669358,669378,669909,670217,670684,67093,671054,671054,671075,671106,671656,671839,672632,672911,672925,673265,673913,674156,674366,674382,674924,675160,675274,675597,675656,675925,67606,676432,676525,67661,676864,677245,677465,677740,677890,678507,678606,678863,67906,679140,67957,680162,680245,680440,680800,680927,68102,68119,681292,681881,681978,681982,682224,682428,682504,682566,682685,682705,682950,682988,683,68306,683061,683433,683683,683996,684289,684835,684936,685294,685346,685780,685986,686834,686898,686898,686898,686898,687165,687507,6877,68772,68806,688180,68862,68932,689418,689786,689851,690109,690134,690554,691232,691241,691897,692002,692322,692499,693281,694068,694196,695094,695854,696054,696128,696778,696836,697120,697136,697141,697179,697363,697616,697880,698122,698208,69830,698694,699894,700159,700823,700850,700898,700958,701864,702176,70229,702294,702705,702802,703279,703303,703346,703752,704169,70435,704588,704901,705098,705106,705120,705195,705227,705406,705612,705676,706151,706360,706439,706734,706890,706902,706990,707455,707493,707773,70935,709385,709723,709913,709971,710100,7103,710308,710335,710362,710517,710580,710591,710638,711023,711024,711035,711055,711139,711457,711540,711615,711994,712177,712252,712383,71239,712587,712894,713117,713376,71353,713633,713700,71427,714725,714879,71507,715276,715303,715390,715918,716004,716229,716297,716425,717058,71707,71717,717763,717961,71801,718030,718246,71826,72e3,720063,720262,720578,720698,721127,721641,721755,72187,722142,722198,722757,722939,72297,72311,723372,723443,724180,724194,724270,724593,724727,724803,724935,725003,725018,725103,725115,725312,725396,725411,725528,725613,725629,725736,725873,72603,72617,726599,726607,726999,727246,727300,727337,727961,72828,728284,728372,728497,728561,728620,728857,728966,729866,730006,730027,730280,73050,730597,730794,73095,730994,731047,731136,731339,731409,731728,732006,732186,732462,732623,73338,733477,733679,733686,733814,734041,734221,734275,734845,734910,735191,735311,735641,73579,735929,736170,736172,736306,736324,736552,737117,737289,737462,737513,737518,737719,737739,738,738012,738215,738663,738903,739164,739472,739646,740366,740674,740764,740953,740953,740953,740953,741070,741212,741347,741840,741989,742303,742415,743025,743207,743241,743771,743795,743890,744093,744239,744850,745e3,745095,745332,745565,745671,745766,745901,746618,746769,746828,746883,747598,747707,747835,748049,748222,748364,748717,748792,748811,748994,749035,749153,749562,749728,749808,749965,7500,750001,751487,751490,751557,751741,752271,752351,753e3,7533,75349,753676,753808,753908,754007,754215,75433,754486,75452,754720,755047,75514,755935,756036,756098,756497,756509,756648,757011,757330,757559,757867,758285,758363,758438,759027,759595,759791,760191,760264,760351,760994,761649,761665,76184,762115,762418,762430,762526,762550,762661,762780,763052,763073,76318,763220,76323,76349,763548,763636,763639,763797,763985,764130,764522,764540,764616,764670,764918,764960,765124,765919,766204,766322,766364,766372,766597,766707,767248,767807,767902,768110,768132,768344,768427,768466,768715,76885,768968,769544,769604,769682,769886,770100,770180,770399,770418,770845,771042,771078,771085,771201,771669,771829,772294,772409,772638,772961,773318,773417,774095,774153,774243,774281,774323,77435,77505,775072,776141,776320,776500,776598,77691,777006,777022,777040,777051,777292,777544,777544,777732,778029,778063,778093,778368,778630,779370,779518,779719,779865,7799,780305,78052,780555,780572,780578,780671,780829,780991,781342,781448,781700,782113,782189,782219,782343,782399,782895,783058,783169,783431,783566,783714,784108,784289,7844,784598,784671,784686,785015,785449,785591,785859,785935,786748,786881,78714,787290,787544,787561,787631,78766,788289,788614,788787,788854,788932,789006,789151,789186,789408,789585,789662,789844,790453,790804,790882,791146,791774,791791,791796,792053,79222,792570,792665,793174,793574,793735,793923,794360,79443,794646,794857,794921,795223,795585,796178,796213,796213,796404,796404,796404,796404,796404,796413,796524,797056,797095,797300,797948,79811,798328,79860,798610,798806,799580,799589,800014,800331,800609,801121,801189,801251,80127,80157,801689,802184,8024,802870,80339,803402,804154,804442,805326,805582,805626,805804,80583,806084,806201,806625,806911,807181,807417,807605,807720,807895,808069,808227,808681,809120,80931,809581,809654,809663,809726,809745,809873,810437,810462,810623,810649,810814,810839,810964,811077,811154,811398,811437,811491,81170,811940,812045,812553,812582,812994,813209,813278,813321,813498,813897,813908,814086,814378,814393,814461,814642,815071,81523,815268,815583,815614,815629,815841,815953,81598,816245,816402,816402,816402,816402,816467,816519,816752,816773,817376,817806,817907,818658,818798,818881,818906,81892,819107,819157,820311,821328,821436,821447,821781,821858,822376,823169,82353,823531,823673,823803,823803,824017,824240,824597,82471,824722,824781,825057,825066,825133,825361,825461,825617,825745,826042,826595,826596,826686,827013,827040,827368,827370,827460,82770,828126,828227,828305,828787,829140,829272,829655,829751,829892,83014,830377,830636,83087,831125,831329,83149,831553,831703,831987,832065,832353,832430,832514,832670,832678,833961,834018,83432,834407,834923,835373,835391,83555,835729,835738,835923,836293,836401,836441,836658,83679,837112,837142,837287,837316,8375,837844,838269,838517,839081,839704,840374,840483,840840,840983,841103,841612,841759,841929,841993,842004,842032,842048,84274,842856,842994,843334,843579,844056,844257,844418,844935,8456,845736,846442,846973,84701,847258,847993,84849,84852,848587,848843,84886,848896,848896,849177,849443,849533,84955,850089,850891,851365,851389,851711,851887,851987,85292,852991,85317,853249,853619,854029,854052,854110,854353,854598,854737,854792,854912,855232,855451,855635,855637,855769,856034,857073,857111,857172,857208,857243,857665,857745,857991,858032,858067,858235,858323,858465,858493,858572,858718,858753,858863,858928,859176,859469,859504,85965,859689,859830,860007,860339,860603,861029,86111,862191,862209,862262,863294,863373,863459,863566,863798,86428,864468,865137,865210,865797,865985,86652,866625,86664,866708,866766,866900,866971,866991,867168,867343,867405,867975,868143,868415,868917,86907,869622,86965,869782,869949,869949,870087,870445,870543,870721,871008,871008,871251,871763,87191,872104,872200,872582,873084,87314,873166,873178,8737,873702,873749,874088,874604,874619,87488,875057,875258,875450,875525,875532,876488,877258,878066,878202,878776,878875,878946,879271,879429,879958,87998,880009,880410,880416,88060,880687,880724,880795,88087,880909,880933,881061,881232,881245,881882,882016,882298,882398,882409,88247,882584,88320,883682,883775,88383,883931,884858,885175,885276,885662,885711,885830,886067,886125,886363,886376,886418,886418,88667,886705,887281,887590,887717,88834,888867,889421,889767,889814,889988,890051,890154,890194,890437,890845,891445,891545,892014,892263,892267,89279,89347,893638,894123,894193,894521,894521,894521,894521,894521,895175,895279,895462,896090,896336,896559,896832,896848,897360,898005,898086,898440,89881,898837,898851,899184,899210,899497,899869,90004,900311,900463,901497,901506,901773,902299,902315,90260,902635,902820,90317,9038,904062,904247,904249,904346,904438,904445,904497,904573,904678,90507,905687,906057,906153,90627,906283,906309,906588,906980,907109,907508,907606,907830,908226,908355,909122,909344,909381,909478,909521,909581,909582,909904,91050,910606,910689,910894,910919,911026,911134,911361,911455,911485,911552,911873,912047,912231,912445,912996,91348,913620,913702,913893,914022,914125,914475,914515,914703,914826,914827,914878,915742,915785,915925,916174,916272,916398,916595,916824,916926,917214,918227,918353,918540,918886,918935,919074,91909,919344,919388,919443,920038,920117,920122,920342,920427,920499,920540,920623,920684,920906,921828,921836,922047,922749,92326,923286,923381,923484,923682,923956,924056,924066,92491,92513,925147,92531,925365,926266,92627,926412,926745,926791,926912,927038,927166,927737,92786,927893,928062,92807,929063,929354,929366,929371,92984,92988,929884,930171,930531,930574,930626,931025,931507,931830,932586,93264,932791,934381,934460,934644,934682,934812,934899,935276,93534,935603,935614,93583,935892,935988,936007,936014,936112,936276,936854,937380,937403,937510,93769,937746,938603,938685,938742,938936,939041,939195,939284,939343,93990,940409,940898,940956,940962,941311,941503,941581,941920,942192,942236,942566,942895,942946,943202,943398,943627,943804,943819,943912,943971,944220,944496,944661,944674,944833,944976,945028,945519,946177,946235,946251,94630,946502,946554,946802,947266,947276,947290,948156,948362,948569,948835,949230,949249,949320,949816,950230,950544,950659,950689,950887,950913,9510,9510,9510,9510,9510,951571,95180,951903,952045,952607,95290,953118,953215,953449,953542,954280,954349,954353,954376,954614,954726,954870,95516,955706,955944,956166,956313,956452,956517,956853,956861,957449,957604,957830,957854,957948,958345,958374,958709,958871,959519,959588,95960,959614,95969,96005,960085,960117,960178,960297,960315,961379,961683,961819,962331,962536,962857,962986,963266,96340,963493,963689,964451,964779,96537,965519,965639,965657,966021,966374,966383,966849,967142,96735,967411,967684,967746,967746,968055,968255,968565,969124,969210,969210,969402,969617,969716,969866,969893,969898,970276,970945,970962,971155,971301,97171,972160,972238,972380,972818,972865,972866,972896,972962,973629,973704,973802,974209,974280,97441,974415,974535,974556,974672,974815,975186,975269,975762,975816,975908,976210,976907,97695,97719,977222,97740,977441,977728,97813,978428,978512,978969,979536,97966,980062,980342,980385,9805,980785,981129,981344,981393,981834,981909,982029,982211,982287,982314,982587,982773,983113,983375,983556,983736,983916,984409,984423,985691,985728,986848,98703,987462,987701,987724,98804,988110,988381,988398,988600,98878,989052,989288,98934,989433,989472,989810,990087,990105,990193,990233,990265,99027,990790,991074,99131,99157,991697,992377,992396,992565,992582,993041,993051,993177,994044,994682,994864,994888,99490,995477,9957,99643,996526,996623,996697,996788,997100,997403,997468,997595,997783,998125,998797,998879,999156,999394,999443,999655,99981]],["@babel/runtime",[124255,127119,138312,143311,150247,187094,21082,211344,266103,267178,300283,34276,369953,387539,398667,406527,423860,440484,442721,449859,451055,45735,457812,463565,474658,476205,498421,500069,502349,538253,543692,560458,562954,612823,647501,6490,688947,694801,708405,709371,71586,757709,779786,782338,783093,789948,800928,810356,824076,838019,841024,854717,871820,877159,896478,935191,979245,98105,999227]],["@blockaid/ppom_release",[297481,89962]],["@emotion/react",[230908,954541]],["@emotion/react>@emotion/cache",[145319]],["@emotion/react>@emotion/cache>@emotion/memoize",[880657]],["@emotion/react>@emotion/cache>@emotion/sheet",[849159]],["@emotion/react>@emotion/cache>stylis",[176154,272480,292907,709823,857267,985114]],["@emotion/react>@emotion/serialize",[612093]],["@emotion/react>@emotion/serialize>@emotion/hash",[866385]],["@emotion/react>@emotion/serialize>@emotion/unitless",[591217]],["@emotion/react>@emotion/use-insertion-effect-with-fallbacks",[128999]],["@emotion/react>@emotion/utils",[839145]],["@emotion/styled",[266708,551187]],["@emotion/styled>@emotion/is-prop-valid",[262835]],["@ensdomains/content-hash",[711571,763621,90624]],["@ensdomains/content-hash>cids",[648765,88526]],["@ensdomains/content-hash>cids>multibase",[233501,381080,482618,809850,896573]],["@ensdomains/content-hash>cids>multibase>@multiformats/base-x",[20793]],["@ensdomains/content-hash>cids>multihashes",[725041,860834]],["@ensdomains/content-hash>cids>multihashes>uint8arrays",[670298,827652,928753]],["@ensdomains/content-hash>cids>multihashes>varint",[235895,680701,801833,844063]],["@ensdomains/content-hash>cids>uint8arrays",[285918,562037,682578]],["@ensdomains/content-hash>js-base64",[765268]],["@ensdomains/content-hash>multicodec",[343708,392394,519477,660610]],["@ensdomains/content-hash>multicodec>uint8arrays",[14839,152785,314935,439470,580986,845617]],["@ensdomains/content-hash>multihashes",[539420,987551]],["@ensdomains/content-hash>multihashes>buffer",[960382]],["@ensdomains/content-hash>multihashes>multibase",[447008,496255,70852,748470,975895]],["@ensdomains/content-hash>multihashes>multibase>base-x",[627585,874484]],["@ensdomains/content-hash>multihashes>varint",[531372,551085,772681,986270]],["@ensdomains/content-hash>multihashes>web-encoding",[869988]],["@ethereumjs/tx",[100452,126896,127314,127469,155e3,204174,215366,229621,242676,248188,279528,282703,325733,331552,407539,423299,443901,48571,488755,492139,496696,571637,71116,711730,773608,795957,815357,819153,830723,841505,954555,986248,986319,988296]],["@ethereumjs/tx>@ethereumjs/common",[116114,138049,186782,207769,256388,428097,435515,440598,584775,597767,617778,712153,77547,842159,921628,932733]],["@ethereumjs/tx>@ethereumjs/rlp",[340904,626536,971047]],["@ethereumjs/tx>@ethereumjs/util",[121208,160942,18546,197133,199456,211645,213333,220681,262336,268411,29433,296648,310188,311718,336422,341872,349456,380211,384377,388655,416527,437881,448578,478459,47909,482875,487277,528720,543178,554880,555440,580203,586720,596187,601803,623052,632496,657076,671762,67618,700862,73689,741736,783798,794537,836584,83895,855224,874349,881019,888838,890415,892667,898069,899217,906238,932477,986881,99683]],["@ethereumjs/tx>@ethereumjs/util>ethereum-cryptography",[110377,219828,301302,395902,401868,452197,492340,492943,535309,567417,732]],["@ethereumjs/tx>@ethereumjs/util>ethereum-cryptography>@noble/curves",[107004,108099,11988,224981,266786,278956,321706,362528,462089,495448,617072,622643,671003,678298,707428,710609,762871,796262,8279]],["@ethereumjs/tx>@ethereumjs/util>ethereum-cryptography>@noble/hashes",[10780,224683,285861,321705,359750,445115,447856,476244,479679,481449,482559,49331,533968,543657,610068,720684,779289,802349,813303,862335,915253,929920,963426,99072]],["@ethereumjs/tx>ethereum-cryptography",[271465,32063,81446,840174]],["@ethereumjs/tx>ethereum-cryptography>@noble/hashes",[130407,224661,301020,362180,430243,532953,936495,972637]],["@ethersproject/abi",[160782,187698,207619,248560,250722,2720,290117,379705,380106,393718,402741,403119,408505,440340,450337,458109,482055,485050,552281,552364,562009,593735,611782,651911,658511,715904,719910,815222,869209,871050,920407,936830]],["@ethersproject/bignumber",[264186,323489,367302,631229,664386,726731,72742]],["@ethersproject/bytes",[168083,524443,771214,993558]],["@ethersproject/contracts",[143722,264926,295523,391959]],["@ethersproject/hdnode",[42014,563965,91135,986604]],["@ethersproject/providers",[1088,113977,138919,144240,159222,203284,235086,260777,272455,272585,280620,286156,375693,380392,396515,411019,416895,460607,504409,550112,639723,675682,683411,702541,728024,728189,732500,744172,806355,81059,819790,882951,890742,900366,927789,930847,935424,981328,981506,996520]],["@ethersproject/providers>bech32",[579841,855010]],["@ethersproject/transactions",[482925,720839,892890,894e3]],["@fortawesome/fontawesome-free",[1527,1527,1527,1527,411525,411525,411525,411525,70035,70035,70035,70035]],["@google/genai>protobufjs",[119463,151942,179394,19298,218825,230388,233393,241032,263003,265120,275867,277049,28e3,281537,293812,298411,299467,31787,350553,35271,367471,370596,399483,411124,4128,420921,481277,488703,504982,538938,540186,54984,550602,626969,649399,662177,674975,676114,677694,727772,735901,747294,7501,750894,762632,76482,792509,796011,798572,808144,811348,817362,829594,832422,864122,912725,912770,912808,929078,954023,960613,961051,986237,987729]],["@google/genai>protobufjs>@protobufjs/aspromise",[35757,884264]],["@google/genai>protobufjs>@protobufjs/base64",[380567,783712]],["@google/genai>protobufjs>@protobufjs/codegen",[406164,80225]],["@google/genai>protobufjs>@protobufjs/eventemitter",[807179,846230]],["@google/genai>protobufjs>@protobufjs/fetch",[129177,33055,890554,895260]],["@google/genai>protobufjs>@protobufjs/float",[179442,5453]],["@google/genai>protobufjs>@protobufjs/path",[437271,450960]],["@google/genai>protobufjs>@protobufjs/pool",[476366,675811]],["@google/genai>protobufjs>@protobufjs/utf8",[544152,843255]],["@google/genai>protobufjs>long",[35849,742559]],["@hello-pangea/dnd",[300039]],["@hello-pangea/dnd>css-box-model",[200635]],["@hello-pangea/dnd>css-box-model>tiny-invariant",[387325]],["@hello-pangea/dnd>memoize-one",[62147]],["@hello-pangea/dnd>raf-schd",[930197]],["@hello-pangea/dnd>react-redux",[149014,300155,31974,338336,372198,378973,391665,418855,431633,472817,567731,588406,643599,681892,72634,779334,844178,887933,899944,900884,9258,976618]],["@hello-pangea/dnd>use-memo-one",[214897]],["@keystonehq/bc-ur-registry-eth",[2593,544829]],["@keystonehq/bc-ur-registry-eth>@keystonehq/bc-ur-registry",[124e3,191052,231626,249615,265655,2977,459024,467722,527355,534855,564315,573995,57636,646539,67798,682001,747747,773884,794735,804119,867283,883483,927029,939286,976399,987339]],["@lavamoat/lavadome-react",[494708]],["@lavamoat/webpack>json-stable-stringify>isarray",[312701,664074]],["@lavamoat/webpack>json-stable-stringify>object-keys",[25880,266165,643408,651180,69051,910229]],["@ledgerhq/errors",[30649,315100,441063,927428]],["@ledgerhq/hw-app-eth",[104027,104586,113800,268879,30606,383317,463313,536227,551257,568746,63684,687439,705565,906779]],["@ledgerhq/hw-app-eth>@ledgerhq/cryptoassets-evm-signatures",[116736,116736,124859,124859,163015,163015,169781,169781,199597,199597,210703,210703,230970,236883,236883,248848,248848,250685,250685,255154,255154,258052,258052,274109,274109,322847,322847,334270,334270,347020,347020,366551,366551,369002,37908,37908,384717,384717,404282,404282,416093,416093,419682,419682,443852,443852,462622,462622,477649,477649,480075,480075,518851,518851,519988,519988,524815,524815,527390,527390,545688,545688,579237,579237,590888,590888,591272,591272,594750,594750,605933,605933,610625,610625,616814,616814,626884,626884,668059,668059,672311,672311,67928,67928,696055,696055,730571,730571,743225,743225,745686,745686,762051,762051,765119,78373,78373,787985,787985,819889,819889,835776,835776,848707,848707,867849,867849,89350,89350,895421,895421,902902,902902,908299,908299,9231,9231,938612,938612,950401,950401,95776,95776,983883,983883]],["@ledgerhq/hw-app-eth>@ledgerhq/domain-service",[224675,565967,862553]],["@ledgerhq/hw-app-eth>@ledgerhq/evm-tools",[454077,819304,977702]],["@ledgerhq/hw-app-eth>@ledgerhq/evm-tools>@ledgerhq/live-env",[265370,373941]],["@ledgerhq/hw-app-eth>@ledgerhq/logs",[293263,878528]],["@ledgerhq/hw-app-eth>bignumber.js",[784124]],["@ledgerhq/hw-transport",[425078]],["@ledgerhq/hw-transport-webhid",[53406]],["@ledgerhq/hw-transport-webhid>@ledgerhq/devices",[42324,695006]],["@ledgerhq/hw-transport-webhid>@ledgerhq/devices>semver",[122508,124306,153063,156827,196336,206080,219259,238402,248308,254004,273435,281017,2911,292487,308262,327803,35765,375822,421895,48037,486088,50122,5166,599021,632189,66184,723811,734082,744484,756398,762961,81032,829019,832090,852453,853846,867350,898423,898721,901711,909957,93192,960393,989346,997168]],["@ledgerhq/hw-transport-webhid>@ledgerhq/hw-transport",[127439]],["@metamask/abi-utils",[104527,163221,180719,181547,252332,29607,311312,31395,352360,364285,367419,374084,479238,502414,506505,542691,543719,548249,553588,561343,56970,577033,578808,601499,627674,635414,713226,743732,756330,785400,808591,833750,838797,883821,894281,933680,961858,968912,974538,986563]],["@metamask/account-api",[268904,360726,365091,413664,462357,531819,549214,571296,629721,673324,674288,689812,716904,809904]],["@metamask/account-tree-controller",[13542,138257,173205,212369,236973,259639,270718,294987,315572,320199,321902,335349,356750,36937,370246,383170,384983,402561,414944,41997,422719,424752,433995,436829,441657,460699,46262,492702,517113,550321,56028,564758,564855,599500,599683,640323,662092,676429,687542,788527,81909,827362,864116,897883,926479,93043,938533,974423,992452,997182]],["@metamask/accounts-controller",[53178,590677,61322,888029]],["@metamask/accounts-controller>ethereum-cryptography",[266988,575454,586390,671508]],["@metamask/accounts-controller>ethereum-cryptography>@noble/hashes",[380393,407105,521377,619894,655163,700931,748103,872574]],["@metamask/address-book-controller",[491368]],["@metamask/analytics-controller",[687955,861530,941375,951797]],["@metamask/announcement-controller",[207587]],["@metamask/approval-controller",[207291,394813,612619,65997]],["@metamask/assets-controller",[130846,140957,143147,147759,163545,169086,201103,241943,253139,255891,26522,266468,267269,285435,286306,291552,326236,347263,370534,37479,384614,391638,405369,44327,47791,496414,500016,506204,528304,528955,532612,535325,541939,559461,562411,563688,572108,577596,583584,591385,598311,599195,603342,609957,631549,636645,651463,659933,669792,67099,685951,694102,705109,73073,730858,731842,745908,747837,754049,78089,810628,811752,820927,860645,867421,889133,91937,944095,944326,94672,947533,954934,969262,979117,983918]],["@metamask/assets-controller>bignumber.js",[694204,814948]],["@metamask/assets-controller>p-limit",[161844,336741]],["@metamask/assets-controller>p-limit>yocto-queue",[326864,632773]],["@metamask/assets-controllers",[100854,108800,155033,172161,232858,232999,244251,252816,253711,258812,260014,308530,337770,412878,426494,454301,458175,469817,473542,484073,495305,496218,517168,521421,521834,527823,547231,549776,571913,587224,589852,60074,629210,650464,676271,680432,698644,80576,820466,82301,855536,888928,892717,964062,99926]],["@metamask/assets-controllers>@metamask/abi-utils",[179309,216474,231360,252388,375302,412680,446966,50732,507780,52554,548990,578625,616911,656805,686733,734898,797590,864843,957489,961576]],["@metamask/assets-controllers>@metamask/abi-utils>@metamask/utils",[108944,118845,165068,302473,304525,319246,378566,486456,497620,546537,676119,719900,775818,784132,86180,872984,886362,910226,924565,92890,93580]],["@metamask/assets-controllers>@tanstack/query-core",[12645,130191,354881,498322,548216,55012,554868,684863,689467,695549,790727,803487,920616,947051,984886]],["@metamask/assets-controllers>multiformats",[122510,158669,170037,229394,255843,276966,342853,371330,41616,447531,488242,526898,538377,569651,585138,62677,627006,634788,64844,649495,655153,748102,773191,782498,791156,814198,850448,875939,876366,884609,953460,958397,963547]],["@metamask/assets-controllers>single-call-balance-checker-abi",[429643,800904]],["@metamask/authenticated-user-storage",[366552,57858,879768,926726]],["@metamask/base-controller",[100209,100209,293889,293889,412599,417318,418920,418920,552558,552558,57338,865473]],["@metamask/bitcoin-wallet-snap",[130595]],["@metamask/bitcoin-wallet-standard",[243229,337874,467743,500285,63130,747555,776179,789365,880287,884948,921950,985447]],["@metamask/bitcoin-wallet-standard>@exodus/bitcoin-wallet-standard>@exodus/bitcoin-wallet-standard-core>@exodus/bitcoin-wallet-standard-chains",[467062]],["@metamask/bitcoin-wallet-standard>@exodus/bitcoin-wallet-standard>@exodus/bitcoin-wallet-standard-core>@exodus/bitcoin-wallet-standard-features",[157519]],["@metamask/bitcoin-wallet-standard>@wallet-standard/wallet",[491867,856492]],["@metamask/bridge-controller",[105448,126523,175070,182317,182332,182348,213142,221178,229718,23851,264901,26620,269405,27109,272189,30,312551,348579,352925,3742,378098,379436,383442,404283,408776,40912,436243,46780,473128,475583,478363,527704,533606,550293,563197,599076,599345,619489,66216,678424,687368,688326,696078,709096,748512,764482,767977,777204,799716,844901,868900,905110,908029,915542,984251,995062]],["@metamask/bridge-controller>bignumber.js",[775880,990088]],["@metamask/bridge-status-controller",[189369,22937,237508,252033,263498,27727,295078,321146,347031,424634,463649,491496,525987,532032,535919,541531,579279,599038,638329,66186,666017,702602,727367,774449,777454,783985,793837,801166,813974,830802,851018,860999,877021,888790,890128,90570,929314]],["@metamask/bridge-status-controller>bignumber.js",[857617]],["@metamask/browser-passworder",[369166]],["@metamask/chain-agnostic-permission",[145096,275267,296639,381375,421508,486444,519931,577635,662824,77523,791104,791857,825365,825445,849231,85904,874933,883109,909512,940741,969713]],["@metamask/chain-agnostic-permission>@metamask/api-specs",[396998,400265,682004,751601,934683,934683,934683,934683,934683,99790,99790,99790,99790,99790]],["@metamask/claims-controller",[111219,1806,348174,515813,823387,987951]],["@metamask/claims-controller>@metamask/controller-utils",[159032,333632,596979,613652,900113]],["@metamask/client-controller",[169891,489830,599726]],["@metamask/client-utils",[126062,252047,262519,535284,550515,570113,917237]],["@metamask/compliance-controller",[197162,332771,361978,713765,74291,768001]],["@metamask/config-registry-controller",[142306,39482,800726]],["@metamask/connectivity-controller",[440931,663169]],["@metamask/contract-metadata",[243179,243179,243179,243179,243179,496300,551513,988313]],["@metamask/controller-utils",[17605,30018,340871,433152,496705,51664,644174,657638,672307,680721,698402,749254,788142,841043]],["@metamask/controller-utils>@metamask/eth-query",[451550,605895]],["@metamask/controller-utils>@metamask/ethjs-unit",[646039,886634]],["@metamask/controller-utils>@metamask/ethjs-unit>@metamask/number-to-bn",[360646,89987]],["@metamask/controller-utils>@spruceid/siwe-parser",[100373,129409,751528,812346,890577,960636]],["@metamask/controller-utils>@spruceid/siwe-parser>apg-js",[106360,118675,1305,133543,135322,151097,158160,174353,190686,196097,204777,207937,216202,245981,249899,252834,269150,283691,337707,341741,360740,383737,397721,410513,431304,442480,46509,469328,488665,548907,560540,570687,58942,597242,622282,670078,810722,811982,820724,872735,897579,905040,928225,936633,952422,953138,965892,979090]],["@metamask/controller-utils>@spruceid/siwe-parser>valid-url",[858384]],["@metamask/core-backend",[209656,229547,234697,259266,301215,396880,399296,416257,440116,541627,64637,753784,79180,824380,852281,903951,926115]],["@metamask/core-backend>@tanstack/query-core",[120458,183364,191522,194019,2076,214251,221954,229461,232318,23878,277754,287421,400632,477302,480615,483152,490130,500980,523061,576455,691456,697528,717981,722339,759119,768321,790381,809633,835468,887154]],["@metamask/delegation-controller",[221772,30285,405008]],["@metamask/delegation-controller>@metamask/keyring-controller",[127034,507686,700774]],["@metamask/delegation-core",[558620,846404]],["@metamask/delegation-deployments",[59983]],["@metamask/design-system-react",[100791,101545,104095,108379,111700,112038,112120,116791,118991,124856,126134,126528,139911,146950,147602,148696,153108,153472,154468,157783,157994,158250,158317,160370,160687,166537,168743,170533,173556,174795,17635,179218,180219,180781,181657,181902,183745,185194,186304,192794,195120,197951,201718,205278,212504,21263,21292,216346,216793,21875,219384,221371,222496,223901,227485,237405,237457,241686,243877,244569,244701,248477,250778,254465,255145,261181,266965,268870,27150,274207,2762,281051,281244,282311,283931,287002,287721,289055,290070,290605,296263,302175,303362,305955,306392,309111,310583,311698,314356,314756,323966,327468,330793,331498,33539,3372,339262,340390,343043,344809,346414,34997,353187,353438,355670,35721,364588,367792,376193,380917,381150,382707,385780,386745,38914,392800,395528,398412,40106,403015,405165,407554,407699,409644,410701,411275,412524,424341,424502,428504,431037,432914,434186,435684,437840,439295,439550,443273,445973,446947,449341,449565,450435,451902,452304,452668,454831,455836,457302,458646,459182,460390,465560,466770,47233,479746,480116,486359,48845,488581,492670,493611,49421,494800,498658,498677,502676,50627,507803,508323,508533,510243,514816,516438,518206,518491,519559,520430,524405,526447,527442,529775,531462,533632,534408,53669,537119,53784,538324,539783,540463,541292,544020,544944,546947,559099,563376,564250,566707,568085,576040,578429,579952,581745,582814,588106,588156,592479,593902,596940,600838,60209,602435,608887,60938,609415,616203,618485,621719,622832,623197,627871,632419,633400,634850,635860,639263,640713,641816,644493,65093,652230,655301,657580,65874,661447,671492,672992,67493,675319,676513,679085,679968,68323,68593,687513,687949,68940,690034,694394,709071,712964,719082,720483,72180,723576,729079,738935,742351,746005,746150,746812,748507,75451,756741,757654,758832,759310,762644,772737,773742,775075,779749,783088,783173,785016,785427,78990,790558,793216,797460,799163,804968,805600,806198,80649,81120,811571,814520,823445,827933,828116,829471,831404,832190,836726,838175,838490,842111,844326,845022,845417,848365,848558,849803,852336,853169,855034,865740,86660,866927,868118,870677,87288,874176,876365,877291,879575,879638,884056,890954,895370,903273,904306,907319,912629,913802,913807,922726,926968,927951,931231,93278,934509,935664,937069,938132,942959,949098,955662,958152,962428,963245,964414,966455,966872,970443,972938,976849,982635,983857,985268,990900,992164,995163,998246]],["@metamask/design-system-react>@radix-ui/react-slot",[700694]],["@metamask/design-system-react>@radix-ui/react-slot>@radix-ui/react-compose-refs",[128659]],["@metamask/design-system-react>blo",[150609,749193,904710,999084]],["@metamask/design-system-react>tailwind-merge",[704044]],["@metamask/design-system-shared",[206576,220719,305142,506410,520858,556734,568894,584942,683772,706794,73804,75734,789292,79038,831198,833304,848574,918070,918318]],["@metamask/design-tokens",[115312,152301,158967,167203,184382,225344,228187,246336,284253,28509,288228,300784,311204,317309,32803,335287,347861,356770,377043,394478,394689,428132,434518,465020,4796,482988,500944,522686,530159,551572,553616,610707,617795,619893,633612,638513,659249,681561,690548,690691,711582,716674,732791,777440,777855,783158,784672,794401,82737,868103,870912,875644,914025,91504,92071,972017,993766,997238]],["@metamask/eip-5792-middleware",[172936,182912,183501,338412,627228,628102,680796,714249,772029]],["@metamask/eip-5792-middleware>@metamask/transaction-controller",[485271]],["@metamask/eip-7702-internal-rpc-middleware",[119949,38153,391741,733785,738169]],["@metamask/ens-controller",[349167]],["@metamask/ens-resolver-snap",[502420]],["@metamask/eth-hd-keyring",[142629,357268,739583,780268]],["@metamask/eth-hd-keyring>ethereum-cryptography",[683722,731631,780922,965525]],["@metamask/eth-hd-keyring>ethereum-cryptography>@noble/curves",[187339,275501,354273,380907,502616,624994,654265,862503,862530,86744,90063,987385]],["@metamask/eth-hd-keyring>ethereum-cryptography>@noble/hashes",[109213,137818,147274,248241,315771,459303,474660,536508,536710,537242,546308,553230,59257,592843,612378,628989,64055,701194,705962,775836]],["@metamask/eth-hd-keyring>ethereum-cryptography>@scure/bip32",[55007,66889]],["@metamask/eth-hd-keyring>ethereum-cryptography>@scure/bip32>@scure/base",[100912,907904]],["@metamask/eth-json-rpc-filters",[142096,247486,255123,267132,37219,453470,834264,839468,942589]],["@metamask/eth-json-rpc-middleware",[14889,149616,168383,223049,261260,279576,313439,32061,349807,368847,400071,483226,52673,544345,563496,576704,606322,617682,681384,694979,706620,738804,752356,757661,783493,786869,804121,865707,881809,936027,957027,966679]],["@metamask/eth-json-rpc-middleware>safe-stable-stringify",[330764,612980,754903,911668]],["@metamask/eth-json-rpc-provider",[55711,664759,770437,884465]],["@metamask/eth-ledger-bridge-keyring",[146110,462175,474790,64822,676012,712450,77378,864507]],["@metamask/eth-qr-keyring",[177111,270128,659481,807147,815507,995456]],["@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth",[11448,356471,545448,910187]],["@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util",[106166,107015,129631,184430,189255,202020,227759,242063,287160,304681,317236,365684,413456,416838,422522,451854,463212,48505,499760,512514,650359,832445,841455,900165,910697,924906,935909,943228,943909,977461]],["@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>@ethereumjs/rlp",[195412,506783]],["@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography",[221427,613096,748037,837272,857020,943013]],["@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography>@noble/curves",[158115,23489,255008,291818,397454,435491,445730,449273,546894,588947,712218,774223,889447,933636]],["@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography>@noble/hashes",[157753,16342,245326,274209,307067,402728,408688,492641,562204,655119,772775,778756,804949,860498,898914,9102]],["@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@keystonehq/bc-ur-registry",[109968,115358,117966,122720,133557,154783,161856,177355,182666,185897,204916,235376,261574,272857,28597,304809,381418,41249,450301,451297,456406,461683,470297,470600,550736,589837,636165,639779,648167,655398,659325,67503,675722,700095,748835,755426,782172,791890,816816,879846,887673,895608,926141,934292,934796,949592,961101,969685,983013,987073,99602,996720]],["@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>uuid",[241376,242547,260475,301443,331312,350967,506592,509189,512578,544660,592510,596952,630568,64667,655956,663309,68131,695274,695305,713983,724869,743621,751815,76104,833038,837494,840633,859812,946844,959159]],["@metamask/eth-qr-keyring>hdkey",[821827,942518]],["@metamask/eth-qr-keyring>uuid",[261346,329214,331553,363633,414102,420591,579133,611514,646280,67769,852884,995985]],["@metamask/eth-sig-util",[162924,166243,327081,371046,398434,47994,57209,793940,844654,874235,876521,937867]],["@metamask/eth-sig-util>@ethereumjs/rlp",[42850,799901]],["@metamask/eth-sig-util>@ethereumjs/util",[122265,136513,142565,146175,191914,193298,209472,212876,227526,253553,271935,373347,374639,415846,456703,495838,59170,610843,618068,627626,665027,670186,70081,729945,7824,789337,789352,853979,933932,952208]],["@metamask/eth-sig-util>@scure/base",[846906,96959]],["@metamask/eth-sig-util>ethereum-cryptography",[121732,337164,369916,457095,519021,696063]],["@metamask/eth-sig-util>ethereum-cryptography>@noble/curves",[154145,173752,183896,317475,394542,416989,464749,498307,563246,591346,629229,790586,850513,893506]],["@metamask/eth-sig-util>ethereum-cryptography>@noble/hashes",[108610,122679,173646,215020,24004,242736,2819,295849,337099,351520,570641,59242,755859,760501,842382,845139]],["@metamask/eth-snap-keyring",[105527,198032,314873,510840,565052,586380,647262,692443,765389,850982,896009,912558,971019]],["@metamask/eth-snap-keyring>@metamask/keyring-internal-snap-client",[136545]],["@metamask/eth-snap-keyring>@metamask/keyring-snap-sdk",[439103]],["@metamask/eth-snap-keyring>uuid",[241696,246227,495506,655502]],["@metamask/eth-token-tracker",[255353,521476,767110]],["@metamask/eth-token-tracker>@metamask/eth-block-tracker",[46097,607723,614362,624895,696478]],["@metamask/eth-token-tracker>deep-equal",[747174]],["@metamask/eth-token-tracker>deep-equal>es-get-iterator",[89048]],["@metamask/eth-token-tracker>deep-equal>es-get-iterator>is-map",[107274]],["@metamask/eth-token-tracker>deep-equal>is-date-object",[952632]],["@metamask/eth-token-tracker>deep-equal>which-boxed-primitive",[114003]],["@metamask/eth-token-tracker>deep-equal>which-boxed-primitive>is-bigint",[1771]],["@metamask/eth-token-tracker>deep-equal>which-boxed-primitive>is-boolean-object",[841928]],["@metamask/eth-token-tracker>deep-equal>which-boxed-primitive>is-number-object",[523543]],["@metamask/eth-token-tracker>deep-equal>which-collection",[539681]],["@metamask/eth-token-tracker>deep-equal>which-collection>is-weakmap",[46066]],["@metamask/eth-token-tracker>deep-equal>which-collection>is-weakset",[954136]],["@metamask/eth-trezor-keyring",[164172,218202,310843,412665,449478,855756]],["@metamask/eth-trezor-keyring>@trezor/connect-plugin-ethereum",[576404]],["@metamask/etherscan-link",[254605,314846,331176,386325,450656,455308,633713,64025,647573,759868,878622,896383,947264,971443]],["@metamask/gas-fee-controller",[170777,431866,473163,651658,65293,899051]],["@metamask/gator-permissions-controller",[10222,139086,165518,198592,217449,229308,236753,245754,292184,328346,393992,43461,56702,700051,722883,732031,759010,849108,871250,916647,925545,938154,989420]],["@metamask/gator-permissions-controller>@metamask/abi-utils",[161659,203674,281731,331541,41488,467490,5350,661484,664323,677379,681530,685189,719319,733242,798708,843028,905308,95728,964058,97148]],["@metamask/gator-permissions-controller>@metamask/abi-utils>@metamask/utils",[138116,138940,156290,273854,304628,307263,346387,4726,48103,530048,548586,579038,592567,692214,696650,726431,774466,844783,883658,903481,930008]],["@metamask/gator-permissions-controller>@metamask/transaction-controller",[245401]],["@metamask/gator-permissions-snap",[501707]],["@metamask/geolocation-controller",[153615,472806,909614,969456]],["@metamask/geolocation-controller>@metamask/controller-utils",[119285,777824,835663]],["@metamask/hw-wallet-sdk",[137889,37355,593365,649775,687371,784717,832813,853955,925338,937578]],["@metamask/institutional-wallet-snap",[214494]],["@metamask/jazzicon",[256985,762823,983303]],["@metamask/jazzicon>color",[796458]],["@metamask/jazzicon>color>clone",[901347]],["@metamask/jazzicon>color>color-convert",[665773,698052,793961]],["@metamask/jazzicon>color>color-convert>color-name",[670366]],["@metamask/jazzicon>color>color-string",[362611]],["@metamask/jazzicon>mersenne-twister",[760322]],["@metamask/json-rpc-engine",[100670,129385,140667,157637,162982,189857,19352,19352,19352,19352,19352,195970,199481,267035,298292,314307,350026,354466,354466,354466,354466,354466,355864,372429,374078,377530,386586,395037,422356,423047,438025,441246,447055,464671,474292,482742,482742,482742,482742,482742,490562,556620,556620,556620,556620,556620,561744,574527,574527,574527,574527,574527,631823,647553,647553,647553,647553,647553,654105,69388,722193,742547,742547,742547,742547,742547,750449,787307,813216,813216,813216,813216,813216,858594,858594,858594,858594,858594,875877,894454,897312,897312,897312,897312,897312,905416,905416,905416,905416,905416,930504,935888,96214,96214,96214,96214,96214,97002,97002,97002,97002,97002,993793,998561]],["@metamask/json-rpc-engine>klona",[20219,699479,810045,966056]],["@metamask/json-rpc-middleware-stream",[407394,410102,643984,721920]],["@metamask/json-rpc-middleware-stream>readable-stream",[1024,104760,123210,134796,156997,17144,221179,231821,235139,278031,285372,304983,306788,30763,323247,329687,424983,462397,494081,546165,558254,63063,682145,700528,710347,724843,750965,752314,775370,813254,820213,825326,839868,847866,859321,867208,906781,915142,925777,929561,942412,942755,947558,960094,979496]],["@metamask/keyring-api",[131807,141203,150042,161271,161934,197318,201831,223967,242317,250502,265109,28360,286141,306637,330239,334242,334493,341483,348554,368243,373585,382682,39610,44141,462726,467236,477322,492023,54178,551171,582873,592653,595704,612293,663608,670158,674397,694359,711298,718622,732475,740234,751817,813579,826589,826651,853429,861320,867525,871089,883896,886319,896322,905620,906646,91107,928437,938323,957740,970519,979855,983932]],["@metamask/keyring-controller",[280501,401155,511133,869959,945597,988763]],["@metamask/keyring-controller>@metamask/eth-simple-keyring",[207492,232031,688668,716741]],["@metamask/keyring-controller>@metamask/eth-simple-keyring>ethereum-cryptography",[11305,460532,784908,925631]],["@metamask/keyring-controller>@metamask/eth-simple-keyring>ethereum-cryptography>@noble/hashes",[223880,310270,453512,500916,586102,741197,828940,972107]],["@metamask/keyring-controller>ethereumjs-wallet",[145286,436551,512249,562210,610527,705638]],["@metamask/keyring-controller>ethereumjs-wallet>ethereum-cryptography",[143313,151789,215602,238365,267378,283155,361274,398760,51747,564783,585825,61648,638460,645627,65389,723983,748624,748852,749005,847292,90980,988244]],["@metamask/keyring-controller>ethereumjs-wallet>ethereumjs-util",[191517,206354,227271,255583,303999,363828,388918,468754,531412,648512,681551,681987,690345,701971,702249,71210,75560,828122,831933,851954,888663,892253,916531,945458]],["@metamask/keyring-controller>ethereumjs-wallet>utf8",[670655,730782]],["@metamask/keyring-controller>ulid",[246338,31299,599794,988585]],["@metamask/keyring-internal-api",[693992]],["@metamask/keyring-sdk",[192060,210385,314527,440005,485426,680238,688215,693228,892692,932754]],["@metamask/keyring-sdk>ethereum-cryptography",[103525,525043,783724,824745]],["@metamask/keyring-sdk>ethereum-cryptography>@noble/hashes",[10928,231968,411983,785108,821114,911404,926645,980746]],["@metamask/keyring-sdk>uuid",[236250,280255,345719,394608,43681,474820,682642,905303]],["@metamask/keyring-snap-client",[329212,656228]],["@metamask/keyring-snap-client>uuid",[207956,210603,292899,468320,491914,580723,724414,768145]],["@metamask/keyring-utils",[156635,259691,364524,385586,426708,510930,551277,61683,893513,911633]],["@metamask/logging-controller",[237092,791215,89806]],["@metamask/logo",[663411,739929,844113]],["@metamask/logo>gl-mat4",[58879,717641,733652,740435,974021,979173]],["@metamask/logo>gl-vec3",[239384]],["@metamask/message-manager",[192896,278809,7255,75530]],["@metamask/message-manager>@metamask/controller-utils",[142466,449166,580289]],["@metamask/message-manager>jsonschema",[338038,454579,561845,657206,802569]],["@metamask/message-signing-snap",[35272]],["@metamask/messenger",[324960,446337,446337,446337,446337,446337,498768,547368,547368,547368,547368,547368,924679,953320]],["@metamask/metamask-eth-abis",[115022,285981,409227,571397,623031,632915,697040,751270,785012,85218]],["@metamask/mobile-wallet-protocol-core",[454830]],["@metamask/mobile-wallet-protocol-core>centrifuge",[218725]],["@metamask/mobile-wallet-protocol-core>eventemitter3",[280167]],["@metamask/mobile-wallet-protocol-core>uuid",[290130,34227,426629,43138,440826,478364,485512,527229,542488,574456,622389,635654,686616,714334,728021,849380,879677,889265,912587,920183,957975]],["@metamask/mobile-wallet-protocol-dapp-client",[998611]],["@metamask/mobile-wallet-protocol-dapp-client>@metamask/utils",[717919,812258]],["@metamask/mobile-wallet-protocol-dapp-client>uuid",[570794,645413,899037,990133]],["@metamask/multichain-account-service",[136893,201847,265276,294377,340846,374363,392978,400212,433512,45659,571331,58014,583015,632908,723563,756400,98276]],["@metamask/multichain-api-client",[220677,366196,412454,4712,56710,675768,676687,991999]],["@metamask/multichain-api-middleware",[22054,231253,316756,374018,457740,5135,784979,862719,965714]],["@metamask/multichain-api-middleware>@metamask/api-specs",[349544,496663,989430]],["@metamask/multichain-network-controller",[15549,392858,431035,501203,888813,915877,928711,951493]],["@metamask/multichain-transactions-controller",[37610]],["@metamask/name-controller",[12824,140701,414136,530451,614937,643343,709216,812529,834395,869152,943221]],["@metamask/name-controller>@metamask/controller-utils",[812246,812830]],["@metamask/network-controller",[131483,20940,339710,418084,469233,507292,552682,6203,628535,636061,668348,762180,871933,875062,877882,884938,918074,964084]],["@metamask/network-controller>@metamask/eth-block-tracker",[265196,336767,601556,636005]],["@metamask/network-controller>@metamask/eth-json-rpc-infura",[196288,324738,391341,507424,515366,597837,717129,891881,975366,986795]],["@metamask/network-controller>@metamask/eth-json-rpc-infura>@metamask/eth-json-rpc-provider",[139596,139596,139596,139596,139596,163433,163433,163433,163433,163433,215604,357480,357480,357480,357480,357480,394408,666594,666594,666594,666594,666594,973186,996223]],["@metamask/network-controller>@metamask/swappable-obj-proxy",[101126,31640,480251,554207,821954,832336,871023,906117]],["@metamask/network-enablement-controller",[255685,688916,80884,897544]],["@metamask/notification-services-controller",[171101,19676,221890,235298,240004,278056,289962,291105,303728,308033,358963,390923,42162,446112,461940,465447,477703,509960,543884,555313,565553,57797,590754,599565,602551,621095,713351,724427,747449,749512,767678,795086,815360,887942,898238,914806,923231,98742,989029]],["@metamask/notification-services-controller>@contentful/rich-text-html-renderer",[396769,777316]],["@metamask/notification-services-controller>bignumber.js",[584345,807275]],["@metamask/notification-services-controller>firebase",[168633,634193,888506]],["@metamask/notification-services-controller>firebase>@firebase/app",[810127]],["@metamask/notification-services-controller>firebase>@firebase/app>@firebase/component",[8271]],["@metamask/notification-services-controller>firebase>@firebase/app>@firebase/logger",[320916]],["@metamask/notification-services-controller>firebase>@firebase/app>idb",[131816,470206]],["@metamask/notification-services-controller>firebase>@firebase/installations",[839897]],["@metamask/notification-services-controller>firebase>@firebase/messaging",[228728,321964]],["@metamask/notification-services-controller>firebase>@firebase/util",[873774]],["@metamask/object-multiplex",[136940,273538,373445,541726,541726,657887,657887,925275,950169,967744,967744,993027]],["@metamask/object-multiplex>once",[150910,688655,688655,842744]],["@metamask/object-multiplex>once>wrappy",[368616,703854,885067,885067]],["@metamask/object-multiplex>readable-stream",[103508,103508,108694,108694,15394,15394,178079,181531,181531,183588,25387,258565,258565,284911,292787,304208,304208,319353,373654,388658,406385,441713,446267,446267,469856,472387,478633,478633,540031,540031,554907,593545,593545,604196,652767,659909,66066,666688,666688,691259,71293,729063,737465,752333,75284,75284,753921,835990,838926,838926,839488,842809,846686,884578,897252,907776,934344,934344,979662,979662]],["@metamask/obs-store",[22954,311763,335953,530109,533761,942538]],["@metamask/obs-store>readable-stream",[150473,157404,181418,263336,294921,367710,403784,460097,560380,615239,642085,694935,707781,748489,905456]],["@metamask/passkey-controller",[106212,137247,14818,155586,17926,309715,381202,43704,529857,65405,684542,708634,749002,768666,818631,850735,85757]],["@metamask/passkey-controller>@levischuck/tiny-cbor",[21408,423054,53929]],["@metamask/permission-controller",[130798,236375,241361,241361,29947,29947,405463,408613,43161,441099,441099,462105,462105,566505,652871,671288,766840,775377,811443,831851]],["@metamask/permission-log-controller",[230060,940669]],["@metamask/permissions-kernel-snap",[271657]],["@metamask/perps-controller",[110328,134470,14517,166861,167513,16793,174096,19900,245971,251442,254038,271256,276674,277062,288559,296289,329354,339240,36252,373663,382635,409925,428010,435356,479054,483123,526696,538692,541911,548596,565969,577690,585609,594563,598283,661774,671385,68885,741759,778872,782101,798777,801679,810634,81702,823759,840331,841344,868322,889371,921273,925049,951141,974106,978719]],["@metamask/perps-controller>@metamask/abi-utils",[111264,137012,142182,186069,224747,272812,319695,366721,413373,459134,46185,635465,756610,762350,771722,830360,86560,903852,925850,926394]],["@metamask/perps-controller>@metamask/abi-utils>@metamask/utils",[105656,229132,233188,255952,333389,3476,416082,440710,520728,52393,580748,686234,704983,712090,751549,804682,855452,867150,921673,931140,956117]],["@metamask/perps-controller>@nktkas/hyperliquid",[101129,102362,104684,105154,1056,106128,109323,110466,125212,130360,136002,137722,141624,142095,151515,158657,161535,16664,174985,175815,176141,176558,181275,186074,192088,193501,193947,228324,229042,240763,24213,247707,247865,248197,251454,262172,262369,263985,271768,273005,286810,309848,312624,318481,323716,328150,335704,346714,352145,370572,385984,390159,39020,397326,400050,401532,401791,403369,408572,408925,410421,428551,434189,434214,446069,44676,453316,453553,458920,471596,472431,472732,482402,485243,499202,502334,507419,51032,51249,519574,537694,538599,539411,541870,545529,548680,554215,557460,564494,566805,56681,569407,572906,575265,583018,584258,585272,585773,590319,59960,603927,611097,616095,626513,636739,640135,643575,643896,650627,659104,660583,660786,670779,671868,674641,678e3,679722,681458,685001,687514,689875,693525,703312,713408,714659,725316,743415,747068,750953,761286,77414,782773,784414,788089,792950,797101,79747,800804,801399,807265,808356,815951,818121,819249,820795,822137,825194,827996,836630,841724,844070,845762,853337,855596,875500,882665,883962,88719,890432,894839,898119,898536,903423,904880,910301,915832,922491,936813,937899,938731,94985,951280,953264,956003,958904,963422,968666,980065,981863,982691,990103,997946]],["@metamask/perps-controller>@nktkas/hyperliquid>@nktkas/rews",[919092]],["@metamask/perps-controller>@nktkas/hyperliquid>@noble/hashes",[52184,708987,933919]],["@metamask/perps-controller>@nktkas/hyperliquid>valibot",[744050]],["@metamask/phishing-controller",[177094,214642,217903,311290,332106,566314,731502,996024]],["@metamask/phishing-controller>ethereum-cryptography",[930800,95458]],["@metamask/phishing-controller>ethereum-cryptography>@noble/hashes",[101787,301725,699445,965258]],["@metamask/polling-controller",[475754,499945,729986,816571,848418]],["@metamask/post-message-stream",[101274,101274,107927,107927,23400,303501,359799,379148,411515,462271,465868,524382,524382,543433,543474,562582,620498,620498,74883,74883,755593,755593,797866,822105,841953,848351,927785,927785]],["@metamask/post-message-stream>readable-stream",[103082,122587,122587,128093,128093,149890,149890,158647,158647,163119,164196,209528,216795,280932,311931,335992,365149,377228,377228,387923,387923,430723,430723,437116,450432,450862,453036,456224,456224,490137,490137,506348,506348,507330,508142,508142,525366,538997,589202,621123,67395,67395,68193,702682,742819,783385,815245,846471,852894,859028,85990,864992,864992,866345,883886,929012,938361,938361,976199,976199]],["@metamask/ppom-validator",[118001,501054,683914,782496]],["@metamask/ppom-validator>@metamask/controller-utils",[147732,280485,702696,708121,722299,95496,967024]],["@metamask/ppom-validator>await-semaphore",[905433]],["@metamask/ppom-validator>crypto-js",[100757,172160,205706,208141,225127,261390,292580,336868,350067,357329,361567,392374,45750,496292,498934,512397,521035,587891,599379,602347,608774,610647,614664,647486,67012,72983,734486,741309,767002,771511,796566,826321,829757,836858,862264,902959,929783,937614,940658]],["@metamask/ppom-validator>json-rpc-random-id",[275336,84187]],["@metamask/profile-metrics-controller",[63076,652640,750877,958495]],["@metamask/profile-sync-controller",[101626,140801,143885,223444,250599,315423,334639,343840,356018,367006,390492,408685,414088,425294,433884,443694,463044,516881,525876,551213,557867,588929,689445,731171,748275,756124,821937,861297,889078,903355,912979,914097,958387,96110]],["@metamask/profile-sync-controller>siwe",[144260,355248,849330,90097,976854]],["@metamask/profile-sync-controller>siwe>@spruceid/siwe-parser",[120724,133970,298093]],["@metamask/profile-sync-controller>siwe>@stablelib/random",[215190,394748,421695,441045]],["@metamask/profile-sync-controller>siwe>@stablelib/random>@stablelib/binary",[65381]],["@metamask/profile-sync-controller>siwe>@stablelib/random>@stablelib/binary>@stablelib/int",[511457]],["@metamask/profile-sync-controller>siwe>@stablelib/random>@stablelib/wipe",[762029]],["@metamask/providers",[116263,152704,178618,482392,604632,611766,683527,725087,733762,748698,78279,798563,944401,946170,946822,958440]],["@metamask/providers>is-stream",[84773,902544]],["@metamask/providers>readable-stream",[125282,131581,167911,206930,217247,272419,275885,31329,31356,352992,360996,366175,373035,406951,433634,478694,577916,609843,616714,655772,660418,670086,719599,769499,777480,789321,817741,834278,871965,919766]],["@metamask/ramps-controller",[111810,311997,384540,384540,384540,384540,384540,403323,605437,606999,62498,65476,80081,810043]],["@metamask/rate-limit-controller",[200214]],["@metamask/react-data-query",[574018]],["@metamask/react-data-query>@metamask/base-data-service",[682088]],["@metamask/remote-feature-flag-controller",[197048,212198,221126,432815,86666,949287]],["@metamask/rpc-errors",[132002,132002,132002,135299,135299,135299,135299,135299,13592,144008,144008,16905,16905,195057,195057,195057,195057,195057,207534,207534,207534,207534,207534,250101,347336,353959,353959,353959,581327,581327,584553,584553,584553,652016,682977,703640,703640,703640,703640,703640,711210,711210,711210,714679,805248,805248,85568,875088,875088,875088,875088,875088,980191,98790]],["@metamask/rpc-errors>fast-safe-stringify",[101292,101292,101292,408738,754255,754255]],["@metamask/safe-event-emitter",[177805,532596,56099,664053,73483]],["@metamask/scure-bip39",[231971,39617,592190,595876]],["@metamask/scure-bip39>@noble/hashes",[202475,239227,401576,484186,494981,512504,560972,56654,614013,693606,754216,782486,835673,851767,879240,88469,938735,980895]],["@metamask/scure-bip39>@scure/base",[763261,816018]],["@metamask/seedless-onboarding-controller",[113935,245922,338126,432920,563204,673260,882450,987160]],["@metamask/seedless-onboarding-controller>@metamask/auth-network-utils",[822318]],["@metamask/seedless-onboarding-controller>@metamask/auth-network-utils>@toruslabs/constants",[225690]],["@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup",[151556,173516,238842,240737,342496,36100,422680,492933,62051,665947,79948,853205,90171]],["@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@metamask/auth-network-utils",[260238,315073,340862,356228,398517,943898,961703,989259]],["@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@toruslabs/fetch-node-details",[176448]],["@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@toruslabs/fetch-node-details>@toruslabs/fnd-base",[244824,451189,489988,762643]],["@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@toruslabs/fetch-node-details>@toruslabs/http-helpers",[807050]],["@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@toruslabs/http-helpers",[558486]],["@metamask/selected-network-controller",[303284,757948]],["@metamask/shield-controller",[365523,417305,876690,976635,987510]],["@metamask/shield-controller>@metamask/transaction-controller",[136552]],["@metamask/signature-controller",[415436,443380,443651,693808,77736,786887,827326,851561]],["@metamask/smart-transactions-controller",[186578,198038,265403,407608,518171,529367,541149,612157,631561,665368,730591,813112,847512]],["@metamask/smart-transactions-controller>@metamask/transaction-controller",[287996]],["@metamask/smart-transactions-controller>bignumber.js",[35040]],["@metamask/snap-account-service",[132324,705043,977542,990306]],["@metamask/snap-simple-keyring-site>react-is",[714527,753371]],["@metamask/snaps-controllers",[100936,13830,159436,186638,197230,278113,296346,2982,302870,365768,37124,479132,585625,592949,624144,640075,65383,685406,737060,758116,792020,800597,821908,881518,886365,958933]],["@metamask/snaps-controllers>@xstate/fsm",[464037]],["@metamask/snaps-controllers>concat-stream",[207552]],["@metamask/snaps-controllers>get-npm-tarball-url",[544627]],["@metamask/snaps-controllers>readable-stream",[151318,151999,163614,18591,352457,371462,379528,387180,473427,631936,644546,668934,908588,911856,95525]],["@metamask/snaps-controllers>readable-web-to-node-stream",[931149]],["@metamask/snaps-controllers>readable-web-to-node-stream>readable-stream",[168302,261736,324144,333048,416003,48390,490661,672710,777866,802799,849252,867751,900609,924693,940258]],["@metamask/snaps-controllers>tar-stream",[462371,597634,612528,75071,861173]],["@metamask/snaps-controllers>tar-stream>b4a",[22010,364148,527062,703600,827088,838641]],["@metamask/snaps-controllers>tar-stream>fast-fifo",[252827,988679]],["@metamask/snaps-controllers>tar-stream>streamx",[26806]],["@metamask/snaps-controllers>tar-stream>streamx>queue-tick",[479050]],["@metamask/snaps-execution-environments",[449787,449787,897911]],["@metamask/snaps-registry",[529597,690212]],["@metamask/snaps-rpc-methods",[144945,146546,147860,153901,172643,185355,19138,193993,197682,202511,210734,22086,228644,245798,257657,269716,274423,282522,283044,304925,314585,315290,322997,350994,36294,373268,374054,379968,385026,406625,425998,434878,434878,448292,449485,46547,466022,474822,47964,506763,514127,522251,545190,545679,56730,574772,576712,587268,601247,617736,662344,67770,680320,689132,689132,710032,746875,747359,756782,760650,765442,795174,819766,829418,830111,831028,834786,840672,875706,899342,899345,926697,941560,942800,944476,951597,969885,991882]],["@metamask/snaps-sdk",[102018,11115,115412,128323,129852,157392,157392,159167,159167,171089,174638,174638,175025,186119,186119,188320,188320,208554,208554,215254,229765,254995,254995,264295,286028,28748,292076,300005,300005,306436,307856,308348,32014,32014,323626,328448,329338,33029,33029,335562,335562,382906,382906,392154,409982,414221,414221,426668,434322,434322,443697,443697,45217,45217,453945,453945,461893,461893,473552,473903,484068,484068,499490,499490,503236,509450,511543,515828,515828,533010,544299,544299,554649,554888,5654,5654,578214,586794,589411,597361,597361,599601,609948,609948,614130,614130,624938,631305,63236,633089,633089,647388,647388,676358,676358,678485,689686,689686,694729,694729,706524,706524,707278,708790,721117,721117,722837,722837,728195,728195,763799,7688,772646,773466,781147,78121,78121,797999,797999,80332,80332,814006,814006,814779,818365,818365,833399,833399,833414,833414,841767,861913,861913,865260,869864,869864,879516,879516,879771,879771,904538,936435,936435,937053,937053,947709,951198,955187,955187,962940,965587,971188,971188,976558,98414,984524,984524,988068,988068,989634]],["@metamask/snaps-sdk>@metamask/key-tree",[100468,138991,141769,202060,202535,224378,245476,256046,268988,365834,365983,379669,410574,42491,476536,480601,480665,508238,53921,568607,568870,585793,617862,64263,643988,650475,691816,693932,697917,699078,732112,754560,884797,899105,914309,916003,920131,94947,949840,953152,963624,999736]],["@metamask/snaps-utils",[116243,122017,138526,143996,148812,156828,203116,219701,237825,244499,252164,259024,296252,30260,325631,327256,342548,355897,358e3,366816,392380,399768,431050,440561,444743,464686,470298,501578,504536,524342,541503,54872,549849,569476,58520,593452,619193,62099,622104,627819,630249,631524,650273,650976,676798,685502,705935,725942,744381,761368,761585,809308,81679,828364,833302,849444,877759,895112,90157,90404,914420,941248,968074,973637,988931,988950,99290]],["@metamask/snaps-utils>@metamask/slip44",[62816,847408,847408,847408,847408,847408]],["@metamask/snaps-utils>fast-xml-parser",[111761,290529,379535,522951,608178,64236,690389,859399,953156]],["@metamask/snaps-utils>fast-xml-parser>@nodable/entities",[493755,743107]],["@metamask/snaps-utils>fast-xml-parser>path-expression-matcher",[263528,371328,766382]],["@metamask/snaps-utils>fast-xml-parser>strnum",[191736]],["@metamask/snaps-utils>marked",[44747,746041]],["@metamask/snaps-utils>rfdc",[397348,945441]],["@metamask/snaps-utils>validate-npm-package-name",[170762,226237]],["@metamask/snaps-utils>validate-npm-package-name>builtins",[264034,81481]],["@metamask/solana-wallet-snap",[990997]],["@metamask/solana-wallet-standard",[158133,29645,309289,819292,876553]],["@metamask/solana-wallet-standard>@solana/wallet-standard-features",[45444,527170,598497,943760]],["@metamask/solana-wallet-standard>@wallet-standard/features",[694718,716207,986059]],["@metamask/solana-wallet-standard>@wallet-standard/wallet",[295412,302163]],["@metamask/storage-service",[493201,694546,878445]],["@metamask/subscription-controller",[112583,135109,173923,623763,663425,683630,940965,975034]],["@metamask/subscription-controller>@metamask/transaction-controller",[85120]],["@metamask/subscription-controller>bignumber.js",[816207]],["@metamask/superstruct",[126717,133777,142827,142827,147698,147698,147698,147698,147698,147698,147698,160064,179379,179379,179379,179379,179379,179379,179379,244231,244231,290266,290266,290266,296422,315560,315560,315560,315560,315560,315560,315560,342672,342672,355608,355608,356583,356583,362066,411554,411554,411554,437527,448967,448967,448967,449070,449070,497177,497177,497177,497177,497177,497177,497177,5136,5136,5136,5136,5136,5136,5136,514728,545203,545203,545203,585186,599805,599805,599805,599805,599805,599805,599805,612815,612815,612815,628674,628674,628674,628674,628674,628674,628674,63015,638737,638737,638737,638737,638737,638737,638737,642240,652825,652825,652825,710429,784225,784225,829528,844377,886639,982944,982944,982944,991163]],["@metamask/test-dapp-solana>@solana/wallet-standard-chains",[826167]],["@metamask/transaction-controller",[120470,129438,133660,145895,15420,158388,174838,176414,182929,200881,20190,204471,20486,212808,242238,24889,260385,266860,271351,284154,289702,29575,317525,326310,348372,354166,419204,420762,423085,427709,434906,439116,454515,491993,493646,496737,499236,517718,523615,53002,536474,546292,579150,581759,592361,59370,607402,619783,622702,623476,628371,629577,633919,637434,660158,660227,660502,67269,674324,685128,707258,71530,720509,730691,731521,74065,755199,777394,777863,780690,788457,793583,795886,80667,850156,857157,858128,864266,882950,8862,900682,905804,907315,910368,922469,929373,957391,963648,967792,976022,978561,980003]],["@metamask/transaction-controller>@metamask/nonce-tracker",[203385,71290,775896,877795]],["@metamask/transaction-controller>@metamask/nonce-tracker>async-mutex",[154427,214637,295819,420968,626394,751816,77684,793012,857279,901613,955353,997852]],["@metamask/transaction-controller>bignumber.js",[580891,717341]],["@metamask/transaction-pay-controller",[115365,116929,11976,129447,145827,153815,212087,223766,229622,233199,268144,287700,303928,307788,309473,318122,33631,348694,373107,373428,388762,390381,420713,426741,478127,481511,48892,506105,524122,534377,545939,549584,572919,600608,60342,617590,628650,632976,645727,646127,683663,686869,693890,694114,699880,733786,746992,75827,762096,772381,789324,831767,846006,860948,888191,904359,908828,916775,92167,932099,941902,98610]],["@metamask/transaction-pay-controller>@metamask/ramps-controller",[397088,567550]],["@metamask/transaction-pay-controller>bignumber.js",[951082]],["@metamask/tron-wallet-snap",[500994]],["@metamask/user-operation-controller",[137553,143344,201013,308951,341048,427635,433151,509105,581410,923672,949040,992425]],["@metamask/user-operation-controller>@metamask/transaction-controller",[803490]],["@metamask/utils",[103453,103453,103453,103453,103453,103453,103453,106234,110727,114045,115835,133788,142282,142282,166378,166378,166378,166378,166378,166378,166378,204179,204179,204179,204179,204179,204179,204179,211600,220790,224340,230855,230855,230855,230855,230855,230855,230855,258862,258862,267889,269530,269530,269530,269530,269530,269530,269530,289049,297564,297564,301885,301885,301885,301885,301885,301885,301885,311007,324995,333644,334031,334031,334031,334031,334031,334031,334031,364705,364705,364705,364705,364705,364705,364705,379054,379054,379054,379054,379054,379054,379054,38333,38333,38333,38333,38333,38333,38333,387434,405234,415797,418021,418021,418021,418021,418021,418021,418021,424819,432315,432315,432315,432315,432315,432315,432315,447519,447519,447519,462267,481009,481009,481009,481009,481009,481009,481009,481533,487212,502257,502257,502257,502257,502257,502257,502257,507060,507060,507060,507060,507060,507060,507060,534901,536560,536560,536560,536560,536560,536560,536560,540087,544904,549140,554839,554839,554839,570302,570302,570302,570302,570302,570302,570302,572433,572433,572433,572433,572433,572433,572433,615195,629368,679194,685673,691991,691991,691991,691991,691991,691991,691991,695591,699844,699844,699844,699844,699844,699844,699844,705025,705025,707479,745085,745085,745928,750331,755244,755244,755244,755244,755244,755244,755244,760184,760184,761788,812805,812805,812805,812902,818337,818337,819575,823680,83174,832018,851754,855482,870601,870601,870601,870601,870601,870601,870601,882125,889333,889333,889333,889333,889333,889333,889333,893088,896639,896639,908743,908743,924709,933647,933647,933647,933647,933647,933647,933647,934538,935406,943152,970980,971968,973594,973594,991386]],["@metamask/utils>pony-cause",[175660,178430,207912,341875,353747,529131,546899,67282,762565,878070]],["@metamask/wallet",[102052,170712,379628,420950,49452,557740,647928,656171,677024,69454,795690,924272,927676]],["@metamask/wallet>@metamask/connectivity-controller",[540286,709902]],["@mui/material",[104312,11577,11847,127519,131770,133546,133610,134295,138369,149615,153167,156273,157655,162330,165360,166451,167754,167889,178627,181078,181235,189302,191831,203048,210303,226316,236307,255651,259731,26139,2653,282411,301846,307879,310781,313877,324435,332447,332703,336669,341331,35299,35395,365663,368447,370166,378470,379241,38422,398360,412251,413825,416935,425277,431563,436002,440400,450283,452141,454296,465673,471225,473091,479487,501597,514651,519621,531344,538827,548057,551018,55753,569241,57703,578155,57903,590551,591867,597805,599115,6059,609711,61123,614039,624277,62485,632116,640422,641503,648848,654282,656872,661831,663415,66571,671692,676437,678803,682879,685075,689227,700221,714326,715498,767335,768420,812063,818175,819181,822498,834867,836235,852735,860482,867615,879514,886401,895557,901045,90255,909476,91357,917195,920763,925855,928405,933304,94413,945520,945831,955653,963413,965979,97417,989167,989507,991447,999946]],["@mui/system",[112307,157747,170487,223596,260499,292499,337791,382928,508125,51009,518028,521462,559495,571389,573633,613431,627531,740860,75139,752367,759456,767479,768766,773517,800001,801105,828135,87567,884047,901626,927296,961052,967443,97900]],["@mui/system>@mui/private-theming",[57094,573456,603025,82634]],["@mui/system>@mui/styled-engine",[184884,472395,669950]],["@mui/system>@mui/utils",[103354,184229,1975,20613,214359,230793,246517,282805,291577,305397,319,331467,331569,394779,418965,439189,448157,486545,487849,498525,503031,510163,540913,554911,557889,599139,632271,650543,711433,727645,768304,781887,79181,843102,850845,856709,875719,902965,958525,991061,996063]],["@mui/system>@mui/utils>react-is",[254918]],["@mui/x-date-pickers",[10168,10283,109947,111395,122804,123803,126836,129352,135,137138,143620,14500,193795,207533,217914,232699,236e3,240425,252109,253626,256113,276833,28014,282147,286591,291798,296702,297337,299813,306965,312931,31307,31610,324552,346464,347478,360213,367588,371017,373436,407675,409265,427557,428868,43945,439705,449361,450172,456280,462684,465385,471109,472329,475479,481776,493444,495730,509819,516586,531919,534334,535112,549645,559442,560807,57035,575472,575759,576361,591276,613923,621225,62313,636789,637605,644658,645967,664886,684598,696035,696877,722351,731545,735574,743304,748043,76734,777039,79095,794182,794335,797343,802198,802583,804689,807381,81821,836036,837819,842867,844151,847094,860107,861581,864041,868232,872762,881645,883161,888956,903160,904440,909821,916237,918664,922167,922940,923449,92574,931514,939733,946300,948710,983447,984247,995814]],["@mui/x-date-pickers>@mui/utils",[119651,197021,248723,261091,302419,340611,352023,365965,48343,529819,586991,63207,646853,676243,677617,73013,77457,789905,803499,86397]],["@ngraveio/bc-ur",[10198,127443,216814,334683,347103,407755,42514,440515,441576,470363,526436,585651,605041,608778,615564,669916,677855,715987,757072,777518,816060,912490,916561,94803]],["@ngraveio/bc-ur>@keystonehq/alias-sampling",[815543,836484]],["@ngraveio/bc-ur>assert",[100734,110254,158196,215851,276499,392615,528896,784333]],["@ngraveio/bc-ur>assert>is-nan",[157383,223141,247643,277973,461010,603758,882710,924544]],["@ngraveio/bc-ur>assert>object-is",[129730,16056,331205,345247,370244,628587,827856,919581]],["@ngraveio/bc-ur>bignumber.js",[107456,574149]],["@ngraveio/bc-ur>cbor-sync",[632362,863475]],["@ngraveio/bc-ur>crc",[117977,136322,164719,173976,217684,219649,232409,274359,355276,389601,457640,520173,524523,538289,633555,640716,683775,739574,761450,76520,825036,852556,858449,871860,878551,888882,946884,94905]],["@ngraveio/bc-ur>crc>buffer",[690678,797843]],["@ngraveio/bc-ur>jsbi",[233128,847743]],["@ngraveio/bc-ur>sha.js",[112801,132806,158146,211859,240184,266803,36036,363368,381195,576585,588986,627106,740154,774747,893961,948953]],["@ngraveio/bc-ur>sha.js>to-buffer",[407116,715425]],["@noble/ciphers",[101476,111073,179606,330590,50599,55527,562386,697680,780376,85518,872133,910068,958071]],["@noble/curves",[140552,145779,177937,17902,195015,215644,240960,275316,322394,357764,36773,413796,419797,425930,446266,470978,489928,539817,578933,58340,589072,600124,610537,610911,625658,792499,824778,905407,927500,956501]],["@noble/hashes",[117154,128961,158357,163684,216243,237402,251754,279307,282974,318449,344524,344863,362108,367013,38578,399502,41903,462900,469688,477964,477964,478639,496064,496153,505886,551278,553668,661330,661330,671955,671955,672780,716070,716070,730375,737542,769570,770999,772169,777636,810410,82357,844842,850479,85428,857074,943940,943940,975651,975651,984530,993173]],["@open-rpc/meta-schema",[513412]],["@open-rpc/schema-utils-js",[410241,517545,859138]],["@open-rpc/schema-utils-js>@json-schema-tools/dereferencer",[313518,627554]],["@open-rpc/schema-utils-js>@json-schema-tools/dereferencer>@json-schema-tools/traverse",[282562]],["@open-rpc/schema-utils-js>@json-schema-tools/meta-schema",[98602]],["@open-rpc/schema-utils-js>@json-schema-tools/reference-resolver",[350138,399262,476835,695517,733650]],["@open-rpc/schema-utils-js>@json-schema-tools/reference-resolver>@json-schema-spec/json-pointer",[648777]],["@open-rpc/schema-utils-js>is-url",[831330]],["@open-rpc/test-coverage>isomorphic-fetch",[971115]],["@open-rpc/test-coverage>isomorphic-fetch>whatwg-fetch",[337329]],["@popperjs/core",[104262,120185,131500,134115,149922,172285,183817,201918,206556,218858,226744,25019,262272,289140,302530,326635,330629,335526,33565,351475,3598,400267,492560,50696,513223,532874,553918,568598,589833,638543,659638,674110,680243,70361,750319,757155,762019,773577,790791,794063,814127,815258,818832,826916,843022,864542,872787,886298,891016,908905,925448,947862,954239,978752]],["@reduxjs/toolkit",[55820,661515]],["@reduxjs/toolkit>reselect",[12420,317341,648099,93958]],["@rive-app/react-canvas",[913965]],["@rive-app/react-canvas>@rive-app/canvas",[236494,236494,236494,236494,236494,888132]],["@scure/base",[54584,591315,599542,75640]],["@segment/analytics-node",[114292,135879,163263,173925,182386,232806,23300,24050,279322,300126,32883,335978,340597,34948,374517,415566,420552,422712,423275,436490,444519,449889,499454,513601,521632,537071,599541,617928,653229,668435,677885,679751,703484,744764,778153,784915,808671,810290,86389,881020,885160,950625]],["@segment/analytics-node>@lukeed/uuid",[43220,650476]],["@segment/analytics-node>@segment/analytics-core",[102925,122822,12916,160021,171519,184523,201210,207015,215256,2368,243329,265654,274166,299891,395707,416644,463599,482259,534481,549325,58131,599055,681279,706813,70932,781258,799074,839404,858693,863234,901844,946716,956877,978616,987212,996346]],["@segment/analytics-node>@segment/analytics-core>dset",[433864,680712]],["@segment/analytics-node>@segment/analytics-generic-utils",[432482,693142,927339,958351]],["@segment/analytics-node>jose",[100648,115208,116941,141454,171121,222891,235544,260779,290961,355329,378729,3865,400639,428514,435641,461740,463860,466038,49106,499518,527336,531349,53295,539790,556697,562807,577658,589323,59992,615640,615679,663478,67737,678296,69186,714316,732642,755924,758792,784203,796358,8143,843557,850867,851454,896511,936995,937930,942639,953385,968646,989618]],["@sentry/browser",[106438,106438,130760,130760,14635,155001,162183,185635,195829,216295,216295,224245,224245,244880,266615,266615,273521,273521,279802,327566,327566,360023,360023,366523,369735,369735,382128,392788,392788,43417,443227,443227,455142,466024,472847,47810,47810,494688,494688,503510,503510,535279,537252,537252,538564,550041,550041,553205,553205,564350,571893,591386,591386,606189,639781,642735,642735,659129,659129,707995,707995,717309,717309,723808,747402,747402,748028,753036,763935,795966,810087,845226,845226,851781,851781,868888,868888,892145,902419,902419,943544,943544,96434,982238]],["@sentry/browser>@sentry-internal/browser-utils",[104168,104168,117529,117529,12796,12796,132076,132076,133481,133481,138716,184748,184748,185335,185335,185746,185746,19467,225669,225669,234512,234598,234598,259463,259463,303818,303818,314408,327140,327140,33040,406097,406097,417860,417860,441265,459517,459517,495242,495242,51450,515400,533858,533858,566632,56680,57324,621827,662925,676979,681747,681747,702053,71337,714599,714599,74342,756025,756025,764651,764651,765698,768571,772879,814601,821396,858586,858586,863531,863531,879954,882555,882555,898026,898026,903217,932294,932294,956354,956742,956742,975431,978802,993671]],["@sentry/browser>@sentry-internal/feedback",[178066,666012,666012]],["@sentry/browser>@sentry-internal/replay",[117172,117172,949306]],["@sentry/browser>@sentry-internal/replay-canvas",[928535,928535,986415]],["@sentry/browser>@sentry/core",[105388,105388,115433,115433,122411,123532,125617,125617,136244,136244,137891,137891,138706,138706,140722,140722,145834,145834,153839,153839,155682,155682,15797,16278,16278,16686,16686,17072,172900,173177,173177,175384,178061,179184,179184,187474,187763,187763,187973,189193,191895,191895,192279,192279,198066,198066,201740,24708,24708,254759,254759,267276,267276,276277,276277,276435,285803,290264,290264,295088,298556,329537,341035,352158,355989,367877,367877,369793,398471,39859,405971,405971,410710,411335,420376,438774,438774,441227,441227,444284,461582,466737,468417,48718,48718,488560,513234,5152,52018,532725,532725,534098,534098,538979,542764,548697,550866,577102,584222,584222,587044,587044,597014,597014,59824,598723,608119,608119,612717,631905,631905,664746,665016,671480,67904,67904,682631,691963,691963,704776,707212,709356,713966,71409,71409,718800,718800,719149,719149,719509,719509,724666,724666,730074,730074,76838,76838,768881,768881,77614,77614,777217,777217,778313,778552,78463,793111,793111,803537,803537,808106,808106,812863,812863,818747,818747,827284,836164,836164,837971,837971,848294,865961,884405,884405,884488,884488,901814,901814,902309,903226,903226,911216,920938,92376,92376,931263,933190,933190,934379,939543,943924,960196,960196,960767,96331,96331,967173,973149,973149,973234,973234,98154,986746,986746]],["@sentry/utils",[107842,107842,1090,109910,148366,151201,16786,16786,179329,179329,182881,230337,230337,25605,25605,283049,316310,370861,37853,37853,384255,384255,38561,388006,388006,397718,397718,401967,40209,40209,402228,414753,424264,424264,425535,425535,450579,450579,462128,471265,471265,490521,494945,494945,497577,513064,520348,536275,538600,538600,562298,562298,566612,571825,571825,572858,572858,586312,586312,605257,613608,620209,620209,6246,644094,644094,646493,648017,648017,650773,654761,654761,665812,669891,680985,680985,696294,696294,708521,709502,716547,74263,766221,766221,769233,785755,799130,799130,814508,821016,821016,830339,830339,833097,834028,834028,834529,834529,837075,837075,84607,851338,851338,85182,85182,856928,879561,895315,895315,906769,906769,921368,940344,940344,950825,973544,97407,97407,988217,988217]],["@simplewebauthn/browser",[134797,148928,173983,208413,216354,249474,311050,322193,328784,345592,36549,417239,454807,506130,50783,537185,582584,600306,630213,759813,80287,891367,931567,955988,970407]],["@solana/addresses",[164047,500089]],["@solana/addresses>@solana/codecs-core",[531837,723771]],["@solana/addresses>@solana/codecs-strings",[654344,726472]],["@solana/addresses>@solana/errors",[410059,780217]],["@storybook/addon-docs>remark-external-links>mdast-util-definitions",[603936]],["@storybook/react>util-deprecate",[381763,381763,418748,79894]],["@tanstack/react-query",[224732,237278,493565,511705,559260,599973,630844,842109,866471,940025,967358]],["@tanstack/react-query>@tanstack/query-core",[100980,11219,140390,147322,223445,248801,286636,330821,352140,377322,522737,530095,534924,536570,586235,586542,612194,645876,656599,665,731286,753269,78174,837058,856269,858515,877295,8980,905319,92190,923689,988867]],["@tanstack/react-query>use-sync-external-store",[11853,837954,897866,941760]],["@tanstack/react-virtual",[207896]],["@tanstack/react-virtual>@tanstack/virtual-core",[282889,737520]],["@toruslabs/eccrypto",[613749]],["@toruslabs/eccrypto>elliptic",[13856,16264,174705,206133,311850,31289,33103,385483,431844,439410,504136,505841,506849,520526,56160,57363,595344,598866,627030,62710,671066,754561,756924,831370,834229,847297,915125,917768,917768,917768,917768,917768,917768,917768,938376,975115,97907,995991]],["@toruslabs/eccrypto>elliptic>brorand",[29360,700493]],["@toruslabs/eccrypto>elliptic>hmac-drbg",[178403,467286]],["@toruslabs/eccrypto>elliptic>minimalistic-assert",[147749,579424]],["@toruslabs/eccrypto>elliptic>minimalistic-crypto-utils",[178175,288762]],["@trezor/connect-web",[149934,161947,209064,264637,302088,353076,416962,448771,475227,511005,549365,577703,676994,777401,778803,802974,819815,833940,883249,925614,932425,942600,948414,949662]],["@trezor/connect-web>@trezor/connect",[102356,104752,108752,110145,113801,11766,122517,12260,151165,15811,195279,203181,266718,274388,283080,291598,300706,310250,312737,314251,324564,329191,3467,347648,381398,38310,390491,39245,399160,40275,40574,416188,419495,43960,450719,458572,459154,499050,507351,515009,531360,565501,567771,574206,612950,63117,631525,636408,640660,644936,646784,653595,659703,686693,69171,699158,699779,700328,715952,723595,728359,740975,763543,765486,767847,773642,792108,794554,799799,823473,832029,841885,842718,843037,845438,847e3,85307,854377,860263,869276,876101,878923,879212,880529,896867,900998,912960,92633,941442,945725,947269,95052,960805,965279,989202,996616]],["@trezor/connect-web>@trezor/connect-common",[1424,32142,323221,439606,457455,494623,556102,867503]],["@trezor/connect-web>@trezor/connect-common>@trezor/env-utils",[156541,254129,410764,53958,759514,903021]],["@trezor/connect-web>@trezor/connect-common>@trezor/env-utils>ua-parser-js",[266523,959498]],["@trezor/connect-web>@trezor/connect>@trezor/blockchain-link>@trezor/websocket-client",[34818,47679,487483,664255,735898,98162]],["@trezor/connect-web>@trezor/connect>@trezor/device-utils",[141965,292761,358991,389452,406597,472650,526170,586775,626392,824082,856220,860193,886318,913937]],["@trezor/connect-web>@trezor/connect>@trezor/protobuf",[108069,131253,192040,244192,289533,311145,326711,352879,534276,669094,783184,806218,969356,974893]],["@trezor/connect-web>@trezor/connect>@trezor/protobuf>long",[154388,229996]],["@trezor/connect-web>@trezor/connect>@trezor/schema-utils",[122668,189121,212317,261702,318930,342180,36195,463685,479101,508198,585053,659995,736876,754128,948506,979693]],["@trezor/connect-web>@trezor/connect>@trezor/schema-utils>@sinclair/typebox",[10071,100733,103796,107091,110922,115647,117177,118003,118011,119200,12572,133648,137135,141248,141584,141594,146496,147967,149264,149457,150650,156134,159565,164639,16791,168041,169535,169820,170758,171039,172991,174218,177386,178860,18600,188342,192669,194706,196624,200299,201099,206718,208399,213208,214286,216042,216167,216342,219050,221172,229784,229971,231358,234780,237875,238197,239055,239058,239258,239520,242637,24284,245249,246721,253578,255176,257519,257695,25789,260556,261111,265631,268431,268908,271739,274396,27684,286312,286836,294615,300644,301031,303504,304363,305481,307704,309754,31199,317312,318295,31989,32976,329881,331519,331682,335570,336021,339102,33953,341314,343978,345058,345602,345945,34641,346487,349811,351009,355743,359094,363143,363296,364835,367026,367636,369119,369736,370059,371543,373225,379348,380175,381147,382219,383298,387371,390099,390622,393392,394828,397474,397532,40186,405919,406295,407224,407776,407881,408619,409603,409783,410500,412896,413523,415519,415827,417672,418942,419688,419792,421427,425782,428561,430096,430971,432312,433803,436271,438240,44071,442473,445592,446330,447676,448635,449839,449922,451164,454835,455429,464960,465701,469696,471615,472977,473496,481167,48182,482649,48745,488767,489560,491881,49269,49638,503150,503156,50320,504217,50501,505749,50615,50686,508463,50892,51069,510979,51314,51590,516104,5168,523517,525219,526787,52776,528627,538011,538649,54028,547533,549475,557183,559146,559614,560885,561224,561555,562097,562257,565490,568209,572055,573886,575085,575449,57744,583492,586736,588569,596773,605452,606394,607170,607971,608002,608015,610442,612376,613762,621097,6215,630094,630448,63092,630960,632188,634166,635421,637094,638924,64079,641768,645032,652547,652606,655535,657502,664900,665066,665447,668354,668464,670079,671534,672327,673763,673921,67488,680644,681765,683687,683876,684089,685526,687123,687162,688581,689850,691341,698063,708137,709621,712099,717272,717686,718600,719546,720281,725168,729280,729801,731968,732863,747175,747896,750164,751934,753591,755722,757749,758657,759810,760170,760233,761770,767104,767337,769314,772102,777620,778184,778693,780967,781247,788247,788763,790596,791780,792063,795935,796256,798959,804806,806053,808643,810711,813740,813970,814691,8156,815755,820985,823515,824683,826014,826080,826176,834141,836330,836552,842900,843683,845106,845734,846752,848123,848245,850066,851479,853339,854521,855857,857713,859079,859375,860424,861799,86775,868260,870992,874026,876464,878559,880937,886114,888556,888891,891552,892408,893015,896175,897077,897100,897851,901930,904720,905518,906404,908251,913407,917151,918597,921299,925046,927174,929194,929295,93690,937600,94468,944998,951275,953624,955550,955668,95586,957389,96495,971233,972457,972516,976667,979282,980367,980539,988942,99035,994868,994890,996108,996407,99695]],["@trezor/connect-web>@trezor/connect>@trezor/transport",[10733,825912]],["@trezor/connect-web>@trezor/utils",[105122,10919,114422,118452,121596,126632,140895,147039,151988,152458,163960,168562,169,183583,193114,19345,200971,214941,240990,243683,245471,279971,288252,29281,297908,300795,303251,309599,312634,312898,31374,315922,317344,317668,3283,360391,377702,386474,38717,391697,402625,413391,422349,468313,473116,485286,486057,488143,504558,507929,510717,514914,524017,531436,540608,547102,551151,557099,562303,582966,598574,600242,603297,606149,608262,610477,618189,618301,623666,635766,639474,641718,642137,648889,662552,671958,673885,682727,683481,686691,700160,700816,702946,706191,707446,707804,719025,742497,746311,748577,755685,763770,773861,777833,792310,803866,805328,813058,813155,814213,815236,81812,827145,838364,842779,853776,857425,860442,863786,864786,897150,948037,959930,961652,961998,97101,977779,97924,98944,999764]],["@trezor/connect-web>@trezor/utils>bignumber.js",[457590,549083]],["@zxing/browser",[145953,147414,301448,342264,585117,594168,657902,717209,729074,754576,855256,877446]],["@zxing/library",[102076,104640,105846,10967,118907,130552,131671,135525,13619,137253,147843,148535,157062,161840,162502,165773,173036,177378,177605,181600,182358,1880,192328,200985,204042,211185,214711,217403,220502,222151,225176,226658,226843,231804,245348,245586,256598,265347,267647,281891,283130,283402,290294,290552,292589,30383,305577,30700,312627,313691,318681,322242,326170,330187,33047,331102,342062,344837,344937,348944,350023,350110,353827,35702,358354,36393,364077,366804,367456,37933,382336,38382,384185,389157,391484,395347,398079,398319,403738,410854,413135,414480,420387,426748,429613,447649,448751,448788,452848,454274,467294,470216,475173,476225,480383,48100,4886,490735,491694,495292,511410,512766,51355,517495,520474,524483,533622,543903,545034,550786,5641,567973,568293,576257,579657,58251,595812,599545,602724,604879,605398,606450,608296,618081,618221,628824,628900,633971,633978,636179,638450,639014,643367,643977,659159,66029,670237,674724,689980,690012,693466,696602,696739,701767,702808,70813,7139,715814,717651,720949,723205,726724,731223,731411,73343,734567,739843,744838,754217,762947,764246,770429,77429,781645,795293,805428,805970,809671,810595,812056,812169,826170,845566,84931,849943,853708,862070,863850,865388,873614,879385,881821,887588,887774,888951,895334,902900,907072,923877,935419,935949,939171,943402,946912,959134,96263,964206,966391,972327,978368,980892,981228,992729,993255,993733,99546,996484]],["@zxing/library>ts-custom-error",[325932]],["addons-linter>deepmerge",[239016,494597]],["async-mutex",[126335,34965,350288,424657,460177,570659,718686,936631]],["base32-encode",[564541]],["base32-encode>to-data-view",[947064]],["base64-js",[223159,237877,685590,685590]],["bignumber.js",[60746,964655]],["bitcoin-address-validation",[262686,272909]],["bitcoin-address-validation>bech32",[140322]],["bowser",[598640,598640,752049]],["browserify>concat-stream>buffer-from",[30445]],["browserify>concat-stream>typedarray",[467969]],["browserify>has>function-bind",[384002,500185,819495,86170]],["browserify>string_decoder",[242714,698800,938453,938453]],["browserify>url",[558163,873290]],["browserify>url>punycode",[546495,646246]],["browserify>util",[199472,204191,333961,642801,807928,852144]],["browserify>util>is-arguments",[785857,790588]],["browserify>util>is-generator-function",[386015,664264]],["browserify>util>is-typed-array",[242256,588421]],["browserify>util>which-typed-array",[708759,860610]],["browserify>util>which-typed-array>for-each",[541290,580911]],["browserify>xtend",[445334,45329]],["bs58",[121295,982157]],["bs58>base-x",[452885,908463]],["buffer",[387920,916794,971567,971567]],["buffer>ieee754",[170059,170059,305992,795926]],["chalk",[289568,353616,550169,620047,675473,995050]],["chalk>ansi-styles",[317566,780723]],["chalk>ansi-styles>color-convert",[179422,286427,395354,585797,733454,969867]],["chalk>supports-color",[469146,898797]],["chart.js",[137490,464071]],["chart.js>@kurkle/color",[283251]],["clsx",[92288]],["cockatiel",[119008,132427,142081,166146,187850,197840,229411,266536,286985,301137,324161,345523,36228,380736,424918,492012,496021,50519,507271,519577,541698,544190,584592,595527,606424,66690,690468,737081,755020,791579,793823,826572,826585,869397,91588,921466,923348,962708,973053,991321]],["copy-to-clipboard",[258205]],["copy-to-clipboard>toggle-selection",[876026]],["core-js-pure",[105436,120990,126725,12759,129272,137203,151859,158e3,18656,188366,194094,20560,207845,227267,227607,251242,2530,258224,25884,264629,26932,270856,277064,277389,278892,279840,286840,303606,305727,308832,31814,330035,330636,347527,347599,35086,352945,353883,354189,356579,359997,360330,370579,372433,392512,39718,400874,407322,413491,42848,449294,45914,465210,468876,485365,495678,497108,502337,506546,508591,518976,532810,536708,54840,551946,55696,562061,562352,57343,576773,579725,58616,587510,613408,646878,655559,662482,665216,666050,671814,673319,702630,706080,718422,719418,726335,739256,741560,747440,747601,748841,750338,752223,770833,777274,782214,788100,792385,804550,811989,827764,828095,850958,855233,856768,878832,880912,884024,885109,895202,897744,907471,913653,927049,927773,928937,945814,958467,965413,966053,972435,978775,985456,995454]],["cron-parser",[180793,212712,433256,439869,495081,528063,631724,796683,814724,843470]],["crypto-browserify",[554365,745856]],["crypto-browserify>browserify-cipher",[473156,647133]],["crypto-browserify>browserify-cipher>browserify-des",[213314,419175,769094,925511]],["crypto-browserify>browserify-cipher>browserify-des>des.js",[104109,127821,216938,289008,398216,609466,679344,699112,731279,762931,803859,899967]],["crypto-browserify>browserify-cipher>evp_bytestokey",[626238,774347]],["crypto-browserify>browserify-sign",[184715,184715,184715,184715,184715,184715,184715,210639,330169,364172,370063,373124,540311,634624,643038,661841,661841,661841,661841,661841,661841,661841,750771,791887]],["crypto-browserify>browserify-sign>readable-stream",[207368,221737,24961,338149,34862,389274,400143,49634,501565,520109,542596,579432,728536,85840,882487,892947,923357,954630]],["crypto-browserify>browserify-sign>readable-stream>isarray",[287141,828544]],["crypto-browserify>browserify-sign>readable-stream>safe-buffer",[228612,530523]],["crypto-browserify>browserify-sign>readable-stream>string_decoder",[240696,813931]],["crypto-browserify>browserify-sign>readable-stream>string_decoder>safe-buffer",[66,791641]],["crypto-browserify>create-ecdh",[65084,856947]],["crypto-browserify>create-hmac",[209475,718853,799678,954968]],["crypto-browserify>diffie-hellman",[248663,487876,53365,53365,53365,53365,53365,53365,53365,574293,678158,7702,776323,982225]],["crypto-browserify>diffie-hellman>miller-rabin",[434884,898823]],["crypto-browserify>pbkdf2",[2216,303271,42113,428172,504301,590683,626730,696696,763227,822303,86900,910166]],["crypto-browserify>pbkdf2>create-hash",[180133,205939,396674,837138]],["crypto-browserify>pbkdf2>ripemd160",[219475,652176]],["crypto-browserify>pbkdf2>ripemd160>hash-base",[128623,571210]],["crypto-browserify>public-encrypt",[139006,228597,431798,437355,574303,576758,584160,658759,689162,889634,92793,97677]],["crypto-browserify>public-encrypt>browserify-rsa",[172788,23717]],["crypto-browserify>public-encrypt>parse-asn1",[176150,455901,622547,657421,704002,740100,756021,890535,890535,890535,890535,890535,890535,890535,910026,996481]],["crypto-browserify>public-encrypt>parse-asn1>asn1.js",[147352,208103,30820,326570,335890,354951,42905,430576,471853,486602,502048,540274,542561,561461,561813,575188,592225,597323,600205,61716,626144,728554,735793,804506,8083,853593,933023,964662]],["crypto-browserify>randombytes",[883369,906516]],["crypto-browserify>randomfill",[654168,96103]],["currency-formatter",[160041,187270,383865,450338,72800,758533,758533,758533,758533,758533,888624,888624,888624,888624,888624,898387]],["currency-formatter>accounting",[241927,369810]],["currency-formatter>locale-currency",[11740,789077,794854,802055]],["deep-freeze-strict",[627685,703498]],["dompurify",[88174]],["duplexify>inherits",[389629,509847,985738,985738]],["eciesjs",[185661,367701,470884,517408,541560,687391,721017,855423,867881,939891,97856]],["eciesjs>@ecies/ciphers",[264220,70429]],["eslint-plugin-react>array-includes>is-string",[118857]],["eslint-plugin-react>array-includes>math-intrinsics",[23605,439486,512902,568095,608107,620455,662346,687135,712281,742296,779452,79565,877e3,963098,963442,96533]],["eslint-plugin-react>es-iterator-helpers>has-property-descriptors",[584368,695605]],["eslint-plugin-react>es-iterator-helpers>has-proto>dunder-proto",[385877,826936]],["eslint-plugin-react>hasown",[464178,704149]],["eslint>ajv",[147172,159721,16295,170097,19949,21581,226861,282833,289148,327767,349128,352705,355338,360178,377397,398680,408145,447226,4537,461238,492109,551155,557638,55850,595687,600286,673936,67713,678772,685283,729835,837021,853174,859414,861933,871063,895411,931967,955642,967140,977228,978651]],["eslint>ajv>json-schema-traverse",[603411]],["eslint>fast-deep-equal",[170210,299808,932993]],["eslint>json-stable-stringify-without-jsonify",[782636]],["eth-chainlist",[275821,405219]],["eth-ens-namehash",[489676,558791]],["eth-ens-namehash>idna-uts46-hx",[160106,593891,683712,841305]],["eth-ens-namehash>idna-uts46-hx>punycode",[33245,407262]],["eth-ens-namehash>js-sha3",[227864,889709]],["eth-lattice-keyring",[404107]],["eth-lattice-keyring>@ethereumjs/util",[136989,175611,209374,289743,31791,347350,401587,441433,513949,516751,647123,68093,798648,896464,932413]],["eth-lattice-keyring>@ethereumjs/util>@ethereumjs/rlp",[782086]],["eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography",[548920,85299,917064]],["eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/curves",[240253,383777,44186,477670,662780,728167,748501]],["eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/hashes",[1170,13639,583398,683528,717604,811517,919484,928960]],["eth-lattice-keyring>@ethereumjs/util>micro-ftch",[203639,69148]],["eth-lattice-keyring>gridplus-sdk",[723851]],["eth-lattice-keyring>gridplus-sdk>@ethereumjs/rlp",[169651,522074]],["eth-lattice-keyring>gridplus-sdk>aes-js",[782813,972828]],["eth-lattice-keyring>gridplus-sdk>bignumber.js",[143048,434255]],["eth-lattice-keyring>gridplus-sdk>bs58check",[376428,414825]],["eth-lattice-keyring>gridplus-sdk>cbor",[113870,166524,175853,217179,270294,288958,37556,396826,459229,481572,509208,513916,690170]],["eth-lattice-keyring>gridplus-sdk>cbor-bigdecimal",[390582]],["eth-lattice-keyring>gridplus-sdk>cbor>nofilter",[718497]],["eth-lattice-keyring>gridplus-sdk>crc-32",[128947]],["eth-lattice-keyring>gridplus-sdk>ox",[156642,327684,620641,623088,716750,750175,877372,911341,93090]],["eth-lattice-keyring>gridplus-sdk>secp256k1",[411333,49261,945543]],["eth-lattice-keyring>gridplus-sdk>zod",[102224,110837,11699,150083,171134,172847,18344,200791,204758,224575,230595,241973,245503,265143,268245,278287,279058,281023,282177,310712,313032,313241,317805,327662,356338,360843,365604,381348,394147,404545,406283,415542,41950,424456,425946,456539,471059,480790,48375,496328,502387,503576,518627,532330,580474,610854,613047,632003,646506,662427,681006,684647,702216,70392,704326,712509,71930,728066,74513,760978,767742,801895,820826,830351,868830,870047,883013,893374,912101,950168,962710,977323,983497,985057]],["eth-lattice-keyring>rlp",[377343]],["eth-method-registry",[239820,243922,243922,243922,243922,243922,432999,438386,852032,852032,852032,852032,852032,89008]],["eth-method-registry>@metamask/ethjs-contract",[149490,158371,171151,327729,814390,924868]],["eth-method-registry>@metamask/ethjs-contract>@metamask/ethjs-filter",[436803,9590]],["eth-method-registry>@metamask/ethjs-contract>@metamask/ethjs-util",[73489,820764]],["eth-method-registry>@metamask/ethjs-contract>ethjs-abi",[424783,43470,452332,822873]],["eth-method-registry>@metamask/ethjs-contract>ethjs-abi>number-to-bn",[545984,608417]],["eth-method-registry>@metamask/ethjs-query",[47199,883348]],["eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format",[407843,658808]],["eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format>ethjs-schema",[130530,613122,613122,613122,613122,613122]],["eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format>is-hex-prefixed",[433028,780415]],["eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format>strip-hex-prefix",[140158,341529]],["eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-rpc",[401814,482131]],["eth-method-registry>@metamask/ethjs-query>promise-to-callback",[448483,587668]],["eth-method-registry>@metamask/ethjs-query>promise-to-callback>is-fn",[745755,754084]],["eth-method-registry>@metamask/ethjs-query>promise-to-callback>set-immediate-shim",[149156,408243]],["ethereum-cryptography",[664194,77405]],["ethereumjs-util",[199060,229375,252494,260161,286982,349576,362242,405897,423693,441293,500520,512477,527514,556643,567856,57111,648297,671523,676190,7201,756854,801305,822020,850844]],["ethereumjs-util>bn.js",[416917,461532]],["ethereumjs-util>create-hash",[108619,492439,765236,825936]],["ethereumjs-util>create-hash>cipher-base",[372024,407403]],["ethereumjs-util>create-hash>md5.js",[689828,962913]],["ethereumjs-util>create-hash>md5.js>hash-base",[337073,368942]],["ethereumjs-util>create-hash>md5.js>hash-base>readable-stream",[138273,138633,160302,192891,195995,241236,271873,295891,347276,377502,388078,399896,492274,555963,556543,614793,646997,649807,6626,700460,703581,708830,731966,801517,908596,938792,943289,95690,971662,973505]],["ethereumjs-util>create-hash>ripemd160",[777899,946746]],["ethereumjs-util>create-hash>ripemd160>hash-base",[188184,346203]],["ethereumjs-util>create-hash>ripemd160>hash-base>readable-stream",[137970,15297,172368,261027,286148,337639,357763,379370,409345,43604,438430,462220,493940,516851,551538,567434,583152,59225,605971,634765,682597,779349,786589,816462,820542,887380,915477,952405,972431,975832]],["ethereumjs-util>ethereum-cryptography",[110404,496988,519915,759953,894002,93915,95453,976081]],["ethereumjs-util>ethereum-cryptography>browserify-aes",[104667,120362,160855,166623,194324,316615,328328,339226,388844,425693,496770,508919,513885,522466,531017,564143,564395,569105,57155,579600,589543,589543,589543,589543,589543,589543,589543,626996,652708,70029,766738,782553,787881,825934,909099,958896,966121,966682,999384,999908]],["ethereumjs-util>ethereum-cryptography>browserify-aes>buffer-xor",[400492,64679]],["ethereumjs-util>ethereum-cryptography>bs58check",[224485,283092,328208,767265]],["ethereumjs-util>ethereum-cryptography>bs58check>bs58",[411447,921602]],["ethereumjs-util>ethereum-cryptography>keccak",[156187,188166,2560,289124,351903,399137,597833,599140,883926,937780,97631,978239]],["ethereumjs-util>ethereum-cryptography>keccak>readable-stream",[120656,141293,163083,200606,201271,234258,236194,261453,364924,427167,43819,507487,511022,527114,535004,576557,611239,618502,62895,716001,7176,722326,731291,751113,76524,786926,833699,833726,860185,972964]],["ethereumjs-util>ethereum-cryptography>secp256k1",[449222,459010,524053,634699,667525,75366]],["ethereumjs-util>rlp",[312945,724840]],["ethers",[100238,164293,49566,518459,60361,621453]],["ethers>@ethersproject/abstract-provider",[136854,211701,337985,445174]],["ethers>@ethersproject/abstract-signer",[230706,514118,642731,654687]],["ethers>@ethersproject/address",[243322,317262,421357,998381]],["ethers>@ethersproject/base64",[116728,384786,447309,893747]],["ethers>@ethersproject/basex",[445759,873202]],["ethers>@ethersproject/constants",[101866,166699,738178,862333,870597,885644,901513,994501]],["ethers>@ethersproject/hash",[102391,130488,14327,229341,248528,375271,410943,412718,449047,578030,580813,646265,653503,691950,789828,79978,886384,974082]],["ethers>@ethersproject/json-wallets",[156057,27263,37426,401097,459908,580226,611720,655343,664514,749805,903739,921036]],["ethers>@ethersproject/json-wallets>aes-js",[302968,306515]],["ethers>@ethersproject/json-wallets>scrypt-js",[198336,305583]],["ethers>@ethersproject/keccak256",[233071,453002]],["ethers>@ethersproject/logger",[192947,329882,697489,883272]],["ethers>@ethersproject/networks",[10405,120216,332071,484058]],["ethers>@ethersproject/pbkdf2",[25643,712740]],["ethers>@ethersproject/properties",[176899,227198,338777,830724]],["ethers>@ethersproject/random",[234605,247023,313864,401282,424574,701504,862331,942107]],["ethers>@ethersproject/rlp",[246420,603988,820707,97991]],["ethers>@ethersproject/sha2",[116409,292750,323064,451058,571115,616008,802099,805929]],["ethers>@ethersproject/sha2>hash.js",[102033,128995,132485,179206,186330,238575,245891,283376,34759,387824,438047,439794,466610,51954,567879,57764,65135,80193,826733,832544,88054,89724,909328,970813]],["ethers>@ethersproject/signing-key",[120607,234380,255468,334645,592936,629441]],["ethers>@ethersproject/solidity",[619679,645682,743720,911877]],["ethers>@ethersproject/strings",[108514,301239,329038,340519,382916,465085,677367,795768,855040,936523]],["ethers>@ethersproject/units",[315087,394691,485374,91170]],["ethers>@ethersproject/wallet",[309353,349147,596598,923412]],["ethers>@ethersproject/web",[129311,247884,254712,55410,699423,738337]],["ethers>@ethersproject/wordlists",[273548,386977,400906,738213,760345,792456,837578,995917]],["extension-port-stream",[283079,283079,345979,452179,48050,48050,610518,679620,770467,770467,803058,803058]],["fast-json-patch",[283026,380569,717649,79551]],["fast-json-stable-stringify",[323260,665857]],["fuse.js",[863985]],["gulp>vinyl-fs>object.assign",[302547,337740,461066,724264,852903,983725]],["he",[106115]],["https-browserify",[428284,965339]],["human-standard-token-abi",[186688,944211]],["humanize-duration",[477355]],["immer",[115691,115691,273715,319222,801881,892928,92365,950515,950515]],["ip-regex",[357910,461612]],["jest-canvas-mock>moo-color>color-name",[469804,934681]],["jsdom>form-data>es-set-tostringtag>has-tostringtag",[136935,197300]],["lightweight-charts",[194859]],["lightweight-charts>fancy-canvas",[128943,243582,418818,443436,631652]],["localforage",[544654,569235]],["lodash",[100323,101488,104045,104300,108041,109528,111907,112437,112536,112551,113743,11616,116358,119057,119079,120960,122040,122368,122932,123673,124842,127300,127750,129649,133527,135471,136471,136571,137234,138115,138942,145831,14601,146739,14786,15361,156851,160750,164325,165571,166136,168474,169811,169938,170623,170906,172113,174506,177356,179668,184084,185309,186049,188312,192311,197614,199676,202665,203748,206566,208154,21199,219334,21937,22114,223116,223837,225953,226865,227704,23126,236872,23879,240918,241297,241421,245780,247835,249114,250846,254517,255991,257776,268882,271916,272175,272424,276617,277608,281596,281657,284431,286093,286210,288403,288724,289577,29025,293628,295215,297868,298246,298730,308731,308903,310326,311588,319805,323304,328821,33586,339886,346184,349017,350846,353313,358633,358825,361178,366931,36833,369940,373754,376972,37705,37766,378768,383565,383714,385115,386042,391602,394939,395464,401950,403616,415138,416456,41989,422966,423,424135,428926,428940,429704,430303,433702,433752,433789,436820,438681,438993,440477,447822,449809,455911,456422,456895,456895,458090,459722,461663,463851,465948,471378,47503,475162,476031,481585,481803,483578,485063,485182,487091,498256,498265,500610,502051,502503,504273,509366,510185,517014,517141,517861,522306,524621,533906,535806,53836,53857,543987,550608,553939,556600,55750,558909,562347,563252,564009,564585,568112,571198,576629,580484,58095,585350,586053,58799,58883,589847,589893,593563,59461,604062,605271,608501,616685,618431,620901,622857,623755,625240,629553,631293,631328,633411,635952,641229,645617,647294,648362,65115,652185,653160,653552,655676,65804,658647,659294,659891,660863,663917,665697,666775,667537,668205,670163,671125,671945,679328,68055,682708,685209,685544,690007,692628,695038,698790,698988,699180,700365,702879,704597,709499,714386,718720,722604,726315,726927,727656,728442,728810,728852,72890,72999,733395,74170,744305,744392,746797,751209,752543,755904,758387,759740,760824,765905,771366,779752,782959,788018,796982,797710,797772,799648,807822,810117,810914,813305,813523,817253,821432,822018,822539,826448,830089,830728,833883,834725,835792,837054,837821,838154,840989,841010,843361,844065,845660,849648,851077,855723,859185,859340,859340,861862,863423,868080,871201,871429,871614,873706,884485,887728,891013,892641,895090,895754,903543,904094,905252,910005,91158,919816,920277,920423,92662,927445,928442,928863,929441,930439,933290,939132,944880,945343,949014,953427,953568,961657,966050,96672,971273,97348,976160,976588,978696,980790,981154,983065,98500,989300,992261,995922,997225,998084,999426]],["loglevel",[171097,171097,186992,681050]],["lottie-web",[908216]],["luxon",[112660,122552,122552,138292,138292,14631,14631,208570,208570,210164,210164,228300,232712,232712,232748,263496,263496,283707,283707,296093,305921,316244,316244,317588,317588,347022,347022,352134,352134,360569,360569,392134,392134,417784,419186,419186,442525,442525,446655,446655,451798,451798,463404,484651,493104,493104,512986,512986,525037,525037,552578,558191,592161,597054,597054,600473,600473,603476,603476,609920,640846,640846,670188,686333,686333,688072,695358,695358,701043,7082,731318,731318,735606,750628,750628,763326,774810,774810,775158,775158,78565,78565,791436,794204,794204,821213,821213,831022,831022,835060,835060,835203,835203,85013,85013,86198,868766,868766,891728,891728,892859,895036,907643,912276,912276,925752,925752,938102,938102,948972,948972,951906,951906,961520,961520,964556,977366,984381,984381,991213,991213,994218]],["mocha>ms",[134281,254660,254660,425626]],["mocha>yargs-unparser>is-plain-obj",[119552]],["mockttp>@httptoolkit/subscriptions-transport-ws>symbol-observable",[160875,76648,795713,992594]],["mockttp>express>qs",[169116,291497,299405,315677,428518,556189,663098,717698,80776,875855]],["mockttp>express>safe-buffer",[107796,495670,677197,677197]],["nanoid",[531589,840019]],["nock>debug",[465273,617648,683075,683075,72092,952574,952574,978406]],["openai>abort-controller",[113795,577345,581808,581808]],["path-browserify",[386023]],["pify",[577564]],["process",[208835,208835,208835,242777,378326,378326]],["prop-types",[557789,787332,991606]],["prop-types>object-assign",[858524,905751]],["psl",[153782,95422]],["punycode",[259278,478759]],["qrcode-generator",[929736]],["qrcode.react",[174799]],["react",[23591,276592,31816,336620,506711,860012]],["react-chartjs-2",[173127]],["react-compiler-runtime",[303280,376775]],["react-devtools-core",[38588]],["react-dom",[1159,495264,812640,879505]],["react-dom>scheduler",[117047,192080,517405,594158]],["react-focus-lock",[124676,171702,304417,59129,679770,921718,977522]],["react-focus-lock>focus-lock",[130680,135719,153956,176839,296640,341413,360116,365187,367975,417071,578063,653567,664882,697295,716734,750025,780392,826111,837793,906089,997295]],["react-focus-lock>react-clientside-effect",[132165]],["react-focus-lock>use-callback-ref",[334392,415976,989992]],["react-focus-lock>use-sidecar",[886509]],["react-hot-toast",[638891]],["react-hot-toast>goober",[656304]],["react-idle-timer",[282382]],["react-markdown",[66117,909295,966680,973839]],["react-markdown>comma-separated-tokens",[142527]],["react-markdown>property-information",[109794,136933,222985,287738,293780,403493,403939,489890,625821,651420,709064,709064,709064,709064,709064,713726,815182,887583,897558,918358,927244,95526,993601]],["react-markdown>react-is",[287916,848688]],["react-markdown>remark-parse",[11815]],["react-markdown>remark-parse>mdast-util-from-markdown",[284865,839200]],["react-markdown>remark-parse>mdast-util-from-markdown>mdast-util-to-string",[350350]],["react-markdown>remark-parse>mdast-util-from-markdown>micromark",[115271,122266,129245,13320,144508,147528,156518,158366,160413,166022,167141,191006,236757,255771,300725,32735,345752,350100,367096,369e3,386920,387601,415431,429198,432225,434122,465465,472696,50096,50571,505862,513233,517015,542008,55976,588891,596678,619258,619473,626280,646592,667890,677964,678462,68733,703367,725077,749567,754388,757024,763528,779357,784573,804392,835101,852994,857909,861137,877216,89161,913200,91494,920522,935714,942864,961766,970745,971206,971933,993242,995783]],["react-markdown>remark-rehype",[607537]],["react-markdown>remark-rehype>mdast-util-to-hast",[127017,130453,157984,191532,195532,215432,235812,247600,281038,317058,361014,370310,467157,532167,540226,542795,55227,56788,571047,577504,645553,646177,658367,694268,695298,712147,866355,868166,943308,964922]],["react-markdown>remark-rehype>mdast-util-to-hast>mdurl",[590387]],["react-markdown>remark-rehype>mdast-util-to-hast>unist-builder",[7900]],["react-markdown>remark-rehype>mdast-util-to-hast>unist-util-generated",[602721]],["react-markdown>remark-rehype>mdast-util-to-hast>unist-util-position",[679975]],["react-markdown>space-separated-tokens",[127668]],["react-markdown>style-to-object",[230916]],["react-markdown>style-to-object>inline-style-parser",[395196]],["react-markdown>unified",[286837]],["react-markdown>unified>bail",[370001]],["react-markdown>unified>extend",[203585]],["react-markdown>unified>is-buffer",[287094]],["react-markdown>unified>trough",[652804]],["react-markdown>unist-util-visit",[498679]],["react-markdown>unist-util-visit>unist-util-is",[498559]],["react-markdown>unist-util-visit>unist-util-visit-parents",[776279,949742]],["react-markdown>vfile",[461651,621468]],["react-markdown>vfile>is-buffer",[444576]],["react-markdown>vfile>replace-ext",[68215]],["react-markdown>vfile>unist-util-stringify-position",[296107]],["react-markdown>vfile>vfile-message",[166301]],["react-popper",[646948,897908]],["react-popper>react-fast-compare",[101875]],["react-redux",[176578,23106,235140,247013,26847,291331,299143,314701,369148,410277,421859,470995,473584,48084,525300,52906,562328,5637,585874,62629,66593,684723,686369,701844,721075,745865,750644,771307,772362,787962,824341,842142,858420,872169,881984,891030,909463,915978,92952,956152]],["react-redux>hoist-non-react-statics",[156383,339394]],["react-redux>hoist-non-react-statics>react-is",[113132,211999,327683,337392]],["react-redux>react-is",[167172,259120,457869,924865]],["react-router-dom",[994112]],["react-router-dom>@remix-run/router",[682660]],["react-router-dom>react-router",[107495]],["react-simple-file-input",[742431]],["react-syntax-highlighter>refractor>parse-entities",[512920]],["react-tippy",[971180]],["react-tippy>popper.js",[975427]],["react-toggle-button",[490926]],["react-transition-group",[131350,284003,639130,829556,84954,936137,996331]],["react-transition-group>dom-helpers",[475843,815834,819347]],["readable-stream",[106951,114515,130971,138077,153089,181536,188078,194535,194535,203058,208075,22250,234970,238511,252334,252334,252859,252859,259290,261069,262327,268576,293230,294855,294855,338568,338568,366117,42401,425051,425493,425934,425934,443305,44565,448492,448492,449219,449219,452547,452547,464812,470292,485697,494247,494639,530232,548444,568577,586805,588847,588847,602416,613318,613318,631222,631222,632914,632914,68266,68266,683024,683122,699960,699960,703102,708566,708566,728264,730636,73701,754857,761124,761124,769584,769584,770587,777352,777352,809090,809090,816718,816718,827525,827525,831171,831171,837911,868387,868387,887131,895890,900457,900457,917165,921007,930607,978529,981686,9831]],["readable-stream-2>core-util-is",[711510,867645]],["readable-stream-2>process-nextick-args",[102393,688246]],["redux",[207497,60416]],["redux-thunk",[109842,488961]],["remote-redux-devtools",[120443,188424,348475,398548,417589,712044,933721,961812]],["remote-redux-devtools>jsan",[114885,151109,322054,341696,394938,425053,427767,789796,902841,965556]],["remote-redux-devtools>redux-devtools-core",[172251,566087,650496,778624,934583,981822]],["remote-redux-devtools>redux-devtools-core>get-params",[31908,809405]],["remote-redux-devtools>redux-devtools-core>nanoid",[18302,659269]],["remote-redux-devtools>redux-devtools-core>remotedev-serialize",[205061,274996,43736,464435,688790,98567]],["remote-redux-devtools>redux-devtools-instrument",[217867,672879]],["remote-redux-devtools>rn-host-detect",[653154,710043]],["remote-redux-devtools>socketcluster-client",[130306,134786,280959,36385,424483,46337,557915,672552,701487,844684,851566,94862,963198,99517]],["remote-redux-devtools>socketcluster-client>buffer",[627940,64373]],["remote-redux-devtools>socketcluster-client>clone",[430638,559329]],["remote-redux-devtools>socketcluster-client>component-emitter",[215573,372675]],["remote-redux-devtools>socketcluster-client>linked-list",[200350,262580,759067,823987]],["remote-redux-devtools>socketcluster-client>querystring",[29941,526454,554315,676013,76450,792050]],["remote-redux-devtools>socketcluster-client>sc-channel",[891709,989910]],["remote-redux-devtools>socketcluster-client>sc-errors",[389961,520309,596176,601342]],["remote-redux-devtools>socketcluster-client>sc-formatter",[38652,508873]],["remote-redux-devtools>socketcluster-client>uuid",[107216,192925,496957,596614,626654,648025,855310,901967,905155,998316]],["reselect",[491616,951696]],["sass-embedded>varint",[278676,418914,815680,870232]],["semver",[102998,11114,130698,132606,159585,212669,213832,223550,237927,248391,250377,258453,273657,282429,295762,297891,298090,300736,309624,315317,339498,343546,346340,348400,36974,400386,413859,437715,449524,458014,460668,467260,469878,470644,481665,486031,48939,506168,512786,526710,535367,558557,560706,563167,566205,568925,596964,598305,605657,606005,607684,618315,623287,626162,627830,630655,645178,65667,656844,673188,679153,685987,692636,712800,74207,768365,768605,769567,77365,783212,801015,811863,829373,843432,846768,846891,848745,869544,872547,884499,908707,908975,9090,917098,922262,927349,931574,947946,980803,988446]],["stream-browserify",[594950,888781]],["stream-browserify>readable-stream",[109279,151838,204881,272244,305685,311802,312964,324373,472466,476851,48197,500040,522422,525412,52799,536442,588091,64502,64576,69755,699075,719265,74904,794353,836603,898431,909430,92456]],["stream-http",[162465,424492,427182,482901,669741,683392,819935,99248]],["stream-http>builtin-status-codes",[312335,535522]],["stream-http>readable-stream",[113306,156978,184437,189546,193050,195473,200733,201511,238979,253052,263792,290054,306458,322580,331753,365442,375248,408375,410939,4524,493781,512565,626160,654939,665564,790745,79871,874757,930722,960461]],["string.prototype.matchall>call-bind",[161546,567943,705035,996770]],["string.prototype.matchall>call-bind>call-bind-apply-helpers",[105132,170697,195819,26796,288605,635101,647304,653002,870079,873110,893405,918572]],["string.prototype.matchall>call-bind>es-define-property",[661292,861807]],["string.prototype.matchall>call-bind>set-function-length",[874449,957404]],["string.prototype.matchall>call-bound",[481117,727164]],["string.prototype.matchall>define-properties",[581439,919684]],["string.prototype.matchall>define-properties>define-data-property",[557806,562089]],["string.prototype.matchall>es-abstract>array-buffer-byte-length",[664167]],["string.prototype.matchall>es-abstract>available-typed-arrays",[167871,94121]],["string.prototype.matchall>es-abstract>es-to-primitive>is-symbol",[613340]],["string.prototype.matchall>es-abstract>get-proto",[144767,193624,622892,634207,659417,744104]],["string.prototype.matchall>es-abstract>is-array-buffer",[78062]],["string.prototype.matchall>es-abstract>is-callable",[76176,922191]],["string.prototype.matchall>es-abstract>is-regex",[598040,969219]],["string.prototype.matchall>es-abstract>is-set",[275840]],["string.prototype.matchall>es-abstract>is-shared-array-buffer",[610558]],["string.prototype.matchall>es-abstract>object-inspect",[427195,865172]],["string.prototype.matchall>es-abstract>safe-regex-test",[756068,92025]],["string.prototype.matchall>es-abstract>stop-iteration-iterator",[181996]],["string.prototype.matchall>es-abstract>typed-array-buffer",[274013,813364]],["string.prototype.matchall>es-abstract>typed-array-length>possible-typed-array-names",[267058,529107]],["string.prototype.matchall>es-abstract>unbox-primitive>has-bigints",[733838]],["string.prototype.matchall>es-errors",[231436,331300,382711,444699,492449,50102,523869,529354,592005,68025,701026,80974,812937,995452]],["string.prototype.matchall>es-object-atoms",[152963,588684]],["string.prototype.matchall>get-intrinsic",[191720,933]],["string.prototype.matchall>get-intrinsic>async-function",[779198,846207]],["string.prototype.matchall>get-intrinsic>async-generator-function",[449199,998538]],["string.prototype.matchall>get-intrinsic>generator-function",[538426,735833]],["string.prototype.matchall>gopd",[377379,599968,768613,99180]],["string.prototype.matchall>has-symbols",[160055,431420,49798,694053]],["string.prototype.matchall>internal-slot",[228431]],["string.prototype.matchall>regexp.prototype.flags",[167986,330037,739552,85627]],["string.prototype.matchall>set-function-name",[81814]],["string.prototype.matchall>set-function-name>functions-have-names",[645102]],["string.prototype.matchall>side-channel",[590357,800360]],["string.prototype.matchall>side-channel>side-channel-list",[592227,602442]],["string.prototype.matchall>side-channel>side-channel-map",[344459,547964]],["string.prototype.matchall>side-channel>side-channel-weakmap",[135004,176959]],["ts-mixer",[419108,96481]],["tslib",[344125,92295]],["tweetnacl",[324494,990115]],["unicode-confusables",[531743,531743,531743,531743,531743,540270]],["uri-js",[817502,925475]],["uuid",[106555,112068,112471,123628,123628,123628,131721,16478,189065,216062,247086,299896,301170,348274,38401,485791,516074,575044,585925,586218,607247,609345,620897,621501,632864,659008,659008,659008,726763,739070,761366,834669,834669,834669,849401,921766,921766,921766,923533,934268,951545,951545,951545,975918,995891]],["viem",[126414,134615,142622,144027,152629,154005,159903,192555,193614,231970,244540,253581,260850,263174,281681,290378,293249,298433,33133,362600,376744,411408,451639,466542,477870,481181,503517,516596,554850,577,602405,641142,647738,69995,70230,734169,736411,73794,768068,771532,79584,852085,85632,863127,883699,889515,890883,921124,927081,950576,954345,976013,991845]],["viem>abitype",[126519,155015,162437,168943,378235,452758,611346,7e3,840360,865800,895483,968937,993672]],["wait-on>axios",[132519,138428,17975,183401,196434,235935,247769,2556,260798,269126,272145,279845,302569,307443,329788,337049,337521,347359,35829,365459,374258,405386,423956,435085,443032,447923,451360,456048,47793,516138,527358,561903,573038,577145,621558,627273,652455,653978,685727,686914,727629,732582,736027,738874,743479,757315,771027,776451,793963,933203]],["wait-on>rxjs",[181684,246511,284905,288855,330355,333101,352984,386675,455485,473262,526292,534931,545828,598869,668048,733160,861952,924791]],["web-vitals",[811870]],["webextension-polyfill",[251070,392248,392248,413279,413279]],["webpack-cli>fastest-levenshtein",[593950]],["webpack>events",[55854,780063,780063,998088]]],e.unenforceable=[121455,20168,20168,20168,20168,20168,20168,20168,201783,201783,201783,201783,201783,236305,236305,236305,245672,245672,245672,245672,245672,245672,245672,245672,337994,337994,337994,337994,337994,337994,337994,337994,343966,343966,343966,343966,343966,343966,343966,343966,371173,383972,383972,383972,383972,383972,383972,383972,383972,400495,400495,400495,400495,400495,400495,400495,400495,439181,440830,440830,440830,440830,440830,440830,446179,490513,490513,490513,490513,490513,490513,490513,490513,492752,531854,531854,531854,531854,531854,531854,531854,531854,588776,588776,588776,588776,588776,588776,588776,588776,619200,623661,623661,623661,623661,623661,623661,623661,623661,638581,638581,638581,638581,638581,638581,638581,638581,639266,639266,639266,639266,639266,639266,639266,639266,667544,667544,667544,667544,667544,667544,667544,667544,685066,685066,685066,685066,685066,685066,685066,685066,68724,68724,68724,68724,68724,68724,705444,715050,715050,715050,715050,715050,715050,715050,715050,733258,733258,733258,733258,733258,733258,733258,733258,744643,744643,744643,744643,744643,744643,744643,744643,74754,762634,762634,762634,762634,762634,762634,762634,762634,792981,792981,792981,792981,792981,792981,792981,792981,794832,794832,794832,801874,801874,801874,833028,901409,901409,901409,901409,901409,901409,901409,901409,902731,902731,902731,902731,902731,950514,950514,950514,950514,950514,950514,950514,960548,960548,960548,960548,960548,960548,980564,980564,980564,980564,980564,980564,980564,980564,999154,999154,999154],e.ctxm=[],e.kch=[110,1105,1122,1290,1309,133,1331,1391,1474,1476,1491,1507,1522,1523,1598,1620,166,1684,1768,1791,1818,1826,185,1864,1887,2040,2118,2160,2186,2189,2203,2213,2215,229,2445,2449,2514,2584,2598,2638,2664,2669,2710,2721,2747,2776,2806,285,2913,2962,305,308,3139,3288,3375,339,3400,3404,343,3602,3740,3756,3785,3809,388,3885,392,3931,3956,4016,4052,407,4073,4113,418,425,427,4274,4294,4307,4323,4377,4480,4520,4549,4579,4593,46,461,463,4633,4634,4753,4781,4813,483,4859,5087,5098,5151,5175,5250,5297,5407,5437,5458,5580,5609,5657,5671,5762,5796,5864,5917,5964,6023,6053,6115,614,6141,6209,6358,6401,6428,6556,6565,659,6622,6649,6660,670,6714,6802,6828,6843,6906,7064,7091,7115,7145,7160,7178,7219,7354,74,7449,7547,7555,7568,7614,7651,7755,78,7899,7962,7980,8015,8034,8063,8093,8190,836,8364,8427,8528,8650,8717,8734,8789,8790,8792,8811,887,891,8927,8935,8946,8994,9038,904,9060,9121,9165,9171,9232,9277,9289,9313,9354,9424,9523,9600,9689,9737,9807,9949,9957],e.externals={},e.options={lockdown:{consoleTaming:"unsafe",errorTaming:"unsafe",errorTrapping:"none",localeTaming:"unsafe",overrideTaming:"severe",reporting:"none",stackFiltering:"verbose"},scuttleGlobalThis:{enabled:!0,exceptions:["window","Proxy","toString","getComputedStyle","addEventListener","removeEventListener","ShadowRoot","HTMLElement","HTMLFormElement","Element","pageXOffset","pageYOffset","visualViewport","Reflect","Set","Object","navigator","harden","console","WeakSet","Event","EventTarget","Image","fetch","AbortController","OffscreenCanvas","/cdc_[a-zA-Z0-9]+_[a-zA-Z]+/iu","name","performance","parseFloat","innerWidth","innerHeight","Symbol","Math","DOMRect","Number","Array","crypto","Function","Uint8Array","String","Promise","JSON","Date","RegExp","__SENTRY__","appState","extra","stateHooks","sentryHooks","sentry","logEncryptedVault","history","getSelection","opr","devicePixelRatio","ResizeObserver","setTimeout","clearTimeout","importScripts","webpackChunk"]}},(()=>{let t={exports:{}};t.exports;let{Object:r,Array:n,Error:s,RegExp:a,Set:o,console:i,Proxy:l,Reflect:c}=globalThis,{assign:u,getOwnPropertyNames:m,getOwnPropertyDescriptor:d,create:p,defineProperty:h}=r,f=function(e,t){return r.getOwnPropertyNames(e).filter(r=>e[r]===t[r]).concat(["Compartment","Error","globalThis"])}(new Compartment().globalThis,globalThis),{isArray:g,from:y}=n,{getPrototypeOf:b}=c,{warn:k}=i;t.exports={scuttle:function(e,t){let r=function(e,t=p(null)){let r={enabled:!0,exceptions:[],scuttlerName:""},n=u(p(null),!0===t?r:t,{scuttlerFunc:(e,t)=>t(e)},{exceptions:(t?.exceptions||r.exceptions).map(e=>(function(e){if(!e.startsWith("/"))return e;let t=e.split("/");return new a(t.slice(1,-1).join("/"),t[t.length-1])})(e))});if(n.scuttlerName){if(!e[n.scuttlerName])throw new s(`LavaMoat - 'scuttlerName' function "${n.scuttlerName}" expected on globalRef.To learn more visit https://github.com/LavaMoat/LavaMoat/pull/462.`);n.scuttlerFunc=e[n.scuttlerName]}return n}(e,t);if(r.enabled){if(!g(r.exceptions))throw new s(`LavaMoat - exceptions must be an array, got ${typeof r.exceptions}`);r.scuttlerFunc(e,e=>(function(e,t=[]){let r=[];(function(e){let t=[],r=e;for(;r&&("object"==typeof r||"function"==typeof r);)t.push(r),r=b(r);return t})(e).forEach(e=>r.push(...m(e)));let n=new o([...f,...t]),i=p(null);r.forEach(t=>{let r,o,{get:c,set:u}={get:function(){throw new s(`LavaMoat - property "${t}" of globalThis is inaccessible under scuttling mode. To learn more visit https://github.com/LavaMoat/LavaMoat/pull/360.`)},set:function(){k(`LavaMoat - property "${t}" of globalThis cannot be set under scuttling mode. To learn more visit https://github.com/LavaMoat/LavaMoat/pull/360.`)}};if(r=n,o=t,y(r).some(e=>"string"==typeof e&&e===o||e instanceof a&&e.test(o)))return;let m=d(e,t);if(m?.configurable===!0)m={configurable:!1,set:u,get:c};else{if(m?.writable!==!0)return;m={configurable:!1,writable:!1,value:new l(i,{getPrototypeOf:c,get:c,set:u})}}h(e,t,m)})})(e,r.exceptions))}}},e.scuttling=t.exports})(),e.policy={resources:{"@babel/runtime":{globals:{regeneratorRuntime:"write"}},"@emotion/react":{globals:{HTMLElement:!0,"document.querySelector":!0},packages:{"@babel/runtime":!0,"@emotion/react>@emotion/cache":!0,"@emotion/react>@emotion/serialize":!0,"@emotion/react>@emotion/use-insertion-effect-with-fallbacks":!0,"@emotion/react>@emotion/utils":!0,"@emotion/react>@emotion/weak-memoize":!0,react:!0,"react-redux>hoist-non-react-statics":!0}},"@emotion/react>@emotion/cache":{globals:{"document.head":!0,"document.querySelectorAll":!0},packages:{"@emotion/react>@emotion/cache>@emotion/memoize":!0,"@emotion/react>@emotion/cache>@emotion/sheet":!0,"@emotion/react>@emotion/cache>stylis":!0,"@emotion/react>@emotion/weak-memoize":!0}},"@emotion/react>@emotion/cache>@emotion/sheet":{globals:{"document.createElement":!0,"document.createTextNode":!0,"document.styleSheets":!0}},"@emotion/react>@emotion/serialize":{packages:{"@emotion/react>@emotion/cache>@emotion/memoize":!0,"@emotion/react>@emotion/serialize>@emotion/hash":!0,"@emotion/react>@emotion/serialize>@emotion/unitless":!0}},"@emotion/react>@emotion/use-insertion-effect-with-fallbacks":{packages:{react:!0}},"@emotion/styled":{packages:{"@babel/runtime":!0,"@emotion/react":!0,"@emotion/react>@emotion/serialize":!0,"@emotion/react>@emotion/use-insertion-effect-with-fallbacks":!0,"@emotion/react>@emotion/utils":!0,"@emotion/styled>@emotion/is-prop-valid":!0,react:!0}},"@emotion/styled>@emotion/is-prop-valid":{packages:{"@emotion/react>@emotion/cache>@emotion/memoize":!0}},"@ensdomains/content-hash":{globals:{"Buffer.from":!0,"console.warn":!0},packages:{"@ensdomains/content-hash>cids":!0,"@ensdomains/content-hash>js-base64":!0,"@ensdomains/content-hash>multicodec":!0,"@ensdomains/content-hash>multihashes":!0,"@ensdomains/content-hash>multihashes>buffer":!0}},"@ensdomains/content-hash>cids":{packages:{"@ensdomains/content-hash>cids>multibase":!0,"@ensdomains/content-hash>cids>multihashes":!0,"@ensdomains/content-hash>cids>uint8arrays":!0,"@ensdomains/content-hash>multicodec":!0}},"@ensdomains/content-hash>cids>multibase":{globals:{TextDecoder:!0,TextEncoder:!0},packages:{"@ensdomains/content-hash>cids>multibase>@multiformats/base-x":!0}},"@ensdomains/content-hash>cids>multihashes":{packages:{"@ensdomains/content-hash>cids>multibase":!0,"@ensdomains/content-hash>cids>multihashes>uint8arrays":!0,"@ensdomains/content-hash>cids>multihashes>varint":!0}},"@ensdomains/content-hash>cids>multihashes>uint8arrays":{globals:{TextDecoder:!0,TextEncoder:!0},packages:{"@ensdomains/content-hash>cids>multibase":!0}},"@ensdomains/content-hash>cids>uint8arrays":{globals:{TextDecoder:!0},packages:{"@ensdomains/content-hash>cids>multibase":!0}},"@ensdomains/content-hash>js-base64":{globals:{Base64:"write",Buffer:!0,TextDecoder:!0,TextEncoder:!0,atob:!0,btoa:!0,define:!0},packages:{buffer:!0}},"@ensdomains/content-hash>multicodec":{packages:{"@ensdomains/content-hash>multicodec>uint8arrays":!0,"sass-embedded>varint":!0}},"@ensdomains/content-hash>multicodec>uint8arrays":{globals:{Buffer:!0,TextDecoder:!0,TextEncoder:!0},packages:{"@metamask/assets-controllers>multiformats":!0}},"@ensdomains/content-hash>multihashes":{packages:{"@ensdomains/content-hash>multihashes>buffer":!0,"@ensdomains/content-hash>multihashes>multibase":!0,"@ensdomains/content-hash>multihashes>varint":!0,"@ensdomains/content-hash>multihashes>web-encoding":!0}},"@ensdomains/content-hash>multihashes>buffer":{globals:{console:!0},packages:{"base64-js":!0,"buffer>ieee754":!0}},"@ensdomains/content-hash>multihashes>multibase":{packages:{"@ensdomains/content-hash>multihashes>buffer":!0,"@ensdomains/content-hash>multihashes>multibase>base-x":!0,"@ensdomains/content-hash>multihashes>web-encoding":!0}},"@ensdomains/content-hash>multihashes>multibase>base-x":{packages:{"mockttp>express>safe-buffer":!0}},"@ensdomains/content-hash>multihashes>web-encoding":{globals:{TextDecoder:!0,TextEncoder:!0},packages:{"browserify>util":!0}},"@ethereumjs/tx":{packages:{"@ethereumjs/tx>@ethereumjs/common":!0,"@ethereumjs/tx>@ethereumjs/rlp":!0,"@ethereumjs/tx>@ethereumjs/util":!0,"@ethereumjs/tx>ethereum-cryptography":!0}},"@ethereumjs/tx>@ethereumjs/common":{packages:{"@ethereumjs/tx>@ethereumjs/util":!0,"webpack>events":!0}},"@ethereumjs/tx>@ethereumjs/rlp":{globals:{TextEncoder:!0}},"@ethereumjs/tx>@ethereumjs/util":{globals:{"console.warn":!0,fetch:!0},packages:{"@ethereumjs/tx>@ethereumjs/rlp":!0,"@ethereumjs/tx>@ethereumjs/util>ethereum-cryptography":!0,"@ethereumjs/tx>@ethereumjs/util>ethereum-cryptography>@noble/curves":!0,"@ethereumjs/tx>ethereum-cryptography>@noble/curves":!0,"webpack>events":!0}},"@ethereumjs/tx>@ethereumjs/util>ethereum-cryptography":{globals:{TextDecoder:!0,crypto:!0,module:!0},packages:{"@ethereumjs/tx>@ethereumjs/util>ethereum-cryptography>@noble/curves":!0,"@ethereumjs/tx>@ethereumjs/util>ethereum-cryptography>@noble/hashes":!0}},"@ethereumjs/tx>@ethereumjs/util>ethereum-cryptography>@noble/curves":{globals:{TextEncoder:!0},packages:{"@ethereumjs/tx>@ethereumjs/util>ethereum-cryptography>@noble/hashes":!0}},"@ethereumjs/tx>@ethereumjs/util>ethereum-cryptography>@noble/hashes":{globals:{TextEncoder:!0,crypto:!0}},"@ethereumjs/tx>ethereum-cryptography":{globals:{TextDecoder:!0,crypto:!0,module:!0},packages:{"@ethereumjs/tx>ethereum-cryptography>@noble/hashes":!0}},"@ethereumjs/tx>ethereum-cryptography>@noble/hashes":{globals:{TextEncoder:!0}},"@ethersproject/abi":{globals:{"console.log":!0},packages:{"@ethersproject/bignumber":!0,"@ethersproject/bytes":!0,"ethers>@ethersproject/address":!0,"ethers>@ethersproject/constants":!0,"ethers>@ethersproject/hash":!0,"ethers>@ethersproject/keccak256":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/properties":!0,"ethers>@ethersproject/strings":!0}},"@ethersproject/bignumber":{packages:{"@ethersproject/bytes":!0,"ethereumjs-util>bn.js":!0,"ethers>@ethersproject/logger":!0}},"@ethersproject/bytes":{packages:{"ethers>@ethersproject/logger":!0}},"@ethersproject/contracts":{globals:{setTimeout:!0},packages:{"@ethersproject/abi":!0,"@ethersproject/bignumber":!0,"@ethersproject/bytes":!0,"@ethersproject/transactions":!0,"ethers>@ethersproject/abstract-provider":!0,"ethers>@ethersproject/abstract-signer":!0,"ethers>@ethersproject/address":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/properties":!0}},"@ethersproject/hdnode":{packages:{"@ethersproject/bignumber":!0,"@ethersproject/bytes":!0,"@ethersproject/transactions":!0,"ethers>@ethersproject/basex":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/pbkdf2":!0,"ethers>@ethersproject/properties":!0,"ethers>@ethersproject/sha2":!0,"ethers>@ethersproject/signing-key":!0,"ethers>@ethersproject/strings":!0,"ethers>@ethersproject/wordlists":!0}},"@ethersproject/providers":{globals:{WebSocket:!0,clearInterval:!0,clearTimeout:!0,"console.log":!0,"console.warn":!0,setInterval:!0,setTimeout:!0},packages:{"@ethersproject/bignumber":!0,"@ethersproject/bytes":!0,"@ethersproject/providers>bech32":!0,"@ethersproject/transactions":!0,"ethers>@ethersproject/abstract-provider":!0,"ethers>@ethersproject/abstract-signer":!0,"ethers>@ethersproject/address":!0,"ethers>@ethersproject/base64":!0,"ethers>@ethersproject/basex":!0,"ethers>@ethersproject/constants":!0,"ethers>@ethersproject/hash":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/networks":!0,"ethers>@ethersproject/properties":!0,"ethers>@ethersproject/random":!0,"ethers>@ethersproject/sha2":!0,"ethers>@ethersproject/strings":!0,"ethers>@ethersproject/web":!0}},"@ethersproject/transactions":{packages:{"@ethersproject/bignumber":!0,"@ethersproject/bytes":!0,"ethers>@ethersproject/address":!0,"ethers>@ethersproject/constants":!0,"ethers>@ethersproject/keccak256":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/properties":!0,"ethers>@ethersproject/rlp":!0,"ethers>@ethersproject/signing-key":!0}},"@google/genai>protobufjs":{globals:{process:!0,setTimeout:!0},packages:{"@google/genai>protobufjs>@protobufjs/aspromise":!0,"@google/genai>protobufjs>@protobufjs/base64":!0,"@google/genai>protobufjs>@protobufjs/codegen":!0,"@google/genai>protobufjs>@protobufjs/eventemitter":!0,"@google/genai>protobufjs>@protobufjs/fetch":!0,"@google/genai>protobufjs>@protobufjs/float":!0,"@google/genai>protobufjs>@protobufjs/path":!0,"@google/genai>protobufjs>@protobufjs/pool":!0,"@google/genai>protobufjs>@protobufjs/utf8":!0,"@google/genai>protobufjs>long":!0}},"@google/genai>protobufjs>@protobufjs/codegen":{globals:{"console.log":!0}},"@google/genai>protobufjs>@protobufjs/fetch":{globals:{XMLHttpRequest:!0},packages:{"@google/genai>protobufjs>@protobufjs/aspromise":!0}},"@google/genai>protobufjs>long":{globals:{"WebAssembly.Instance":!0,"WebAssembly.Module":!0,define:!0}},"@hello-pangea/dnd":{globals:{"Element.prototype":!0,__REDUX_DEVTOOLS_EXTENSION_COMPOSE__:!0,addEventListener:!0,cancelAnimationFrame:!0,clearTimeout:!0,console:!0,document:!0,getComputedStyle:!0,pageXOffset:!0,pageYOffset:!0,removeEventListener:!0,requestAnimationFrame:!0,scrollBy:!0,setTimeout:!0},packages:{"@babel/runtime":!0,"@hello-pangea/dnd>css-box-model":!0,"@hello-pangea/dnd>memoize-one":!0,"@hello-pangea/dnd>raf-schd":!0,"@hello-pangea/dnd>react-redux":!0,"@hello-pangea/dnd>use-memo-one":!0,react:!0,"react-dom":!0,redux:!0}},"@hello-pangea/dnd>css-box-model":{globals:{getComputedStyle:!0,pageXOffset:!0,pageYOffset:!0},packages:{"@hello-pangea/dnd>css-box-model>tiny-invariant":!0}},"@hello-pangea/dnd>raf-schd":{globals:{cancelAnimationFrame:!0,requestAnimationFrame:!0}},"@hello-pangea/dnd>react-redux":{globals:{"console.warn":!0,document:!0},packages:{"@babel/runtime":!0,"@metamask/snap-simple-keyring-site>react-is":!0,"@tanstack/react-query>use-sync-external-store":!0,react:!0,"react-dom":!0,"react-redux>hoist-non-react-statics":!0}},"@hello-pangea/dnd>use-memo-one":{packages:{react:!0}},"@keystonehq/bc-ur-registry-eth":{globals:{"Buffer.from":!0},packages:{"@ethereumjs/tx>@ethereumjs/util":!0,"@keystonehq/bc-ur-registry-eth>@keystonehq/bc-ur-registry":!0,"@metamask/eth-qr-keyring>hdkey":!0,buffer:!0,uuid:!0}},"@keystonehq/bc-ur-registry-eth>@keystonehq/bc-ur-registry":{globals:{Buffer:!0,define:!0},packages:{"@ngraveio/bc-ur":!0,buffer:!0,"ethereumjs-util>ethereum-cryptography>bs58check":!0,tslib:!0}},"@lavamoat/lavadome-react":{globals:{Array:!0,Clipboard:!0,Document:!0,DocumentFragment:!0,Element:!0,Event:!0,EventTarget:!0,Function:!0,JSON:!0,NavigateEvent:!0,NavigationDestination:!0,Node:!0,Number:!0,Object:!0,String:!0,Weakmap:!0,"console.warn":!0,document:!0,navigation:!0},packages:{react:!0}},"@ledgerhq/errors":{globals:{"console.warn":!0}},"@ledgerhq/hw-app-eth":{globals:{"Buffer.alloc":!0,"Buffer.concat":!0,"Buffer.from":!0,"console.warn":!0},packages:{"@ethersproject/abi":!0,"@ethersproject/transactions":!0,"@ledgerhq/errors":!0,"@ledgerhq/hw-app-eth>@ledgerhq/cryptoassets-evm-signatures":!0,"@ledgerhq/hw-app-eth>@ledgerhq/domain-service":!0,"@ledgerhq/hw-app-eth>@ledgerhq/evm-tools":!0,"@ledgerhq/hw-app-eth>@ledgerhq/logs":!0,"@ledgerhq/hw-app-eth>bignumber.js":!0,buffer:!0,"ethers>@ethersproject/rlp":!0,semver:!0,"wait-on>axios":!0}},"@ledgerhq/hw-app-eth>@ledgerhq/domain-service":{packages:{"@ledgerhq/hw-app-eth>@ledgerhq/logs":!0,"wait-on>axios":!0}},"@ledgerhq/hw-app-eth>@ledgerhq/evm-tools":{packages:{"@ledgerhq/hw-app-eth>@ledgerhq/cryptoassets-evm-signatures":!0,"@ledgerhq/hw-app-eth>@ledgerhq/evm-tools>@ledgerhq/live-env":!0,"@metamask/ppom-validator>crypto-js":!0,"ethers>@ethersproject/constants":!0,"ethers>@ethersproject/hash":!0,"wait-on>axios":!0}},"@ledgerhq/hw-app-eth>@ledgerhq/evm-tools>@ledgerhq/live-env":{globals:{"console.warn":!0},packages:{"wait-on>rxjs":!0}},"@ledgerhq/hw-app-eth>@ledgerhq/logs":{globals:{__ledgerLogsListen:"write","console.error":!0}},"@ledgerhq/hw-app-eth>bignumber.js":{globals:{crypto:!0}},"@ledgerhq/hw-transport":{globals:{"Buffer.alloc":!0,"Buffer.concat":!0,"Buffer.from":!0,clearTimeout:!0,"console.warn":!0,setTimeout:!0},packages:{"@ledgerhq/errors":!0,"@ledgerhq/hw-app-eth>@ledgerhq/logs":!0,buffer:!0,"webpack>events":!0}},"@ledgerhq/hw-transport-webhid":{globals:{"Buffer.from":!0,navigator:!0},packages:{"@ledgerhq/errors":!0,"@ledgerhq/hw-app-eth>@ledgerhq/logs":!0,"@ledgerhq/hw-transport-webhid>@ledgerhq/devices":!0,"@ledgerhq/hw-transport-webhid>@ledgerhq/hw-transport":!0,buffer:!0}},"@ledgerhq/hw-transport-webhid>@ledgerhq/devices":{globals:{"Buffer.alloc":!0,"Buffer.concat":!0},packages:{"@ledgerhq/errors":!0,"@ledgerhq/hw-transport-webhid>@ledgerhq/devices>semver":!0,buffer:!0}},"@ledgerhq/hw-transport-webhid>@ledgerhq/devices>semver":{globals:{"console.error":!0,process:!0},packages:{process:!0}},"@ledgerhq/hw-transport-webhid>@ledgerhq/hw-transport":{globals:{"Buffer.alloc":!0,"Buffer.concat":!0,"Buffer.from":!0,clearTimeout:!0,"console.warn":!0,setTimeout:!0},packages:{"@ledgerhq/errors":!0,"@ledgerhq/hw-app-eth>@ledgerhq/logs":!0,buffer:!0,"webpack>events":!0}},"@metamask/abi-utils":{packages:{"@metamask/superstruct":!0,"@metamask/utils":!0}},"@metamask/account-api":{packages:{"@metamask/keyring-utils":!0}},"@metamask/account-tree-controller":{globals:{"console.warn":!0,setTimeout:!0},packages:{"@metamask/account-api":!0,"@metamask/accounts-controller":!0,"@metamask/base-controller":!0,"@metamask/keyring-api":!0,"@metamask/keyring-controller":!0,"@metamask/profile-sync-controller":!0,"@metamask/snaps-utils":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,"eslint>fast-deep-equal":!0}},"@metamask/accounts-controller":{globals:{"console.warn":!0},packages:{"@metamask/accounts-controller>ethereum-cryptography":!0,"@metamask/base-controller":!0,"@metamask/eth-snap-keyring":!0,"@metamask/keyring-api":!0,"@metamask/keyring-controller":!0,"@metamask/keyring-sdk":!0,"@metamask/keyring-utils":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,lodash:!0,uuid:!0}},"@metamask/accounts-controller>ethereum-cryptography":{globals:{TextDecoder:!0,crypto:!0,module:!0},packages:{"@metamask/accounts-controller>ethereum-cryptography>@noble/hashes":!0}},"@metamask/accounts-controller>ethereum-cryptography>@noble/hashes":{globals:{TextEncoder:!0}},"@metamask/address-book-controller":{packages:{"@metamask/base-controller":!0,"@metamask/controller-utils":!0}},"@metamask/analytics-controller":{packages:{"@metamask/base-controller":!0,"@metamask/utils":!0,lodash:!0,uuid:!0}},"@metamask/announcement-controller":{packages:{"@metamask/base-controller":!0}},"@metamask/approval-controller":{globals:{"console.info":!0},packages:{"@metamask/base-controller":!0,"@metamask/rpc-errors":!0,nanoid:!0}},"@metamask/assets-controller":{globals:{clearInterval:!0,clearTimeout:!0,"console.error":!0,"fetch.bind":!0,"performance.now":!0,setInterval:!0,setTimeout:!0},packages:{"@ethereumjs/tx>@ethereumjs/util":!0,"@ethersproject/abi":!0,"@ethersproject/providers":!0,"@metamask/assets-controller>bignumber.js":!0,"@metamask/assets-controller>p-limit":!0,"@metamask/assets-controllers":!0,"@metamask/base-controller":!0,"@metamask/client-controller":!0,"@metamask/controller-utils":!0,"@metamask/core-backend":!0,"@metamask/keyring-snap-client":!0,"@metamask/phishing-controller":!0,"@metamask/polling-controller":!0,"@metamask/snaps-utils":!0,"@metamask/utils":!0,"async-mutex":!0,lodash:!0}},"@metamask/assets-controller>bignumber.js":{globals:{crypto:!0}},"@metamask/assets-controller>p-limit":{packages:{"@metamask/assets-controller>p-limit>yocto-queue":!0}},"@metamask/assets-controllers":{globals:{AbortController:!0,"Intl.NumberFormat":!0,URL:!0,URLSearchParams:!0,clearInterval:!0,clearTimeout:!0,"console.error":!0,"console.log":!0,"console.warn":!0,fetch:!0,setInterval:!0,setTimeout:!0},packages:{"@ethereumjs/tx>@ethereumjs/util":!0,"@ethersproject/contracts":!0,"@ethersproject/providers":!0,"@metamask/account-api":!0,"@metamask/assets-controllers>@metamask/abi-utils":!0,"@metamask/assets-controllers>@tanstack/query-core":!0,"@metamask/assets-controllers>multiformats":!0,"@metamask/assets-controllers>single-call-balance-checker-abi":!0,"@metamask/base-controller":!0,"@metamask/contract-metadata":!0,"@metamask/controller-utils":!0,"@metamask/controller-utils>@metamask/eth-query":!0,"@metamask/keyring-api":!0,"@metamask/keyring-snap-client":!0,"@metamask/metamask-eth-abis":!0,"@metamask/phishing-controller":!0,"@metamask/polling-controller":!0,"@metamask/rpc-errors":!0,"@metamask/snaps-utils":!0,"@metamask/utils":!0,"async-mutex":!0,"ethereumjs-util>bn.js":!0,"ethers>@ethersproject/address":!0,immer:!0,lodash:!0,reselect:!0,uuid:!0}},"@metamask/assets-controllers>@metamask/abi-utils":{packages:{"@metamask/assets-controllers>@metamask/abi-utils>@metamask/utils":!0,"@metamask/superstruct":!0}},"@metamask/assets-controllers>@metamask/abi-utils>@metamask/utils":{globals:{Buffer:!0,TextDecoder:!0,TextEncoder:!0},packages:{"@metamask/superstruct":!0,"@metamask/utils>pony-cause":!0,"@noble/hashes":!0,"@scure/base":!0,buffer:!0,"nock>debug":!0,semver:!0}},"@metamask/assets-controllers>@tanstack/query-core":{globals:{AbortController:!0,addEventListener:!1,clearInterval:!0,clearTimeout:!0,"console.error":!0,document:!1,removeEventListener:!0,setInterval:!0,setTimeout:!0}},"@metamask/assets-controllers>multiformats":{globals:{TextDecoder:!0,TextEncoder:!0,"console.warn":!0,"crypto.subtle.digest":!0}},"@metamask/authenticated-user-storage":{globals:{fetch:!0},packages:{"@metamask/controller-utils":!0,"@metamask/react-data-query>@metamask/base-data-service":!0,"@metamask/superstruct":!0}},"@metamask/base-controller":{globals:{"console.error":!0},packages:{immer:!0}},"@metamask/bridge-controller":{globals:{AbortController:!0,"Buffer.from":!0,TextDecoder:!0,URLSearchParams:!0,"console.error":!0,"console.log":!0,"console.warn":!0},packages:{"@ethersproject/bignumber":!0,"@ethersproject/contracts":!0,"@ethersproject/providers":!0,"@metamask/bridge-controller>@metamask/multichain-network-controller":!0,"@metamask/bridge-controller>bignumber.js":!0,"@metamask/controller-utils":!0,"@metamask/keyring-api":!0,"@metamask/metamask-eth-abis":!0,"@metamask/multichain-network-controller":!0,"@metamask/polling-controller":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,buffer:!0,"ethers>@ethersproject/address":!0,"ethers>@ethersproject/constants":!0,lodash:!0,reselect:!0,uuid:!0}},"@metamask/bridge-controller>bignumber.js":{globals:{crypto:!0}},"@metamask/bridge-status-controller":{globals:{URLSearchParams:!0,clearInterval:!0,"console.error":!0,"console.warn":!0,fetch:!0,setInterval:!0,setTimeout:!0},packages:{"@metamask/bridge-controller":!0,"@metamask/bridge-status-controller>bignumber.js":!0,"@metamask/controller-utils":!0,"@metamask/keyring-controller":!0,"@metamask/polling-controller":!0,"@metamask/snaps-controllers":!0,"@metamask/superstruct":!0,"@metamask/transaction-controller":!0,"@metamask/utils":!0,uuid:!0}},"@metamask/bridge-status-controller>bignumber.js":{globals:{crypto:!0}},"@metamask/browser-passworder":{globals:{"Buffer.from":!0,CryptoKey:!0,btoa:!0,"crypto.getRandomValues":!0,"crypto.subtle.decrypt":!0,"crypto.subtle.deriveKey":!0,"crypto.subtle.encrypt":!0,"crypto.subtle.exportKey":!0,"crypto.subtle.importKey":!0},packages:{"@metamask/utils":!0,buffer:!0}},"@metamask/chain-agnostic-permission":{packages:{"@metamask/chain-agnostic-permission>@metamask/api-specs":!0,"@metamask/controller-utils":!0,"@metamask/permission-controller":!0,"@metamask/rpc-errors":!0,"@metamask/utils":!0,lodash:!0}},"@metamask/claims-controller":{packages:{"@metamask/base-controller":!0,"@metamask/claims-controller>@metamask/controller-utils":!0,"@metamask/utils":!0}},"@metamask/claims-controller>@metamask/controller-utils":{globals:{"Buffer.from":!0,URL:!0,"console.error":!0,fetch:!0,setTimeout:!0},packages:{"@metamask/controller-utils>@metamask/ethjs-unit":!0,"@metamask/controller-utils>@spruceid/siwe-parser":!0,"@metamask/utils":!0,buffer:!0,"eslint>fast-deep-equal":!0,"eth-ens-namehash":!0,"ethereumjs-util>bn.js":!0,lodash:!0}},"@metamask/client-controller":{packages:{"@metamask/base-controller":!0}},"@metamask/client-utils":{packages:{"@metamask/contract-metadata":!0,"@metamask/controller-utils":!0,"@metamask/keyring-api":!0,"@metamask/transaction-controller":!0,"@metamask/utils":!0}},"@metamask/compliance-controller":{globals:{URL:!0},packages:{"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/superstruct":!0,reselect:!0}},"@metamask/config-registry-controller":{globals:{fetch:!0},packages:{"@metamask/controller-utils":!0,"@metamask/polling-controller":!0,"@metamask/profile-sync-controller":!0,"@metamask/superstruct":!0,"@metamask/utils":!0}},"@metamask/controller-utils":{globals:{"Buffer.from":!0,URL:!0,"console.error":!0,fetch:!0,setTimeout:!0},packages:{"@ethersproject/abi":!0,"@metamask/controller-utils>@metamask/ethjs-unit":!0,"@metamask/controller-utils>@spruceid/siwe-parser":!0,"@metamask/utils":!0,buffer:!0,cockatiel:!0,"eslint>fast-deep-equal":!0,"eth-ens-namehash":!0,"ethereumjs-util>bn.js":!0,lodash:!0}},"@metamask/controller-utils>@metamask/eth-query":{packages:{"@metamask/ppom-validator>json-rpc-random-id":!0,"browserify>xtend":!0}},"@metamask/controller-utils>@metamask/ethjs-unit":{packages:{"@metamask/controller-utils>@metamask/ethjs-unit>@metamask/number-to-bn":!0,"ethereumjs-util>bn.js":!0}},"@metamask/controller-utils>@metamask/ethjs-unit>@metamask/number-to-bn":{packages:{"eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format>strip-hex-prefix":!0,"ethereumjs-util>bn.js":!0}},"@metamask/controller-utils>@spruceid/siwe-parser":{globals:{"console.error":!0,"console.log":!0},packages:{"@metamask/controller-utils>@spruceid/siwe-parser>apg-js":!0,"@noble/hashes":!0}},"@metamask/controller-utils>@spruceid/siwe-parser>apg-js":{packages:{buffer:!0}},"@metamask/core-backend":{globals:{URL:!0,WebSocket:!0,clearTimeout:!0,fetch:!0,setTimeout:!0},packages:{"@metamask/controller-utils":!0,"@metamask/core-backend>@tanstack/query-core":!0,"@metamask/utils":!0,cockatiel:!0,uuid:!0}},"@metamask/core-backend>@tanstack/query-core":{globals:{AbortController:!0,addEventListener:!1,clearInterval:!0,clearTimeout:!0,"console.error":!0,document:!1,removeEventListener:!0,setInterval:!0,setTimeout:!0}},"@metamask/delegation-controller":{packages:{"@metamask/base-controller":!0,"@metamask/delegation-controller>@metamask/keyring-controller":!0,"@metamask/utils":!0}},"@metamask/delegation-controller>@metamask/keyring-controller":{globals:{"console.error":!0},packages:{"@ethereumjs/tx>@ethereumjs/util":!0,"@metamask/base-controller":!0,"@metamask/eth-hd-keyring":!0,"@metamask/eth-sig-util":!0,"@metamask/keyring-controller>@metamask/eth-simple-keyring":!0,"@metamask/keyring-controller>ethereumjs-wallet":!0,"@metamask/keyring-controller>ulid":!0,"@metamask/utils":!0,"async-mutex":!0,lodash:!0}},"@metamask/delegation-core":{packages:{"@metamask/abi-utils":!0,"@metamask/utils":!0,"@noble/hashes":!0}},"@metamask/design-system-react":{globals:{"console.warn":!0,"document.addEventListener":!0,"document.body":!0,"document.removeEventListener":!0},packages:{"@metamask/design-system-react>@radix-ui/react-slot":!0,"@metamask/design-system-react>blo":!0,"@metamask/design-system-react>tailwind-merge":!0,"@metamask/design-system-shared":!0,"@metamask/jazzicon":!0,react:!0,"react-dom":!0,"react-focus-lock":!0}},"@metamask/design-system-react>@radix-ui/react-slot":{packages:{"@metamask/design-system-react>@radix-ui/react-slot>@radix-ui/react-compose-refs":!0,react:!0}},"@metamask/design-system-react>@radix-ui/react-slot>@radix-ui/react-compose-refs":{packages:{react:!0}},"@metamask/design-system-react>blo":{globals:{btoa:!0}},"@metamask/design-system-shared":{packages:{"@metamask/utils":!0,react:!0}},"@metamask/eip-5792-middleware":{packages:{"@metamask/eip-5792-middleware>@metamask/transaction-controller":!0,"@metamask/keyring-controller":!0,"@metamask/rpc-errors":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,lodash:!0,uuid:!0}},"@metamask/eip-7702-internal-rpc-middleware":{packages:{"@metamask/rpc-errors":!0,"@metamask/superstruct":!0,"@metamask/utils":!0}},"@metamask/ens-controller":{packages:{"@ethersproject/providers":!0,"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/utils":!0,punycode:!0}},"@metamask/eth-hd-keyring":{globals:{"Buffer.concat":!0,"Buffer.from":!0,"Buffer.isBuffer":!0,TextEncoder:!0},packages:{"@ethereumjs/tx>@ethereumjs/util":!0,"@metamask/eth-hd-keyring>ethereum-cryptography":!0,"@metamask/eth-hd-keyring>ethereum-cryptography>@scure/bip32":!0,"@metamask/eth-sig-util":!0,"@metamask/keyring-api":!0,"@metamask/keyring-sdk":!0,"@metamask/scure-bip39":!0,"@metamask/snaps-sdk>@metamask/key-tree":!0,"@metamask/utils":!0,buffer:!0}},"@metamask/eth-hd-keyring>ethereum-cryptography":{globals:{TextDecoder:!0,crypto:!0,module:!0},packages:{"@metamask/eth-hd-keyring>ethereum-cryptography>@noble/hashes":!0}},"@metamask/eth-hd-keyring>ethereum-cryptography>@noble/curves":{globals:{TextEncoder:!0},packages:{"@metamask/eth-hd-keyring>ethereum-cryptography>@noble/hashes":!0}},"@metamask/eth-hd-keyring>ethereum-cryptography>@noble/hashes":{globals:{TextEncoder:!0,crypto:!0}},"@metamask/eth-hd-keyring>ethereum-cryptography>@scure/bip32":{packages:{"@metamask/eth-hd-keyring>ethereum-cryptography>@noble/curves":!0,"@metamask/eth-hd-keyring>ethereum-cryptography>@noble/hashes":!0,"@metamask/eth-hd-keyring>ethereum-cryptography>@scure/bip32>@scure/base":!0}},"@metamask/eth-hd-keyring>ethereum-cryptography>@scure/bip32>@scure/base":{globals:{TextDecoder:!0,TextEncoder:!0}},"@metamask/eth-json-rpc-filters":{globals:{"console.error":!0},packages:{"@metamask/controller-utils>@metamask/eth-query":!0,"@metamask/json-rpc-engine":!0,"@metamask/safe-event-emitter":!0,"async-mutex":!0,pify:!0}},"@metamask/eth-json-rpc-middleware":{globals:{setTimeout:!0},packages:{"@metamask/eth-json-rpc-middleware>safe-stable-stringify":!0,"@metamask/eth-sig-util":!0,"@metamask/json-rpc-engine":!0,"@metamask/json-rpc-engine>klona":!0,"@metamask/rpc-errors":!0,"@metamask/superstruct":!0,"@metamask/utils":!0}},"@metamask/eth-json-rpc-provider":{packages:{"@metamask/json-rpc-engine":!0,nanoid:!0}},"@metamask/eth-ledger-bridge-keyring":{globals:{addEventListener:!0,"document.createElement":!0,"document.head.appendChild":!0,fetch:!0,removeEventListener:!0,setTimeout:!0},packages:{"@ethereumjs/tx":!0,"@ethereumjs/tx>@ethereumjs/rlp":!0,"@ethereumjs/tx>@ethereumjs/util":!0,"@ledgerhq/hw-transport":!0,"@metamask/eth-qr-keyring>hdkey":!0,"@metamask/eth-sig-util":!0,"@metamask/hw-wallet-sdk":!0,"@metamask/keyring-api":!0,"@metamask/keyring-sdk":!0,"@metamask/utils":!0,buffer:!0}},"@metamask/eth-qr-keyring":{globals:{"Buffer.concat":!0,"Buffer.from":!0},packages:{"@ethereumjs/tx":!0,"@ethereumjs/tx>@ethereumjs/rlp":!0,"@ethereumjs/tx>@ethereumjs/util":!0,"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth":!0,"@metamask/eth-qr-keyring>hdkey":!0,"@metamask/eth-qr-keyring>uuid":!0,"@metamask/keyring-api":!0,"@metamask/keyring-sdk":!0,"@metamask/utils":!0,buffer:!0}},"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth":{globals:{"Buffer.from":!0},packages:{"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util":!0,"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@keystonehq/bc-ur-registry":!0,"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>uuid":!0,"@metamask/eth-qr-keyring>hdkey":!0,buffer:!0}},"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util":{globals:{"Buffer.alloc":!0,"Buffer.allocUnsafe":!0,"Buffer.byteLength":!0,"Buffer.concat":!0,"Buffer.from":!0,"Buffer.isBuffer":!0,"console.warn":!0},packages:{"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>@ethereumjs/rlp":!0,"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography":!0,buffer:!0,"eth-lattice-keyring>@ethereumjs/util>micro-ftch":!0,"webpack>events":!0}},"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>@ethereumjs/rlp":{globals:{TextEncoder:!0}},"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography":{globals:{TextDecoder:!0,crypto:!0},packages:{"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography>@noble/curves":!0,"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography>@noble/hashes":!0}},"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography>@noble/curves":{globals:{TextEncoder:!0},packages:{"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography>@noble/hashes":!0}},"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography>@noble/hashes":{globals:{TextEncoder:!0,crypto:!0}},"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>@keystonehq/bc-ur-registry":{globals:{Buffer:!0,define:!0},packages:{"@ngraveio/bc-ur":!0,buffer:!0,"ethereumjs-util>ethereum-cryptography>bs58check":!0,tslib:!0}},"@metamask/eth-qr-keyring>@keystonehq/bc-ur-registry-eth>uuid":{globals:{crypto:!0,msCrypto:!0}},"@metamask/eth-qr-keyring>hdkey":{packages:{"@ngraveio/bc-ur>assert":!0,"crypto-browserify":!0,"ethereumjs-util>create-hash>ripemd160":!0,"ethereumjs-util>ethereum-cryptography>bs58check":!0,"ethereumjs-util>ethereum-cryptography>secp256k1":!0,"mockttp>express>safe-buffer":!0}},"@metamask/eth-qr-keyring>uuid":{globals:{crypto:!0}},"@metamask/eth-sig-util":{globals:{"Buffer.byteLength":!0,"Buffer.concat":!0,"Buffer.from":!0},packages:{"@metamask/abi-utils":!0,"@metamask/eth-sig-util>@ethereumjs/rlp":!0,"@metamask/eth-sig-util>@ethereumjs/util":!0,"@metamask/eth-sig-util>@scure/base":!0,"@metamask/eth-sig-util>ethereum-cryptography":!0,"@metamask/utils":!0,buffer:!0,tweetnacl:!0}},"@metamask/eth-sig-util>@ethereumjs/rlp":{globals:{TextEncoder:!0}},"@metamask/eth-sig-util>@ethereumjs/util":{globals:{"Buffer.alloc":!0,"Buffer.allocUnsafe":!0,"Buffer.byteLength":!0,"Buffer.concat":!0,"Buffer.from":!0,"Buffer.isBuffer":!0,"console.warn":!0},packages:{"@metamask/eth-sig-util>@ethereumjs/rlp":!0,"@metamask/eth-sig-util>ethereum-cryptography":!0,buffer:!0,"eth-lattice-keyring>@ethereumjs/util>micro-ftch":!0,"webpack>events":!0}},"@metamask/eth-sig-util>@scure/base":{globals:{TextDecoder:!0,TextEncoder:!0}},"@metamask/eth-sig-util>ethereum-cryptography":{globals:{TextDecoder:!0,crypto:!0},packages:{"@metamask/eth-sig-util>ethereum-cryptography>@noble/curves":!0,"@metamask/eth-sig-util>ethereum-cryptography>@noble/hashes":!0}},"@metamask/eth-sig-util>ethereum-cryptography>@noble/curves":{globals:{TextEncoder:!0},packages:{"@metamask/eth-sig-util>ethereum-cryptography>@noble/hashes":!0}},"@metamask/eth-sig-util>ethereum-cryptography>@noble/hashes":{globals:{TextEncoder:!0,crypto:!0}},"@metamask/eth-snap-keyring":{globals:{URL:!0,"console.error":!0,"console.info":!0,"console.warn":!0},packages:{"@ethereumjs/tx":!0,"@metamask/eth-sig-util":!0,"@metamask/eth-snap-keyring>@metamask/keyring-internal-snap-client":!0,"@metamask/eth-snap-keyring>@metamask/keyring-snap-sdk":!0,"@metamask/eth-snap-keyring>uuid":!0,"@metamask/keyring-api":!0,"@metamask/keyring-internal-api":!0,"@metamask/keyring-sdk":!0,"@metamask/keyring-utils":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,"async-mutex":!0}},"@metamask/eth-snap-keyring>@metamask/keyring-internal-snap-client":{packages:{"@metamask/keyring-api":!0,"@metamask/keyring-internal-api":!0,"@metamask/keyring-snap-client":!0,"@metamask/keyring-utils":!0}},"@metamask/eth-snap-keyring>@metamask/keyring-snap-sdk":{packages:{"@metamask/superstruct":!0}},"@metamask/eth-snap-keyring>uuid":{globals:{crypto:!0}},"@metamask/eth-token-tracker":{globals:{"console.warn":!0},packages:{"@babel/runtime":!0,"@ethersproject/bignumber":!0,"@ethersproject/contracts":!0,"@ethersproject/providers":!0,"@metamask/eth-token-tracker>@metamask/eth-block-tracker":!0,"@metamask/eth-token-tracker>deep-equal":!0,"@metamask/safe-event-emitter":!0,"ethereumjs-util>bn.js":!0,"human-standard-token-abi":!0}},"@metamask/eth-token-tracker>@metamask/eth-block-tracker":{globals:{clearTimeout:!0,"console.error":!0,setTimeout:!0},packages:{"@metamask/ppom-validator>json-rpc-random-id":!0,"@metamask/safe-event-emitter":!0,"@metamask/utils":!0}},"@metamask/eth-token-tracker>deep-equal":{packages:{"@lavamoat/webpack>json-stable-stringify>isarray":!0,"@lavamoat/webpack>json-stable-stringify>object-keys":!0,"@metamask/eth-token-tracker>deep-equal>es-get-iterator":!0,"@metamask/eth-token-tracker>deep-equal>is-date-object":!0,"@metamask/eth-token-tracker>deep-equal>which-boxed-primitive":!0,"@metamask/eth-token-tracker>deep-equal>which-collection":!0,"@ngraveio/bc-ur>assert>object-is":!0,"browserify>util>is-arguments":!0,"browserify>util>which-typed-array":!0,"gulp>vinyl-fs>object.assign":!0,"string.prototype.matchall>call-bind":!0,"string.prototype.matchall>es-abstract>array-buffer-byte-length":!0,"string.prototype.matchall>es-abstract>is-array-buffer":!0,"string.prototype.matchall>es-abstract>is-regex":!0,"string.prototype.matchall>es-abstract>is-shared-array-buffer":!0,"string.prototype.matchall>get-intrinsic":!0,"string.prototype.matchall>regexp.prototype.flags":!0,"string.prototype.matchall>side-channel":!0}},"@metamask/eth-token-tracker>deep-equal>es-get-iterator":{globals:{process:!0},packages:{"@lavamoat/webpack>json-stable-stringify>isarray":!0,"@metamask/eth-token-tracker>deep-equal>es-get-iterator>is-map":!0,"browserify>util>is-arguments":!0,"eslint-plugin-react>array-includes>is-string":!0,process:!0,"string.prototype.matchall>call-bind":!0,"string.prototype.matchall>es-abstract>is-set":!0,"string.prototype.matchall>es-abstract>stop-iteration-iterator":!0,"string.prototype.matchall>get-intrinsic":!0,"string.prototype.matchall>has-symbols":!0}},"@metamask/eth-token-tracker>deep-equal>is-date-object":{packages:{"jsdom>form-data>es-set-tostringtag>has-tostringtag":!0,"string.prototype.matchall>call-bound":!0}},"@metamask/eth-token-tracker>deep-equal>which-boxed-primitive":{packages:{"@metamask/eth-token-tracker>deep-equal>which-boxed-primitive>is-bigint":!0,"@metamask/eth-token-tracker>deep-equal>which-boxed-primitive>is-boolean-object":!0,"@metamask/eth-token-tracker>deep-equal>which-boxed-primitive>is-number-object":!0,"eslint-plugin-react>array-includes>is-string":!0,"string.prototype.matchall>es-abstract>es-to-primitive>is-symbol":!0}},"@metamask/eth-token-tracker>deep-equal>which-boxed-primitive>is-bigint":{packages:{"string.prototype.matchall>es-abstract>unbox-primitive>has-bigints":!0}},"@metamask/eth-token-tracker>deep-equal>which-boxed-primitive>is-boolean-object":{packages:{"jsdom>form-data>es-set-tostringtag>has-tostringtag":!0,"string.prototype.matchall>call-bound":!0}},"@metamask/eth-token-tracker>deep-equal>which-boxed-primitive>is-number-object":{packages:{"jsdom>form-data>es-set-tostringtag>has-tostringtag":!0,"string.prototype.matchall>call-bound":!0}},"@metamask/eth-token-tracker>deep-equal>which-collection":{packages:{"@metamask/eth-token-tracker>deep-equal>es-get-iterator>is-map":!0,"@metamask/eth-token-tracker>deep-equal>which-collection>is-weakmap":!0,"@metamask/eth-token-tracker>deep-equal>which-collection>is-weakset":!0,"string.prototype.matchall>es-abstract>is-set":!0}},"@metamask/eth-token-tracker>deep-equal>which-collection>is-weakset":{packages:{"string.prototype.matchall>call-bound":!0,"string.prototype.matchall>get-intrinsic":!0}},"@metamask/eth-trezor-keyring":{globals:{"Buffer.from":!0,setTimeout:!0},packages:{"@ethereumjs/tx":!0,"@ethereumjs/tx>@ethereumjs/util":!0,"@metamask/eth-qr-keyring>hdkey":!0,"@metamask/eth-sig-util":!0,"@metamask/eth-trezor-keyring>@trezor/connect-plugin-ethereum":!0,"@metamask/hw-wallet-sdk":!0,"@metamask/keyring-api":!0,"@metamask/keyring-sdk":!0,"@metamask/utils":!0,buffer:!0}},"@metamask/eth-trezor-keyring>@trezor/connect-plugin-ethereum":{packages:{"@metamask/eth-sig-util":!0,tslib:!0}},"@metamask/etherscan-link":{globals:{URL:!0}},"@metamask/gas-fee-controller":{globals:{clearInterval:!0,"console.error":!0,setInterval:!0},packages:{"@metamask/controller-utils":!0,"@metamask/controller-utils>@metamask/eth-query":!0,"@metamask/polling-controller":!0,"ethereumjs-util>bn.js":!0,uuid:!0}},"@metamask/gator-permissions-controller":{globals:{clearTimeout:!0,setTimeout:!0},packages:{"@metamask/base-controller":!0,"@metamask/delegation-core":!0,"@metamask/delegation-deployments":!0,"@metamask/gator-permissions-controller>@metamask/abi-utils":!0,"@metamask/gator-permissions-controller>@metamask/transaction-controller":!0,"@metamask/snaps-utils":!0,"@metamask/utils":!0}},"@metamask/gator-permissions-controller>@metamask/abi-utils":{packages:{"@metamask/gator-permissions-controller>@metamask/abi-utils>@metamask/utils":!0,"@metamask/superstruct":!0}},"@metamask/gator-permissions-controller>@metamask/abi-utils>@metamask/utils":{globals:{Buffer:!0,TextDecoder:!0,TextEncoder:!0},packages:{"@metamask/superstruct":!0,"@metamask/utils>pony-cause":!0,"@noble/hashes":!0,"@scure/base":!0,buffer:!0,"nock>debug":!0,semver:!0}},"@metamask/geolocation-controller":{globals:{fetch:!0},packages:{"@metamask/base-controller":!0,"@metamask/geolocation-controller>@metamask/controller-utils":!0}},"@metamask/geolocation-controller>@metamask/controller-utils":{globals:{"Buffer.from":!0,"console.error":!0,fetch:!0,setTimeout:!0},packages:{"@metamask/controller-utils>@metamask/ethjs-unit":!0,"@metamask/utils":!0,buffer:!0,cockatiel:!0,"eslint>fast-deep-equal":!0,"eth-ens-namehash":!0,"ethereumjs-util>bn.js":!0,lodash:!0}},"@metamask/jazzicon":{globals:{"document.createElement":!0,"document.createElementNS":!0},packages:{"@metamask/jazzicon>color":!0,"@metamask/jazzicon>mersenne-twister":!0}},"@metamask/jazzicon>color":{packages:{"@metamask/jazzicon>color>clone":!0,"@metamask/jazzicon>color>color-convert":!0,"@metamask/jazzicon>color>color-string":!0}},"@metamask/jazzicon>color>clone":{globals:{Buffer:!0},packages:{buffer:!0}},"@metamask/jazzicon>color>color-convert":{packages:{"@metamask/jazzicon>color>color-convert>color-name":!0}},"@metamask/jazzicon>color>color-string":{packages:{"jest-canvas-mock>moo-color>color-name":!0}},"@metamask/json-rpc-engine":{packages:{"@metamask/json-rpc-engine>klona":!0,"@metamask/messenger":!0,"@metamask/rpc-errors":!0,"@metamask/safe-event-emitter":!0,"@metamask/utils":!0,"deep-freeze-strict":!0}},"@metamask/json-rpc-middleware-stream":{globals:{"console.warn":!0,setTimeout:!0},packages:{"@metamask/json-rpc-middleware-stream>readable-stream":!0,"@metamask/safe-event-emitter":!0,"@metamask/utils":!0}},"@metamask/json-rpc-middleware-stream>readable-stream":{globals:{"process.nextTick":!0,"process.stderr":!0,"process.stdout":!0},packages:{"@storybook/react>util-deprecate":!0,"browserify>string_decoder":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"webpack>events":!0}},"@metamask/keyring-api":{packages:{"@metamask/keyring-utils":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,"bitcoin-address-validation":!0}},"@metamask/keyring-controller":{globals:{"console.error":!0},packages:{"@ethereumjs/tx>@ethereumjs/util":!0,"@metamask/base-controller":!0,"@metamask/eth-hd-keyring":!0,"@metamask/eth-sig-util":!0,"@metamask/keyring-controller>@metamask/eth-simple-keyring":!0,"@metamask/keyring-controller>ethereumjs-wallet":!0,"@metamask/keyring-controller>ulid":!0,"@metamask/utils":!0,"async-mutex":!0,lodash:!0}},"@metamask/keyring-controller>@metamask/eth-simple-keyring":{globals:{"Buffer.concat":!0,"Buffer.from":!0},packages:{"@ethereumjs/tx>@ethereumjs/util":!0,"@metamask/eth-sig-util":!0,"@metamask/keyring-api":!0,"@metamask/keyring-controller>@metamask/eth-simple-keyring>ethereum-cryptography":!0,"@metamask/keyring-sdk":!0,"@metamask/utils":!0,buffer:!0,"crypto-browserify>randombytes":!0}},"@metamask/keyring-controller>@metamask/eth-simple-keyring>ethereum-cryptography":{globals:{TextDecoder:!0,crypto:!0,module:!0},packages:{"@metamask/keyring-controller>@metamask/eth-simple-keyring>ethereum-cryptography>@noble/hashes":!0}},"@metamask/keyring-controller>@metamask/eth-simple-keyring>ethereum-cryptography>@noble/hashes":{globals:{TextEncoder:!0}},"@metamask/keyring-controller>ethereumjs-wallet":{globals:{"Buffer.alloc":!0,"Buffer.concat":!0,"Buffer.from":!0,"Buffer.isBuffer":!0},packages:{"@metamask/keyring-controller>ethereumjs-wallet>ethereum-cryptography":!0,"@metamask/keyring-controller>ethereumjs-wallet>ethereumjs-util":!0,"@metamask/keyring-controller>ethereumjs-wallet>utf8":!0,buffer:!0,"crypto-browserify":!0,"crypto-browserify>randombytes":!0,"eth-lattice-keyring>gridplus-sdk>aes-js":!0,"ethereumjs-util>ethereum-cryptography>bs58check":!0,"ethers>@ethersproject/json-wallets>scrypt-js":!0,uuid:!0}},"@metamask/keyring-controller>ethereumjs-wallet>ethereum-cryptography":{globals:{"Buffer.concat":!0,"Buffer.from":!0,"Buffer.isBuffer":!0},packages:{"@ngraveio/bc-ur>assert":!0,buffer:!0,"crypto-browserify>create-hmac":!0,"crypto-browserify>randombytes":!0,"ethereumjs-util>ethereum-cryptography>bs58check":!0,"ethereumjs-util>ethereum-cryptography>keccak":!0,"ethereumjs-util>ethereum-cryptography>secp256k1":!0,"ethers>@ethersproject/sha2>hash.js":!0,"mockttp>express>safe-buffer":!0}},"@metamask/keyring-controller>ethereumjs-wallet>ethereumjs-util":{globals:{Buffer:!0},packages:{"@metamask/keyring-controller>ethereumjs-wallet>ethereum-cryptography":!0,"@ngraveio/bc-ur>assert":!0,buffer:!0,"ethereumjs-util>bn.js":!0,"ethereumjs-util>create-hash":!0,"ethereumjs-util>rlp":!0}},"@metamask/keyring-controller>ulid":{globals:{"console.error":!0,crypto:!0,require:!0}},"@metamask/keyring-internal-api":{packages:{"@metamask/keyring-api":!0,"@metamask/superstruct":!0}},"@metamask/keyring-sdk":{packages:{"@ethereumjs/tx":!0,"@metamask/eth-sig-util":!0,"@metamask/keyring-api":!0,"@metamask/keyring-sdk>ethereum-cryptography":!0,"@metamask/keyring-sdk>uuid":!0,"@metamask/keyring-utils":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,"async-mutex":!0}},"@metamask/keyring-sdk>ethereum-cryptography":{globals:{TextDecoder:!0,crypto:!0,module:!0},packages:{"@metamask/keyring-sdk>ethereum-cryptography>@noble/hashes":!0}},"@metamask/keyring-sdk>ethereum-cryptography>@noble/hashes":{globals:{TextEncoder:!0}},"@metamask/keyring-sdk>uuid":{globals:{crypto:!0}},"@metamask/keyring-snap-client":{packages:{"@metamask/keyring-api":!0,"@metamask/keyring-snap-client>uuid":!0,"@metamask/keyring-utils":!0,"@metamask/superstruct":!0}},"@metamask/keyring-snap-client>uuid":{globals:{crypto:!0}},"@metamask/keyring-utils":{globals:{URL:!0},packages:{"@metamask/superstruct":!0,"@metamask/utils":!0,"bitcoin-address-validation":!0}},"@metamask/logging-controller":{packages:{"@metamask/base-controller":!0,uuid:!0}},"@metamask/logo":{globals:{addEventListener:!0,"document.body.appendChild":!0,"document.createElementNS":!0,innerHeight:!0,innerWidth:!0,requestAnimationFrame:!0},packages:{"@metamask/logo>gl-mat4":!0,"@metamask/logo>gl-vec3":!0}},"@metamask/message-manager":{globals:{"Buffer.from":!0},packages:{"@metamask/base-controller":!0,"@metamask/message-manager>@metamask/controller-utils":!0,"@metamask/utils":!0,buffer:!0,uuid:!0,"webpack>events":!0}},"@metamask/message-manager>@metamask/controller-utils":{globals:{"Buffer.from":!0,"console.error":!0,fetch:!0,setTimeout:!0},packages:{"@metamask/controller-utils>@metamask/ethjs-unit":!0,"@metamask/utils":!0,buffer:!0,"eslint>fast-deep-equal":!0,"eth-ens-namehash":!0,"ethereumjs-util>bn.js":!0,lodash:!0}},"@metamask/message-manager>jsonschema":{packages:{"browserify>url":!0}},"@metamask/messenger":{globals:{"console.error":!0}},"@metamask/mobile-wallet-protocol-core":{globals:{"Buffer.from":!0,"console.warn":!0,setImmediate:!0,setTimeout:!0},packages:{"@metamask/mobile-wallet-protocol-core>centrifuge":!0,"@metamask/mobile-wallet-protocol-core>eventemitter3":!0,"@metamask/mobile-wallet-protocol-core>uuid":!0,"async-mutex":!0,buffer:!0,"core-js-pure":!0}},"@metamask/mobile-wallet-protocol-core>centrifuge":{globals:{AbortController:!1,Event:!1,EventSource:!1,EventTarget:!1,MessageEvent:!1,ReadableStream:!1,SockJS:!1,SuppressedError:!1,TextDecoder:!0,TextEncoder:!0,URL:!1,WebSocket:!0,WebTransport:!1,addEventListener:!0,clearTimeout:!0,console:!1,"console.warn":!0,document:!1,fetch:!1,localStorage:!1,setTimeout:!0}},"@metamask/mobile-wallet-protocol-core>uuid":{globals:{crypto:!0}},"@metamask/mobile-wallet-protocol-dapp-client":{globals:{clearTimeout:!0,setTimeout:!0},packages:{"@metamask/mobile-wallet-protocol-core":!0,"@metamask/mobile-wallet-protocol-dapp-client>@metamask/utils":!0,"@metamask/mobile-wallet-protocol-dapp-client>uuid":!0}},"@metamask/mobile-wallet-protocol-dapp-client>@metamask/utils":{globals:{Buffer:!0,TextDecoder:!0,TextEncoder:!0},packages:{"@metamask/superstruct":!0,"@scure/base":!0,buffer:!0}},"@metamask/mobile-wallet-protocol-dapp-client>uuid":{globals:{crypto:!0}},"@metamask/multichain-account-service":{globals:{clearTimeout:!0,"console.error":!0,"console.warn":!0,"performance.now":!0,setTimeout:!0},packages:{"@ethereumjs/tx>@ethereumjs/util":!0,"@metamask/account-api":!0,"@metamask/eth-snap-keyring":!0,"@metamask/keyring-api":!0,"@metamask/keyring-controller":!0,"@metamask/keyring-snap-client":!0,"@metamask/snaps-utils":!0,"@metamask/utils":!0,"async-mutex":!0}},"@metamask/multichain-api-middleware":{globals:{"console.error":!0},packages:{"@metamask/chain-agnostic-permission":!0,"@metamask/controller-utils":!0,"@metamask/eth-json-rpc-filters":!0,"@metamask/json-rpc-engine":!0,"@metamask/message-manager>jsonschema":!0,"@metamask/multichain-api-middleware>@metamask/api-specs":!0,"@metamask/permission-controller":!0,"@metamask/rpc-errors":!0,"@metamask/safe-event-emitter":!0,"@metamask/utils":!0,"@open-rpc/schema-utils-js":!0}},"@metamask/multichain-network-controller":{globals:{URL:!0},packages:{"@metamask/base-controller":!0,"@metamask/keyring-api":!0,"@metamask/multichain-network-controller>@metamask/keyring-api":!0,"@metamask/network-controller":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,lodash:!0}},"@metamask/multichain-transactions-controller":{globals:{"console.error":!0},packages:{"@metamask/base-controller":!0,"@metamask/keyring-api":!0,"@metamask/keyring-snap-client":!0,"@metamask/snaps-utils":!0}},"@metamask/name-controller":{globals:{fetch:!0},packages:{"@metamask/base-controller":!0,"@metamask/name-controller>@metamask/controller-utils":!0,"@metamask/utils":!0,"async-mutex":!0}},"@metamask/name-controller>@metamask/controller-utils":{globals:{"Buffer.from":!0,"console.error":!0,fetch:!0,setTimeout:!0},packages:{"@metamask/controller-utils>@metamask/ethjs-unit":!0,"@metamask/utils":!0,buffer:!0,"eslint>fast-deep-equal":!0,"eth-ens-namehash":!0,"ethereumjs-util>bn.js":!0,lodash:!0}},"@metamask/network-controller":{globals:{"Intl.NumberFormat":!0,URL:!0,"btoa.bind":!0,"fetch.bind":!0,setTimeout:!0},packages:{"@metamask/base-controller":!0,"@metamask/connectivity-controller":!0,"@metamask/controller-utils":!0,"@metamask/controller-utils>@metamask/eth-query":!0,"@metamask/eth-json-rpc-middleware":!0,"@metamask/eth-json-rpc-provider":!0,"@metamask/json-rpc-engine":!0,"@metamask/network-controller>@metamask/eth-block-tracker":!0,"@metamask/network-controller>@metamask/eth-json-rpc-infura":!0,"@metamask/network-controller>@metamask/swappable-obj-proxy":!0,"@metamask/rpc-errors":!0,"@metamask/utils":!0,"addons-linter>deepmerge":!0,cockatiel:!0,"eslint>fast-deep-equal":!0,immer:!0,lodash:!0,reselect:!0,"uri-js":!0,uuid:!0}},"@metamask/network-controller>@metamask/eth-block-tracker":{globals:{clearTimeout:!0,"console.error":!0,setTimeout:!0},packages:{"@metamask/ppom-validator>json-rpc-random-id":!0,"@metamask/safe-event-emitter":!0,"@metamask/utils":!0}},"@metamask/network-controller>@metamask/eth-json-rpc-infura":{globals:{fetch:!0,setTimeout:!0},packages:{"@metamask/json-rpc-engine":!0,"@metamask/network-controller>@metamask/eth-json-rpc-infura>@metamask/eth-json-rpc-provider":!0,"@metamask/rpc-errors":!0,"@metamask/utils":!0}},"@metamask/network-controller>@metamask/eth-json-rpc-infura>@metamask/eth-json-rpc-provider":{packages:{"@metamask/json-rpc-engine":!0,"@metamask/rpc-errors":!0,"@metamask/safe-event-emitter":!0,uuid:!0}},"@metamask/network-enablement-controller":{packages:{"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/keyring-api":!0,"@metamask/multichain-network-controller":!0,"@metamask/snaps-utils>@metamask/slip44":!0,"@metamask/utils":!0}},"@metamask/notification-services-controller":{globals:{"Intl.NumberFormat":!0,addEventListener:!0,"console.error":!0,fetch:!0,registration:!0,removeEventListener:!0},packages:{"@metamask/authenticated-user-storage":!0,"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/notification-services-controller>@contentful/rich-text-html-renderer":!0,"@metamask/notification-services-controller>bignumber.js":!0,"@metamask/notification-services-controller>firebase":!0,"@metamask/utils":!0,lodash:!0,loglevel:!0,semver:!0,uuid:!0}},"@metamask/notification-services-controller>@contentful/rich-text-html-renderer":{globals:{SuppressedError:!0}},"@metamask/notification-services-controller>bignumber.js":{globals:{crypto:!0}},"@metamask/notification-services-controller>firebase":{packages:{"@metamask/notification-services-controller>firebase>@firebase/app":!0,"@metamask/notification-services-controller>firebase>@firebase/messaging":!0}},"@metamask/notification-services-controller>firebase>@firebase/app":{globals:{FinalizationRegistry:!0,"console.warn":!0},packages:{"@metamask/notification-services-controller>firebase>@firebase/app>@firebase/component":!0,"@metamask/notification-services-controller>firebase>@firebase/app>@firebase/logger":!0,"@metamask/notification-services-controller>firebase>@firebase/app>idb":!0,"@metamask/notification-services-controller>firebase>@firebase/util":!0}},"@metamask/notification-services-controller>firebase>@firebase/app>@firebase/component":{packages:{"@metamask/notification-services-controller>firebase>@firebase/util":!0}},"@metamask/notification-services-controller>firebase>@firebase/app>@firebase/logger":{globals:{console:!0}},"@metamask/notification-services-controller>firebase>@firebase/app>idb":{globals:{DOMException:!0,IDBCursor:!0,IDBDatabase:!0,IDBIndex:!0,IDBObjectStore:!0,IDBRequest:!0,IDBTransaction:!0,"indexedDB.deleteDatabase":!0,"indexedDB.open":!0}},"@metamask/notification-services-controller>firebase>@firebase/installations":{globals:{BroadcastChannel:!0,Headers:!0,btoa:!0,"console.error":!0,crypto:!0,fetch:!0,msCrypto:!0,"navigator.onLine":!0,setTimeout:!0},packages:{"@metamask/notification-services-controller>firebase>@firebase/app":!0,"@metamask/notification-services-controller>firebase>@firebase/app>@firebase/component":!0,"@metamask/notification-services-controller>firebase>@firebase/app>idb":!0,"@metamask/notification-services-controller>firebase>@firebase/util":!0}},"@metamask/notification-services-controller>firebase>@firebase/messaging":{globals:{Headers:!0,"Notification.maxActions":!0,"Notification.permission":!0,"Notification.requestPermission":!0,"PushSubscription.prototype.hasOwnProperty":!0,ServiceWorkerRegistration:!0,URL:!0,addEventListener:!0,atob:!0,btoa:!0,clearTimeout:!0,"clients.matchAll":!0,"clients.openWindow":!0,"console.warn":!0,document:!0,fetch:!0,indexedDB:!0,"location.href":!0,"location.origin":!0,navigator:!0,"origin.replace":!0,"registration.showNotification":!0,setTimeout:!0},packages:{"@metamask/notification-services-controller>firebase>@firebase/app":!0,"@metamask/notification-services-controller>firebase>@firebase/app>@firebase/component":!0,"@metamask/notification-services-controller>firebase>@firebase/app>idb":!0,"@metamask/notification-services-controller>firebase>@firebase/installations":!0,"@metamask/notification-services-controller>firebase>@firebase/util":!0}},"@metamask/notification-services-controller>firebase>@firebase/util":{globals:{WorkerGlobalScope:!0,atob:!0,browser:!0,btoa:!0,chrome:!0,console:!0,document:!0,indexedDB:!0,navigator:!0,process:!0,setTimeout:!0},packages:{process:!0}},"@metamask/object-multiplex":{globals:{"console.warn":!0},packages:{"@metamask/object-multiplex>once":!0,"@metamask/object-multiplex>readable-stream":!0}},"@metamask/object-multiplex>once":{packages:{"@metamask/object-multiplex>once>wrappy":!0}},"@metamask/object-multiplex>readable-stream":{globals:{"process.nextTick":!0,"process.stderr":!0,"process.stdout":!0},packages:{"@storybook/react>util-deprecate":!0,"browserify>string_decoder":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"webpack>events":!0}},"@metamask/obs-store":{packages:{"@metamask/obs-store>readable-stream":!0,"@metamask/safe-event-emitter":!0}},"@metamask/obs-store>readable-stream":{globals:{"process.nextTick":!0,"process.stderr":!0,"process.stdout":!0},packages:{"@storybook/react>util-deprecate":!0,"browserify>string_decoder":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"webpack>events":!0}},"@metamask/passkey-controller":{globals:{TextDecoder:!0,TextEncoder:!0,"crypto.subtle.importKey":!0,"crypto.subtle.verify":!0},packages:{"@metamask/base-controller":!0,"@metamask/passkey-controller>@levischuck/tiny-cbor":!0,"@metamask/utils":!0,"@noble/ciphers":!0,"@noble/curves":!0,"@noble/hashes":!0}},"@metamask/passkey-controller>@levischuck/tiny-cbor":{globals:{TextDecoder:!0,TextEncoder:!0}},"@metamask/permission-controller":{globals:{"console.error":!0},packages:{"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/json-rpc-engine":!0,"@metamask/messenger":!0,"@metamask/rpc-errors":!0,"@metamask/utils":!0,"deep-freeze-strict":!0,immer:!0,nanoid:!0}},"@metamask/permission-log-controller":{packages:{"@metamask/base-controller":!0,"@metamask/utils":!0}},"@metamask/perps-controller":{globals:{AbortController:!0,WebSocket:!0,clearInterval:!0,clearTimeout:!0,fetch:!0,"performance.now":!0,setInterval:!0,setTimeout:!0},packages:{"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/perps-controller>@metamask/abi-utils":!0,"@metamask/perps-controller>@nktkas/hyperliquid":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,uuid:!0}},"@metamask/perps-controller>@metamask/abi-utils":{packages:{"@metamask/perps-controller>@metamask/abi-utils>@metamask/utils":!0,"@metamask/superstruct":!0}},"@metamask/perps-controller>@metamask/abi-utils>@metamask/utils":{globals:{Buffer:!0,TextDecoder:!0,TextEncoder:!0},packages:{"@metamask/superstruct":!0,"@metamask/utils>pony-cause":!0,"@noble/hashes":!0,"@scure/base":!0,buffer:!0,"nock>debug":!0,semver:!0}},"@metamask/perps-controller>@nktkas/hyperliquid":{globals:{AbortController:!0,AbortSignal:!0,CustomEvent:!0,DOMException:!0,Event:!0,EventTarget:!0,Headers:!0,TextEncoder:!0,URL:!0,clearInterval:!0,fetch:!0,setInterval:!0,setTimeout:!0},packages:{"@metamask/perps-controller>@nktkas/hyperliquid>@nktkas/rews":!0,"@metamask/perps-controller>@nktkas/hyperliquid>@noble/hashes":!0,"@metamask/perps-controller>@nktkas/hyperliquid>valibot":!0}},"@metamask/perps-controller>@nktkas/hyperliquid>@nktkas/rews":{globals:{AbortController:!0,CloseEvent:!0,CustomEvent:!0,Event:!0,EventTarget:!0,MessageEvent:!0,WebSocket:!0,clearTimeout:!0,setTimeout:!0}},"@metamask/perps-controller>@nktkas/hyperliquid>@noble/hashes":{globals:{TextEncoder:!0,crypto:!0}},"@metamask/perps-controller>@nktkas/hyperliquid>valibot":{globals:{Blob:!0,File:!0,"Intl.Segmenter":!0,TextEncoder:!0,URL:!0}},"@metamask/phishing-controller":{globals:{TextEncoder:!0,URL:!0,"console.error":!0,"console.warn":!0,fetch:!0},packages:{"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/phishing-controller>ethereum-cryptography":!0,"@metamask/transaction-controller":!0,"@noble/hashes":!0,punycode:!0,"webpack-cli>fastest-levenshtein":!0}},"@metamask/phishing-controller>ethereum-cryptography":{globals:{TextDecoder:!0,crypto:!0,module:!0},packages:{"@metamask/phishing-controller>ethereum-cryptography>@noble/hashes":!0}},"@metamask/phishing-controller>ethereum-cryptography>@noble/hashes":{globals:{TextEncoder:!0}},"@metamask/polling-controller":{globals:{clearTimeout:!0,"console.error":!0,setTimeout:!0},packages:{"@metamask/base-controller":!0,"fast-json-stable-stringify":!0,uuid:!0}},"@metamask/post-message-stream":{globals:{"MessageEvent.prototype":!0,WorkerGlobalScope:!0,addEventListener:!0,browser:!0,chrome:!0,"location.origin":!0,postMessage:!0,removeEventListener:!0},packages:{"@metamask/post-message-stream>readable-stream":!0,"@metamask/utils":!0}},"@metamask/post-message-stream>readable-stream":{globals:{"process.nextTick":!0,"process.stderr":!0,"process.stdout":!0},packages:{"@storybook/react>util-deprecate":!0,"browserify>string_decoder":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"webpack>events":!0}},"@metamask/ppom-validator":{globals:{"Buffer.from":!0,URL:!0,"console.error":!0,crypto:!0},packages:{"@metamask/base-controller":!0,"@metamask/ppom-validator>@metamask/controller-utils":!0,"@metamask/ppom-validator>await-semaphore":!0,"@metamask/ppom-validator>crypto-js":!0,"@metamask/ppom-validator>json-rpc-random-id":!0,"@toruslabs/eccrypto>elliptic":!0,buffer:!0}},"@metamask/ppom-validator>@metamask/controller-utils":{globals:{"Buffer.from":!0,URL:!0,"console.error":!0,fetch:!0,setTimeout:!0},packages:{"@metamask/controller-utils>@metamask/ethjs-unit":!0,"@metamask/controller-utils>@spruceid/siwe-parser":!0,"@metamask/utils":!0,buffer:!0,cockatiel:!0,"eslint>fast-deep-equal":!0,"eth-ens-namehash":!0,"ethereumjs-util>bn.js":!0,lodash:!0}},"@metamask/ppom-validator>await-semaphore":{globals:{process:!0,setImmediate:!0},packages:{"core-js-pure":!0,process:!0}},"@metamask/ppom-validator>crypto-js":{globals:{crypto:!0,define:!0,msCrypto:!0}},"@metamask/profile-metrics-controller":{globals:{URL:!0,"console.error":!0},packages:{"@metamask/controller-utils":!0,"@metamask/polling-controller":!0,"@metamask/profile-sync-controller":!0,"@metamask/snaps-utils":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,"async-mutex":!0,uuid:!0}},"@metamask/profile-sync-controller":{globals:{"Buffer.from":!0,Event:!0,TextDecoder:!0,TextEncoder:!0,URL:!0,URLSearchParams:!0,addEventListener:!0,atob:!0,"console.error":!0,"console.warn":!0,dispatchEvent:!0,fetch:!0,removeEventListener:!0,setTimeout:!0},packages:{"@metamask/base-controller":!0,"@metamask/keyring-controller":!0,"@metamask/profile-sync-controller>siwe":!0,"@noble/ciphers":!0,"@noble/hashes":!0,buffer:!0}},"@metamask/profile-sync-controller>siwe":{globals:{"console.error":!0,"console.warn":!0},packages:{"@metamask/controller-utils>@spruceid/siwe-parser>valid-url":!0,"@metamask/profile-sync-controller>siwe>@spruceid/siwe-parser":!0,"@metamask/profile-sync-controller>siwe>@stablelib/random":!0,ethers:!0}},"@metamask/profile-sync-controller>siwe>@spruceid/siwe-parser":{globals:{"console.error":!0,"console.log":!0},packages:{"@metamask/controller-utils>@spruceid/siwe-parser>apg-js":!0,"@noble/hashes":!0}},"@metamask/profile-sync-controller>siwe>@stablelib/random":{globals:{crypto:!0,msCrypto:!0},packages:{"@metamask/profile-sync-controller>siwe>@stablelib/random>@stablelib/binary":!0,"@metamask/profile-sync-controller>siwe>@stablelib/random>@stablelib/wipe":!0}},"@metamask/profile-sync-controller>siwe>@stablelib/random>@stablelib/binary":{packages:{"@metamask/profile-sync-controller>siwe>@stablelib/random>@stablelib/binary>@stablelib/int":!0}},"@metamask/providers":{globals:{console:!0},packages:{"@metamask/json-rpc-engine":!0,"@metamask/json-rpc-middleware-stream":!0,"@metamask/providers>is-stream":!0,"@metamask/providers>readable-stream":!0,"@metamask/rpc-errors":!0,"@metamask/safe-event-emitter":!0,"eslint>fast-deep-equal":!0}},"@metamask/providers>readable-stream":{globals:{"process.nextTick":!0,"process.stderr":!0,"process.stdout":!0},packages:{"@storybook/react>util-deprecate":!0,"browserify>string_decoder":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"webpack>events":!0}},"@metamask/ramps-controller":{globals:{AbortController:!0,URL:!0,clearInterval:!0,setInterval:!0},packages:{"@metamask/base-controller":!0,"@metamask/controller-utils":!0,cockatiel:!0}},"@metamask/rate-limit-controller":{globals:{setTimeout:!0},packages:{"@metamask/base-controller":!0,"@metamask/rpc-errors":!0,"@metamask/utils":!0}},"@metamask/react-data-query":{packages:{"@metamask/utils":!0,"@tanstack/react-query>@tanstack/query-core":!0}},"@metamask/react-data-query>@metamask/base-data-service":{packages:{"@metamask/controller-utils":!0,"@metamask/messenger":!0,"@metamask/utils":!0,"@tanstack/react-query>@tanstack/query-core":!0,"eslint>fast-deep-equal":!0}},"@metamask/remote-feature-flag-controller":{globals:{TextEncoder:!0},packages:{"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/utils":!0,uuid:!0}},"@metamask/rpc-errors":{packages:{"@metamask/rpc-errors>fast-safe-stringify":!0,"@metamask/utils":!0}},"@metamask/safe-event-emitter":{globals:{setTimeout:!0},packages:{"webpack>events":!0}},"@metamask/scure-bip39":{globals:{TextEncoder:!0},packages:{"@metamask/scure-bip39>@noble/hashes":!0,"@metamask/scure-bip39>@scure/base":!0}},"@metamask/scure-bip39>@noble/hashes":{globals:{TextEncoder:!0,crypto:!0}},"@metamask/scure-bip39>@scure/base":{globals:{TextDecoder:!0,TextEncoder:!0}},"@metamask/seedless-onboarding-controller":{packages:{"@metamask/base-controller":!0,"@metamask/seedless-onboarding-controller>@metamask/auth-network-utils":!0,"@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup":!0,"@metamask/utils":!0,"@noble/ciphers":!0,"@noble/curves":!0,"async-mutex":!0}},"@metamask/seedless-onboarding-controller>@metamask/auth-network-utils":{globals:{"Buffer.from":!0,clearTimeout:!0,setTimeout:!0},packages:{"@noble/hashes":!0,buffer:!0,"eslint>json-stable-stringify-without-jsonify":!0,"ethereumjs-util>bn.js":!0}},"@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup":{globals:{Buffer:!0,URL:!0,"console.error":!0,fetch:!0},packages:{"@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@metamask/auth-network-utils":!0,"@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@toruslabs/fetch-node-details":!0,"@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@toruslabs/http-helpers":!0,"@noble/ciphers":!0,"@noble/curves":!0,"@noble/hashes":!0,"@toruslabs/eccrypto":!0,buffer:!0,"ethereumjs-util>bn.js":!0}},"@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@metamask/auth-network-utils":{globals:{"Buffer.concat":!0,"Buffer.from":!0,clearTimeout:!0,setTimeout:!0},packages:{"@noble/curves":!0,"@noble/hashes":!0,"@toruslabs/eccrypto>elliptic":!0,buffer:!0,"eslint>json-stable-stringify-without-jsonify":!0,"ethereumjs-util>bn.js":!0}},"@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@toruslabs/fetch-node-details":{packages:{"@babel/runtime":!0,"@metamask/seedless-onboarding-controller>@metamask/auth-network-utils>@toruslabs/constants":!0,"@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@toruslabs/fetch-node-details>@toruslabs/fnd-base":!0,"@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@toruslabs/fetch-node-details>@toruslabs/http-helpers":!0,loglevel:!0}},"@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@toruslabs/fetch-node-details>@toruslabs/fnd-base":{packages:{"@metamask/seedless-onboarding-controller>@metamask/auth-network-utils>@toruslabs/constants":!0}},"@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@toruslabs/fetch-node-details>@toruslabs/http-helpers":{globals:{URL:!0,clearTimeout:!0,fetch:!0,setTimeout:!0},packages:{"@babel/runtime":!0,"addons-linter>deepmerge":!0,loglevel:!0}},"@metamask/seedless-onboarding-controller>@metamask/toprf-secure-backup>@toruslabs/http-helpers":{globals:{URL:!0,clearTimeout:!0,fetch:!0,setTimeout:!0},packages:{"@babel/runtime":!0,"addons-linter>deepmerge":!0,loglevel:!0}},"@metamask/selected-network-controller":{packages:{"@metamask/base-controller":!0,"@metamask/network-controller>@metamask/swappable-obj-proxy":!0}},"@metamask/shield-controller":{globals:{AbortController:!0},packages:{"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/shield-controller>@metamask/transaction-controller":!0,"@metamask/signature-controller":!0,"@metamask/utils":!0,cockatiel:!0,lodash:!0}},"@metamask/signature-controller":{globals:{"Buffer.from":!0,fetch:!0},packages:{"@metamask/approval-controller":!0,"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/eth-sig-util":!0,"@metamask/keyring-controller":!0,"@metamask/logging-controller":!0,"@metamask/message-manager>jsonschema":!0,"@metamask/utils":!0,buffer:!0,uuid:!0,"webpack>events":!0}},"@metamask/smart-transactions-controller":{globals:{URLSearchParams:!0,clearInterval:!0,"console.error":!0,"console.log":!0,fetch:!0,setInterval:!0},packages:{"@ethersproject/bytes":!0,"@ethersproject/transactions":!0,"@metamask/controller-utils":!0,"@metamask/controller-utils>@metamask/eth-query":!0,"@metamask/polling-controller":!0,"@metamask/smart-transactions-controller>@metamask/transaction-controller":!0,"@metamask/smart-transactions-controller>bignumber.js":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,"ethers>@ethersproject/keccak256":!0,lodash:!0,reselect:!0}},"@metamask/smart-transactions-controller>bignumber.js":{globals:{crypto:!0}},"@metamask/snap-account-service":{globals:{"console.error":!0},packages:{"@metamask/eth-snap-keyring":!0,"@metamask/eth-snap-keyring>@metamask/keyring-snap-sdk":!0,"@metamask/keyring-api":!0,"@metamask/keyring-controller":!0,"@metamask/utils":!0,lodash:!0}},"@metamask/snaps-controllers":{globals:{DecompressionStream:!0,URL:!0,WebSocket:!0,clearTimeout:!0,"document.getElementById":!0,"fetch.bind":!0,setTimeout:!0},packages:{"@metamask/approval-controller":!0,"@metamask/base-controller":!0,"@metamask/json-rpc-engine":!0,"@metamask/json-rpc-middleware-stream":!0,"@metamask/object-multiplex":!0,"@metamask/permission-controller":!0,"@metamask/post-message-stream":!0,"@metamask/rpc-errors":!0,"@metamask/snaps-controllers>@xstate/fsm":!0,"@metamask/snaps-controllers>concat-stream":!0,"@metamask/snaps-controllers>get-npm-tarball-url":!0,"@metamask/snaps-controllers>readable-stream":!0,"@metamask/snaps-controllers>readable-web-to-node-stream":!0,"@metamask/snaps-controllers>tar-stream":!0,"@metamask/snaps-registry":!0,"@metamask/snaps-rpc-methods":!0,"@metamask/snaps-sdk":!0,"@metamask/snaps-utils":!0,"@metamask/utils":!0,"async-mutex":!0,"cron-parser":!0,"eslint>fast-deep-equal":!0,immer:!0,luxon:!0,nanoid:!0,semver:!0}},"@metamask/snaps-controllers>concat-stream":{globals:{"Buffer.concat":!0,"Buffer.isBuffer":!0},packages:{"@metamask/snaps-controllers>readable-stream":!0,"browserify>concat-stream>buffer-from":!0,"browserify>concat-stream>typedarray":!0,buffer:!0,"duplexify>inherits":!0}},"@metamask/snaps-controllers>readable-stream":{globals:{"process.nextTick":!0,"process.stderr":!0,"process.stdout":!0},packages:{"@storybook/react>util-deprecate":!0,"browserify>string_decoder":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"webpack>events":!0}},"@metamask/snaps-controllers>readable-web-to-node-stream":{packages:{"@metamask/snaps-controllers>readable-web-to-node-stream>readable-stream":!0}},"@metamask/snaps-controllers>readable-web-to-node-stream>readable-stream":{globals:{"process.nextTick":!0,"process.stderr":!0,"process.stdout":!0},packages:{"@storybook/react>util-deprecate":!0,"browserify>string_decoder":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"webpack>events":!0}},"@metamask/snaps-controllers>tar-stream":{packages:{"@metamask/snaps-controllers>tar-stream>b4a":!0,"@metamask/snaps-controllers>tar-stream>fast-fifo":!0,"@metamask/snaps-controllers>tar-stream>streamx":!0}},"@metamask/snaps-controllers>tar-stream>b4a":{globals:{TextDecoder:!0,TextEncoder:!0}},"@metamask/snaps-controllers>tar-stream>streamx":{packages:{"@metamask/snaps-controllers>tar-stream>fast-fifo":!0,"@metamask/snaps-controllers>tar-stream>streamx>queue-tick":!0,"webpack>events":!0}},"@metamask/snaps-controllers>tar-stream>streamx>queue-tick":{globals:{queueMicrotask:!0}},"@metamask/snaps-execution-environments":{globals:{"document.getElementById":!0},packages:{"@metamask/post-message-stream":!0,"@metamask/snaps-utils":!0,"@metamask/utils":!0}},"@metamask/snaps-registry":{globals:{crypto:!0},packages:{"@metamask/superstruct":!0,"@metamask/utils":!0,"@noble/curves":!0,"@noble/hashes":!0}},"@metamask/snaps-rpc-methods":{packages:{"@metamask/json-rpc-engine":!0,"@metamask/permission-controller":!0,"@metamask/rpc-errors":!0,"@metamask/snaps-sdk":!0,"@metamask/snaps-sdk>@metamask/key-tree":!0,"@metamask/snaps-utils":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,"@noble/hashes":!0,"async-mutex":!0}},"@metamask/snaps-sdk":{globals:{URL:!0},packages:{"@metamask/rpc-errors":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,luxon:!0}},"@metamask/snaps-sdk>@metamask/key-tree":{globals:{"crypto.subtle":!0,ed25519:!0,ed25519Bip32:!0,secp256k1:!0},packages:{"@metamask/scure-bip39":!0,"@metamask/utils":!0,"@noble/curves":!0,"@noble/hashes":!0,"@scure/base":!0}},"@metamask/snaps-utils":{globals:{File:!0,FileReader:!0,TextDecoder:!0,TextEncoder:!0,URL:!0,"console.error":!0,"console.log":!0,"console.warn":!0,"document.body.appendChild":!0,"document.createElement":!0,fetch:!0,navigator:!0},packages:{"@metamask/permission-controller":!0,"@metamask/rpc-errors":!0,"@metamask/snaps-sdk":!0,"@metamask/snaps-sdk>@metamask/key-tree":!0,"@metamask/snaps-utils>@metamask/slip44":!0,"@metamask/snaps-utils>fast-xml-parser":!0,"@metamask/snaps-utils>marked":!0,"@metamask/snaps-utils>rfdc":!0,"@metamask/snaps-utils>validate-npm-package-name":!0,"@metamask/superstruct":!0,"@metamask/utils":!0,"@scure/base":!0,chalk:!0,"cron-parser":!0,"fast-json-stable-stringify":!0,luxon:!0,semver:!0}},"@metamask/snaps-utils>fast-xml-parser":{globals:{"exports.isExist":!0},packages:{"@metamask/snaps-utils>fast-xml-parser>@nodable/entities":!0,"@metamask/snaps-utils>fast-xml-parser>path-expression-matcher":!0,"@metamask/snaps-utils>fast-xml-parser>strnum":!0}},"@metamask/snaps-utils>marked":{globals:{"console.error":!0,"console.warn":!0}},"@metamask/snaps-utils>rfdc":{globals:{Buffer:!0},packages:{buffer:!0}},"@metamask/snaps-utils>validate-npm-package-name":{packages:{"@metamask/snaps-utils>validate-npm-package-name>builtins":!0}},"@metamask/snaps-utils>validate-npm-package-name>builtins":{globals:{"process.version":!0},packages:{process:!0,semver:!0}},"@metamask/storage-service":{globals:{"console.error":!0,"console.warn":!0}},"@metamask/subscription-controller":{globals:{URL:!0},packages:{"@metamask/polling-controller":!0,"@metamask/subscription-controller>@metamask/transaction-controller":!0,"@metamask/subscription-controller>bignumber.js":!0,"@metamask/utils":!0}},"@metamask/subscription-controller>bignumber.js":{globals:{crypto:!0}},"@metamask/transaction-controller":{globals:{"Buffer.from":!0,clearInterval:!0,clearTimeout:!0,"console.error":!0,fetch:!0,setInterval:!0,setTimeout:!0},packages:{"@ethereumjs/tx":!0,"@ethereumjs/tx>@ethereumjs/common":!0,"@ethersproject/abi":!0,"@ethersproject/contracts":!0,"@ethersproject/providers":!0,"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/gas-fee-controller":!0,"@metamask/metamask-eth-abis":!0,"@metamask/network-controller":!0,"@metamask/rpc-errors":!0,"@metamask/transaction-controller>@metamask/nonce-tracker":!0,"@metamask/transaction-controller>bignumber.js":!0,"@metamask/utils":!0,"async-mutex":!0,buffer:!0,"eth-method-registry":!0,"ethereumjs-util>bn.js":!0,"ethers>@ethersproject/wallet":!0,lodash:!0,uuid:!0,"webpack>events":!0}},"@metamask/transaction-controller>@metamask/nonce-tracker":{packages:{"@ethersproject/providers":!0,"@metamask/transaction-controller>@metamask/nonce-tracker>async-mutex":!0,"@ngraveio/bc-ur>assert":!0}},"@metamask/transaction-controller>@metamask/nonce-tracker>async-mutex":{globals:{clearTimeout:!0,setTimeout:!0},packages:{tslib:!0}},"@metamask/transaction-controller>bignumber.js":{globals:{crypto:!0}},"@metamask/transaction-pay-controller":{globals:{AbortController:!0,URLSearchParams:!0,clearTimeout:!0,fetch:!0,setTimeout:!0},packages:{"@ethersproject/abi":!0,"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/keyring-controller":!0,"@metamask/metamask-eth-abis":!0,"@metamask/network-controller":!0,"@metamask/transaction-controller":!0,"@metamask/transaction-pay-controller>@metamask/ramps-controller":!0,"@metamask/transaction-pay-controller>bignumber.js":!0,"@metamask/utils":!0,lodash:!0}},"@metamask/transaction-pay-controller>@metamask/ramps-controller":{globals:{URL:!0},packages:{"@metamask/controller-utils":!0}},"@metamask/transaction-pay-controller>bignumber.js":{globals:{crypto:!0}},"@metamask/user-operation-controller":{globals:{fetch:!0},packages:{"@metamask/base-controller":!0,"@metamask/controller-utils":!0,"@metamask/controller-utils>@metamask/eth-query":!0,"@metamask/gas-fee-controller":!0,"@metamask/polling-controller":!0,"@metamask/rpc-errors":!0,"@metamask/superstruct":!0,"@metamask/user-operation-controller>@metamask/transaction-controller":!0,"@metamask/utils":!0,"ethereumjs-util>bn.js":!0,lodash:!0,uuid:!0,"webpack>events":!0}},"@metamask/utils":{globals:{Buffer:!0,TextDecoder:!0,TextEncoder:!0,crypto:!0},packages:{"@metamask/superstruct":!0,"@metamask/utils>pony-cause":!0,"@noble/hashes":!0,"@scure/base":!0,buffer:!0,lodash:!0,"nock>debug":!0,semver:!0}},"@metamask/wallet":{packages:{"@metamask/accounts-controller":!0,"@metamask/address-book-controller":!0,"@metamask/approval-controller":!0,"@metamask/browser-passworder":!0,"@metamask/controller-utils":!0,"@metamask/keyring-controller":!0,"@metamask/messenger":!0,"@metamask/network-controller":!0,"@metamask/remote-feature-flag-controller":!0,"@metamask/storage-service":!0,"@metamask/transaction-controller":!0,"@metamask/utils":!0,"@metamask/wallet>@metamask/connectivity-controller":!0}},"@metamask/wallet>@metamask/connectivity-controller":{packages:{"@metamask/base-controller":!0}},"@mui/material":{globals:{CSS:!0,DocumentFragment:!0,IntersectionObserver:!0,MutationObserver:!0,ResizeObserver:!0,addEventListener:!0,cancelAnimationFrame:!0,clearInterval:!0,clearTimeout:!0,"console.error":!0,"console.warn":!0,"document.activeElement":!0,"document.body":!0,getSelection:!0,navigator:!0,"performance.now":!0,removeEventListener:!0,requestAnimationFrame:!0,setInterval:!0,setTimeout:!0},packages:{"@babel/runtime":!0,"@emotion/react":!0,"@mui/material>react-is":!0,"@mui/system":!0,"@mui/system>@mui/utils":!0,clsx:!0,"prop-types":!0,react:!0,"react-dom":!0,"react-transition-group":!0}},"@mui/system":{globals:{"console.error":!0,"console.warn":!0,"document.createElement":!0,"document.querySelector":!0,matchMedia:!0},packages:{"@babel/runtime":!0,"@emotion/react":!0,"@mui/system>@mui/private-theming":!0,"@mui/system>@mui/styled-engine":!0,"@mui/system>@mui/utils":!0,"prop-types":!0,react:!0}},"@mui/system>@mui/private-theming":{globals:{"console.error":!0},packages:{"@babel/runtime":!0,"@mui/system>@mui/utils":!0,"prop-types":!0,react:!0}},"@mui/system>@mui/styled-engine":{globals:{"console.error":!0,document:!0},packages:{"@emotion/react":!0,"@emotion/react>@emotion/cache":!0,"@emotion/react>@emotion/serialize":!0,"@emotion/styled":!0,"prop-types":!0,react:!0}},"@mui/system>@mui/utils":{globals:{clearTimeout:!0,"console.error":!0,document:!0,innerWidth:!0,setTimeout:!0},packages:{"@babel/runtime":!0,"@mui/system>@mui/utils>react-is":!0,clsx:!0,react:!0}},"@mui/x-date-pickers":{globals:{Intl:!0,Range:!0,addEventListener:!0,clearTimeout:!0,"console.error":!0,"console.warn":!0,document:!0,innerHeight:!0,navigator:!0,orientation:!0,removeEventListener:!0,screen:!0,setTimeout:!0},packages:{"@babel/runtime":!0,"@mui/material":!0,"@mui/system":!0,"@mui/x-date-pickers>@mui/utils":!0,"@mui/x-date-pickers>@mui/x-internals":!0,clsx:!0,luxon:!0,"prop-types":!0,react:!0,"react-transition-group":!0}},"@mui/x-date-pickers>@mui/utils":{globals:{URL:!0,"console.error":!0},packages:{clsx:!0,"prop-types":!0,react:!0}},"@ngraveio/bc-ur":{globals:{"Buffer.alloc":!0,"Buffer.allocUnsafe":!0,"Buffer.concat":!0,"Buffer.from":!0,"Buffer.isBuffer":!0},packages:{"@ngraveio/bc-ur>@keystonehq/alias-sampling":!0,"@ngraveio/bc-ur>assert":!0,"@ngraveio/bc-ur>bignumber.js":!0,"@ngraveio/bc-ur>cbor-sync":!0,"@ngraveio/bc-ur>crc":!0,"@ngraveio/bc-ur>jsbi":!0,"@ngraveio/bc-ur>sha.js":!0,buffer:!0}},"@ngraveio/bc-ur>assert":{globals:{console:!0,"process.emitWarning":!0,"process.stderr":!0},packages:{"@ngraveio/bc-ur>assert>is-nan":!0,"@ngraveio/bc-ur>assert>object-is":!0,"browserify>util":!0,"gulp>vinyl-fs>object.assign":!0,process:!0,"string.prototype.matchall>call-bind":!0}},"@ngraveio/bc-ur>assert>is-nan":{packages:{"string.prototype.matchall>call-bind":!0,"string.prototype.matchall>define-properties":!0}},"@ngraveio/bc-ur>assert>object-is":{packages:{"string.prototype.matchall>call-bind":!0,"string.prototype.matchall>define-properties":!0}},"@ngraveio/bc-ur>bignumber.js":{globals:{crypto:!0,define:!0}},"@ngraveio/bc-ur>cbor-sync":{globals:{Buffer:!0,define:!0},packages:{buffer:!0}},"@ngraveio/bc-ur>crc":{packages:{"@ngraveio/bc-ur>crc>buffer":!0}},"@ngraveio/bc-ur>crc>buffer":{globals:{console:!0},packages:{"base64-js":!0,"buffer>ieee754":!0}},"@ngraveio/bc-ur>jsbi":{globals:{define:!0}},"@ngraveio/bc-ur>sha.js":{packages:{"@ngraveio/bc-ur>sha.js>to-buffer":!0,"duplexify>inherits":!0,"mockttp>express>safe-buffer":!0}},"@ngraveio/bc-ur>sha.js>to-buffer":{packages:{"@lavamoat/webpack>json-stable-stringify>isarray":!0,"mockttp>express>safe-buffer":!0,"string.prototype.matchall>es-abstract>typed-array-buffer":!0}},"@noble/ciphers":{globals:{TextDecoder:!0,TextEncoder:!0,crypto:!0}},"@noble/curves":{packages:{"@noble/hashes":!0}},"@noble/hashes":{globals:{TextDecoder:!0,TextEncoder:!0,crypto:!0}},"@open-rpc/schema-utils-js":{packages:{"@metamask/rpc-errors>fast-safe-stringify":!0,"@open-rpc/meta-schema":!0,"@open-rpc/schema-utils-js>@json-schema-tools/dereferencer":!0,"@open-rpc/schema-utils-js>@json-schema-tools/meta-schema":!0,"@open-rpc/schema-utils-js>@json-schema-tools/reference-resolver":!0,"@open-rpc/schema-utils-js>is-url":!0,"eslint>ajv":!0}},"@open-rpc/schema-utils-js>@json-schema-tools/dereferencer":{packages:{"@metamask/rpc-errors>fast-safe-stringify":!0,"@open-rpc/schema-utils-js>@json-schema-tools/dereferencer>@json-schema-tools/traverse":!0,"@open-rpc/schema-utils-js>@json-schema-tools/reference-resolver":!0}},"@open-rpc/schema-utils-js>@json-schema-tools/reference-resolver":{packages:{"@open-rpc/schema-utils-js>@json-schema-tools/reference-resolver>@json-schema-spec/json-pointer":!0,"@open-rpc/test-coverage>isomorphic-fetch":!0}},"@open-rpc/test-coverage>isomorphic-fetch":{globals:{"fetch.bind":!0},packages:{"@open-rpc/test-coverage>isomorphic-fetch>whatwg-fetch":!0}},"@open-rpc/test-coverage>isomorphic-fetch>whatwg-fetch":{globals:{AbortController:!0,Blob:!0,DOMException:!0,FileReader:!0,FormData:!0,"URLSearchParams.prototype.isPrototypeOf":!0,XMLHttpRequest:!0,"console.warn":!0,fetch:!0,setTimeout:!0}},"@popperjs/core":{globals:{Element:!0,HTMLElement:!0,ShadowRoot:!0,devicePixelRatio:!0,document:!0,"navigator.userAgent":!0,"navigator.userAgentData":!0}},"@reduxjs/toolkit":{globals:{AbortController:!0,__REDUX_DEVTOOLS_EXTENSION_COMPOSE__:!0,__REDUX_DEVTOOLS_EXTENSION__:!0,console:!0,process:!0,queueMicrotask:!0,requestAnimationFrame:!0,setTimeout:!0},packages:{"@reduxjs/toolkit>reselect":!0,immer:!0,process:!0,redux:!0,"redux-thunk":!0}},"@rive-app/react-canvas":{globals:{IntersectionObserver:!0,ResizeObserver:!0,addEventListener:!0,clearTimeout:!0,"console.error":!0,devicePixelRatio:!0,"document.documentElement.clientHeight":!0,"document.documentElement.clientWidth":!0,innerHeight:!0,innerWidth:!0,matchMedia:!0,removeEventListener:!0,setTimeout:!0},packages:{"@rive-app/react-canvas>@rive-app/canvas":!0,react:!0}},"@rive-app/react-canvas>@rive-app/canvas":{globals:{AudioContext:!1,Blob:!0,DOMMatrix:!1,FinalizationRegistry:!1,HTMLCanvasElement:!0,Image:!0,Iterator:!1,MouseEvent:!1,Path2D:!0,Request:!0,ResizeObserver:!1,TextDecoder:!0,"URL.createObjectURL":!0,"URL.revokeObjectURL":!0,WebAssembly:!0,XMLHttpRequest:!1,cancelAnimationFrame:!0,clearInterval:!0,clearTimeout:!0,console:!0,crypto:!1,define:!1,devicePixelRatio:!0,document:!1,"document.createElement":!0,fetch:!1,h:!1,importScripts:!1,location:!1,navigator:!1,"navigator.userAgent":!0,"performance.now":!0,prompt:!1,readline:!1,requestAnimationFrame:!0,setTimeout:!0,webkitAudioContext:!1}},"@scure/base":{globals:{TextDecoder:!0,TextEncoder:!0}},"@segment/analytics-node":{globals:{AbortController:!0,EdgeRuntime:!1,URL:!0,WebSocketPair:!1,WorkerGlobalScope:!1,clearTimeout:!0,"console.warn":!0,fetch:!0,importScripts:!1,process:!0,setTimeout:!0},packages:{"@segment/analytics-node>@lukeed/uuid":!0,"@segment/analytics-node>@segment/analytics-core":!0,"@segment/analytics-node>@segment/analytics-generic-utils":!0,"@segment/analytics-node>jose":!0,process:!0}},"@segment/analytics-node>@segment/analytics-core":{globals:{clearTimeout:!0,console:!0,setTimeout:!0},packages:{"@segment/analytics-node>@lukeed/uuid":!0,"@segment/analytics-node>@segment/analytics-core>dset":!0,"@segment/analytics-node>@segment/analytics-generic-utils":!0,tslib:!0}},"@segment/analytics-node>@segment/analytics-generic-utils":{globals:{"console.warn":!0}},"@segment/analytics-node>jose":{globals:{CryptoKey:!0,TextDecoder:!0,TextEncoder:!0,atob:!0,btoa:!0,crypto:!0}},"@sentry/browser":{globals:{"PerformanceObserver.supportedEntryTypes":!0,Request:!0,URL:!0,"XMLHttpRequest.prototype":!0,__SENTRY_DEBUG__:!0,__SENTRY_RELEASE__:!0,addEventListener:!0,"console.error":!0,"indexedDB.open":!0,"performance.timeOrigin":!0,setTimeout:!0},packages:{"@sentry/browser>@sentry-internal/browser-utils":!0,"@sentry/browser>@sentry-internal/feedback":!0,"@sentry/browser>@sentry-internal/replay":!0,"@sentry/browser>@sentry-internal/replay-canvas":!0,"@sentry/browser>@sentry/core":!0,"@sentry/utils":!0}},"@sentry/browser>@sentry-internal/browser-utils":{globals:{"PerformanceEventTiming.prototype":!0,PerformanceObserver:!0,"XMLHttpRequest.prototype":!0,__SENTRY_DEBUG__:!0,addEventListener:!0,clearTimeout:!0,performance:!0,removeEventListener:!0,setTimeout:!0},packages:{"@sentry/browser>@sentry/core":!0,"@sentry/utils":!0}},"@sentry/browser>@sentry-internal/feedback":{globals:{FormData:!0,HTMLFormElement:!0,__SENTRY_DEBUG__:!0,cancelAnimationFrame:!0,clearTimeout:!0,"document.createElement":!0,"document.createElementNS":!0,"document.createTextNode":!0,isSecureContext:!0,requestAnimationFrame:!0,setTimeout:!0},packages:{"@sentry/browser>@sentry/core":!0,"@sentry/utils":!0}},"@sentry/browser>@sentry-internal/replay":{globals:{Blob:!0,CSSConditionRule:!0,CSSGroupingRule:!0,CSSMediaRule:!0,CSSRule:!0,CSSSupportsRule:!0,Document:!0,DragEvent:!0,Element:!0,FormData:!0,HTMLElement:!0,HTMLFormElement:!0,Headers:!0,MouseEvent:!0,MutationObserver:!0,"Node.DOCUMENT_FRAGMENT_NODE":!0,"Node.prototype.contains":!0,PointerEvent:!0,TextEncoder:!0,URL:!0,URLSearchParams:!0,Worker:!0,__RRWEB_EXCLUDE_IFRAME__:!0,__RRWEB_EXCLUDE_SHADOW_DOM__:!0,__SENTRY_DEBUG__:!0,__SENTRY_EXCLUDE_REPLAY_WORKER__:!0,__rrMutationObserver:!0,addEventListener:!0,clearTimeout:!0,"console.debug":!0,"console.error":!0,"console.warn":!0,"customElements.get":!0,document:!0,innerHeight:!0,innerWidth:!0,"location.href":!0,"location.origin":!0,parent:!0,setTimeout:!0},packages:{"@sentry/browser>@sentry-internal/browser-utils":!0,"@sentry/browser>@sentry/core":!0,"@sentry/utils":!0}},"@sentry/browser>@sentry-internal/replay-canvas":{globals:{Blob:!0,HTMLCanvasElement:!0,HTMLImageElement:!0,ImageData:!0,"URL.createObjectURL":!0,WeakRef:!0,Worker:!0,cancelAnimationFrame:!0,"console.error":!0,createImageBitmap:!0,document:!0},packages:{"@sentry/browser>@sentry/core":!0,"@sentry/utils":!0}},"@sentry/browser>@sentry/core":{globals:{Headers:!0,Request:!0,URL:!0,__SENTRY_DEBUG__:!0,__SENTRY_TRACING__:!0,clearInterval:!0,clearTimeout:!0,"console.log":!0,"console.warn":!0,setInterval:!0,setTimeout:!0},packages:{"@sentry/utils":!0}},"@sentry/utils":{globals:{CustomEvent:!0,DOMError:!0,DOMException:!0,EdgeRuntime:!0,Element:!0,ErrorEvent:!0,Event:!0,HTMLElement:!0,Headers:!0,PerformanceObserver:!0,Request:!0,Response:!0,TextDecoder:!0,TextEncoder:!0,__SENTRY_BROWSER_BUNDLE__:!0,__SENTRY_DEBUG__:!0,addEventListener:!0,"chrome.app":!0,"chrome.runtime":!0,clearTimeout:!0,"console.error":!0,crypto:!0,devicePixelRatio:!0,document:!0,location:!1,"location.href":!0,module:!0,"navigator.language":!0,"navigator.userAgent":!0,"navigator.userAgentData":!0,onunhandledrejection:!0,"performance.now":!0,"performance.timeOrigin":!0,process:!0,setTimeout:!0,top:!0},packages:{process:!0}},"@simplewebauthn/browser":{globals:{AbortController:!0,AbortSignal:!0,PublicKeyCredential:!0,atob:!0,btoa:!0,"console.warn":!0,"document.querySelectorAll":!0,"location.hostname":!0,"navigator.credentials.create":!0,"navigator.credentials.get":!0}},"@solana/addresses":{globals:{"Intl.Collator":!0,TextEncoder:!0,"crypto.subtle.digest":!0,"crypto.subtle.exportKey":!0},packages:{"@solana/addresses>@solana/assertions":!0,"@solana/addresses>@solana/codecs-core":!0,"@solana/addresses>@solana/codecs-strings":!0,"@solana/addresses>@solana/errors":!0}},"@solana/addresses>@solana/codecs-core":{packages:{"@solana/addresses>@solana/errors":!0}},"@solana/addresses>@solana/codecs-strings":{globals:{TextDecoder:!0,TextEncoder:!0,atob:!0,btoa:!0},packages:{"@solana/addresses>@solana/codecs-core":!0,"@solana/addresses>@solana/errors":!0}},"@solana/addresses>@solana/errors":{globals:{btoa:!0}},"@storybook/addon-docs>remark-external-links>mdast-util-definitions":{packages:{"react-markdown>unist-util-visit":!0}},"@storybook/react>util-deprecate":{globals:{"console.trace":!0,"console.warn":!0,localStorage:!0}},"@tanstack/react-query":{globals:{ReactQueryClientContext:"write"},packages:{"@tanstack/react-query>@tanstack/query-core":!0,"@tanstack/react-query>use-sync-external-store":!0,react:!0}},"@tanstack/react-query>@tanstack/query-core":{globals:{AbortController:!0,addEventListener:!1,clearInterval:!0,clearTimeout:!0,console:!0,document:!1,navigator:!0,removeEventListener:!0,setInterval:!0,setTimeout:!0}},"@tanstack/react-query>use-sync-external-store":{globals:{__REACT_DEVTOOLS_GLOBAL_HOOK__:!1,document:!1,"document.createElement":!0},packages:{react:!0}},"@tanstack/react-virtual":{globals:{document:!0,scrollY:!0},packages:{"@tanstack/react-virtual>@tanstack/virtual-core":!0,react:!0,"react-dom":!0}},"@tanstack/react-virtual>@tanstack/virtual-core":{globals:{"console.info":!0,"console.warn":!0,requestAnimationFrame:!0}},"@toruslabs/eccrypto":{globals:{"Buffer.alloc":!0,"Buffer.concat":!0,"Buffer.from":!0,"Buffer.isBuffer":!0,crypto:!0,msCrypto:!0},packages:{"@toruslabs/eccrypto>elliptic":!0,buffer:!0}},"@toruslabs/eccrypto>elliptic":{packages:{"@toruslabs/eccrypto>elliptic>brorand":!0,"@toruslabs/eccrypto>elliptic>hmac-drbg":!0,"@toruslabs/eccrypto>elliptic>minimalistic-assert":!0,"@toruslabs/eccrypto>elliptic>minimalistic-crypto-utils":!0,"duplexify>inherits":!0,"ethereumjs-util>bn.js":!0,"ethers>@ethersproject/sha2>hash.js":!0}},"@toruslabs/eccrypto>elliptic>brorand":{globals:{crypto:!0,msCrypto:!0}},"@toruslabs/eccrypto>elliptic>hmac-drbg":{packages:{"@toruslabs/eccrypto>elliptic>minimalistic-assert":!0,"@toruslabs/eccrypto>elliptic>minimalistic-crypto-utils":!0,"ethers>@ethersproject/sha2>hash.js":!0}},"@trezor/connect-web":{globals:{URLSearchParams:!0,__TREZOR_CONNECT_SRC:!0,addEventListener:!0,btoa:!0,chrome:!0,clearInterval:!0,clearTimeout:!0,"console.warn":!0,"document.body":!0,"document.createElement":!0,"document.createTextNode":!0,"document.getElementById":!0,"document.querySelectorAll":!0,"location.origin":!0,navigator:!0,open:!0,origin:!0,removeEventListener:!0,setInterval:!0,setTimeout:!0},packages:{"@trezor/connect-web>@trezor/connect":!0,"@trezor/connect-web>@trezor/connect-common":!0,"@trezor/connect-web>@trezor/connect>@trezor/blockchain-link>@trezor/websocket-client":!0,"@trezor/connect-web>@trezor/utils":!0,tslib:!0,"webpack>events":!0}},"@trezor/connect-web>@trezor/connect":{packages:{"@trezor/connect-web>@trezor/connect>@trezor/device-utils":!0,"@trezor/connect-web>@trezor/connect>@trezor/protobuf":!0,"@trezor/connect-web>@trezor/connect>@trezor/schema-utils":!0,"@trezor/connect-web>@trezor/connect>@trezor/transport":!0,"@trezor/connect-web>@trezor/utils":!0,tslib:!0}},"@trezor/connect-web>@trezor/connect-common":{globals:{"console.warn":!0,"localStorage.getItem":!0,"localStorage.setItem":!0,navigator:!0,setTimeout:!0,window:!0},packages:{"@trezor/connect-web>@trezor/connect-common>@trezor/env-utils":!0,"@trezor/connect-web>@trezor/utils":!0,tslib:!0}},"@trezor/connect-web>@trezor/connect-common>@trezor/env-utils":{globals:{innerHeight:!0,innerWidth:!0,"location.hostname":!0,"location.origin":!0,"navigator.languages":!0,"navigator.platform":!0,"navigator.userAgent":!0,process:!0,"screen.height":!0,"screen.width":!0},packages:{"@trezor/connect-web>@trezor/connect-common>@trezor/env-utils>ua-parser-js":!0,process:!0}},"@trezor/connect-web>@trezor/connect-common>@trezor/env-utils>ua-parser-js":{globals:{define:!0,"navigator.userAgentData":!0}},"@trezor/connect-web>@trezor/connect>@trezor/blockchain-link>@trezor/websocket-client":{globals:{WebSocket:!0,clearTimeout:!0,setTimeout:!0},packages:{"@trezor/connect-web>@trezor/utils":!0,tslib:!0,"webpack>events":!0}},"@trezor/connect-web>@trezor/connect>@trezor/device-utils":{packages:{tslib:!0}},"@trezor/connect-web>@trezor/connect>@trezor/protobuf":{globals:{"Buffer.from":!0},packages:{"@google/genai>protobufjs":!0,"@trezor/connect-web>@trezor/connect>@trezor/protobuf>long":!0,"@trezor/connect-web>@trezor/connect>@trezor/schema-utils":!0,buffer:!0,tslib:!0}},"@trezor/connect-web>@trezor/connect>@trezor/protobuf>long":{globals:{"WebAssembly.Instance":!0,"WebAssembly.Module":!0,define:!0}},"@trezor/connect-web>@trezor/connect>@trezor/schema-utils":{globals:{Buffer:!0,"console.warn":!0},packages:{"@trezor/connect-web>@trezor/connect>@trezor/schema-utils>@sinclair/typebox":!0,buffer:!0,"ts-mixer":!0}},"@trezor/connect-web>@trezor/utils":{globals:{AbortController:!0,Blob:!0,"Buffer.alloc":!0,"Buffer.allocUnsafe":!0,"Intl.NumberFormat":!0,TextEncoder:!0,clearInterval:!0,clearTimeout:!0,"console.error":!0,"console.info":!0,"console.log":!0,"console.warn":!0,"crypto.getRandomValues":!0,setInterval:!0,setTimeout:!0},packages:{"@trezor/connect-web>@trezor/utils>bignumber.js":!0,buffer:!0,tslib:!0,"webpack>events":!0}},"@trezor/connect-web>@trezor/utils>bignumber.js":{globals:{crypto:!0,define:!0}},"@zxing/browser":{globals:{HTMLElement:!0,HTMLImageElement:!0,HTMLVideoElement:!0,clearTimeout:!0,"console.error":!0,"console.warn":!0,document:!0,navigator:!0,setTimeout:!0},packages:{"@zxing/library":!0}},"@zxing/library":{globals:{HTMLImageElement:!0,HTMLVideoElement:!0,TextDecoder:!0,TextEncoder:!0,"URL.createObjectURL":!0,btoa:!0,"console.log":!0,"console.warn":!0,document:!0,navigator:!0,setTimeout:!0},packages:{"@zxing/library>ts-custom-error":!0}},"async-mutex":{globals:{clearTimeout:!0,setTimeout:!0},packages:{tslib:!0}},"base32-encode":{packages:{"base32-encode>to-data-view":!0}},"bignumber.js":{globals:{crypto:!0,define:!0}},bowser:{globals:{define:!0}},"browserify>concat-stream>buffer-from":{globals:{Buffer:!0},packages:{buffer:!0}},"browserify>string_decoder":{packages:{"mockttp>express>safe-buffer":!0}},"browserify>url":{packages:{"browserify>url>punycode":!0,"mockttp>express>qs":!0}},"browserify>url>punycode":{globals:{define:!0}},"browserify>util":{globals:{SharedArrayBuffer:!0,"console.error":!0,"console.log":!0,"console.trace":!0,process:!0},packages:{"browserify>util>is-arguments":!0,"browserify>util>is-generator-function":!0,"browserify>util>is-typed-array":!0,"browserify>util>which-typed-array":!0,"duplexify>inherits":!0,process:!0}},"browserify>util>is-arguments":{packages:{"jsdom>form-data>es-set-tostringtag>has-tostringtag":!0,"string.prototype.matchall>call-bind":!0}},"browserify>util>is-generator-function":{packages:{"jsdom>form-data>es-set-tostringtag>has-tostringtag":!0,"string.prototype.matchall>call-bound":!0,"string.prototype.matchall>es-abstract>get-proto":!0,"string.prototype.matchall>es-abstract>safe-regex-test":!0,"string.prototype.matchall>get-intrinsic>generator-function":!0}},"browserify>util>is-typed-array":{packages:{"browserify>util>which-typed-array":!0}},"browserify>util>which-typed-array":{packages:{"browserify>util>which-typed-array>for-each":!0,"jsdom>form-data>es-set-tostringtag>has-tostringtag":!0,"string.prototype.matchall>call-bind":!0,"string.prototype.matchall>call-bound":!0,"string.prototype.matchall>es-abstract>available-typed-arrays":!0,"string.prototype.matchall>es-abstract>get-proto":!0,"string.prototype.matchall>gopd":!0}},"browserify>util>which-typed-array>for-each":{packages:{"string.prototype.matchall>es-abstract>is-callable":!0}},bs58:{packages:{"bs58>base-x":!0}},buffer:{globals:{SharedArrayBuffer:!0,console:!0},packages:{"base64-js":!0,"buffer>ieee754":!0}},chalk:{packages:{"chalk>ansi-styles":!0,"chalk>supports-color":!0}},"chalk>ansi-styles":{packages:{"chalk>ansi-styles>color-convert":!0}},"chalk>ansi-styles>color-convert":{packages:{"jest-canvas-mock>moo-color>color-name":!0}},"chart.js":{globals:{"Intl.NumberFormat":!0,MutationObserver:!0,OffscreenCanvas:!0,Path2D:!0,ResizeObserver:!0,addEventListener:!0,clearTimeout:!0,"console.error":!0,"console.warn":!0,devicePixelRatio:!0,document:!0,removeEventListener:!0,requestAnimationFrame:!0,setTimeout:!0},packages:{"chart.js>@kurkle/color":!0}},cockatiel:{globals:{AbortController:!0,AbortSignal:!0,WeakRef:!0,clearTimeout:!0,performance:!0,"process.hrtime.bigint":!0,setTimeout:!0},packages:{process:!0}},"copy-to-clipboard":{globals:{clipboardData:!0,"console.error":!0,"console.warn":!0,"document.body.appendChild":!0,"document.body.removeChild":!0,"document.createElement":!0,"document.createRange":!0,"document.execCommand":!0,"document.getSelection":!0,"navigator.userAgent":!0,prompt:!0},packages:{"copy-to-clipboard>toggle-selection":!0}},"copy-to-clipboard>toggle-selection":{globals:{"document.activeElement":!0,"document.getSelection":!0}},"core-js-pure":{globals:{"Bun.version":!0,"Deno.version":!0,document:!0,setTimeout:!0}},"cron-parser":{packages:{luxon:!0}},"crypto-browserify":{packages:{"crypto-browserify>browserify-cipher":!0,"crypto-browserify>browserify-sign":!0,"crypto-browserify>create-ecdh":!0,"crypto-browserify>create-hmac":!0,"crypto-browserify>diffie-hellman":!0,"crypto-browserify>pbkdf2":!0,"crypto-browserify>public-encrypt":!0,"crypto-browserify>randombytes":!0,"crypto-browserify>randomfill":!0,"ethereumjs-util>create-hash":!0}},"crypto-browserify>browserify-cipher":{packages:{"crypto-browserify>browserify-cipher>browserify-des":!0,"crypto-browserify>browserify-cipher>evp_bytestokey":!0,"ethereumjs-util>ethereum-cryptography>browserify-aes":!0}},"crypto-browserify>browserify-cipher>browserify-des":{globals:{Buffer:!0},packages:{buffer:!0,"crypto-browserify>browserify-cipher>browserify-des>des.js":!0,"duplexify>inherits":!0,"ethereumjs-util>create-hash>cipher-base":!0}},"crypto-browserify>browserify-cipher>browserify-des>des.js":{packages:{"@toruslabs/eccrypto>elliptic>minimalistic-assert":!0,"duplexify>inherits":!0}},"crypto-browserify>browserify-cipher>evp_bytestokey":{packages:{"ethereumjs-util>create-hash>md5.js":!0,"mockttp>express>safe-buffer":!0}},"crypto-browserify>browserify-sign":{packages:{"@toruslabs/eccrypto>elliptic":!0,"crypto-browserify>browserify-sign>readable-stream":!0,"crypto-browserify>create-hmac":!0,"crypto-browserify>public-encrypt>browserify-rsa":!0,"crypto-browserify>public-encrypt>parse-asn1":!0,"duplexify>inherits":!0,"ethereumjs-util>bn.js":!0,"ethereumjs-util>create-hash":!0,"mockttp>express>safe-buffer":!0}},"crypto-browserify>browserify-sign>readable-stream":{globals:{"process.browser":!0,"process.stderr":!0,"process.stdout":!0,"process.version.slice":!0,setImmediate:!0},packages:{"@storybook/react>util-deprecate":!0,"core-js-pure":!0,"crypto-browserify>browserify-sign>readable-stream>isarray":!0,"crypto-browserify>browserify-sign>readable-stream>safe-buffer":!0,"crypto-browserify>browserify-sign>readable-stream>string_decoder":!0,"duplexify>inherits":!0,process:!0,"readable-stream-2>core-util-is":!0,"readable-stream-2>process-nextick-args":!0,"webpack>events":!0}},"crypto-browserify>browserify-sign>readable-stream>safe-buffer":{packages:{buffer:!0}},"crypto-browserify>browserify-sign>readable-stream>string_decoder":{packages:{"crypto-browserify>browserify-sign>readable-stream>string_decoder>safe-buffer":!0}},"crypto-browserify>browserify-sign>readable-stream>string_decoder>safe-buffer":{packages:{buffer:!0}},"crypto-browserify>create-ecdh":{globals:{Buffer:!0},packages:{"@toruslabs/eccrypto>elliptic":!0,buffer:!0,"ethereumjs-util>bn.js":!0}},"crypto-browserify>create-hmac":{packages:{"@ngraveio/bc-ur>sha.js":!0,"duplexify>inherits":!0,"ethereumjs-util>create-hash":!0,"ethereumjs-util>create-hash>cipher-base":!0,"ethereumjs-util>create-hash>ripemd160":!0,"mockttp>express>safe-buffer":!0}},"crypto-browserify>diffie-hellman":{globals:{Buffer:!0},packages:{buffer:!0,"crypto-browserify>diffie-hellman>miller-rabin":!0,"crypto-browserify>randombytes":!0,"ethereumjs-util>bn.js":!0}},"crypto-browserify>diffie-hellman>miller-rabin":{packages:{"@toruslabs/eccrypto>elliptic>brorand":!0,"ethereumjs-util>bn.js":!0}},"crypto-browserify>pbkdf2":{globals:{crypto:!0,process:!0,queueMicrotask:!0,setImmediate:!0,setTimeout:!0},packages:{"@ngraveio/bc-ur>sha.js":!0,"@ngraveio/bc-ur>sha.js>to-buffer":!0,"crypto-browserify>pbkdf2>create-hash":!0,"crypto-browserify>pbkdf2>ripemd160":!0,"mockttp>express>safe-buffer":!0,process:!0}},"crypto-browserify>pbkdf2>create-hash":{globals:{Buffer:!0},packages:{buffer:!0}},"crypto-browserify>pbkdf2>ripemd160":{globals:{Buffer:!0},packages:{buffer:!0,"crypto-browserify>pbkdf2>ripemd160>hash-base":!0,"duplexify>inherits":!0}},"crypto-browserify>pbkdf2>ripemd160>hash-base":{globals:{Buffer:!0},packages:{buffer:!0,"duplexify>inherits":!0,"stream-browserify":!0}},"crypto-browserify>public-encrypt":{packages:{"crypto-browserify>public-encrypt>browserify-rsa":!0,"crypto-browserify>public-encrypt>parse-asn1":!0,"crypto-browserify>randombytes":!0,"ethereumjs-util>bn.js":!0,"ethereumjs-util>create-hash":!0,"mockttp>express>safe-buffer":!0}},"crypto-browserify>public-encrypt>browserify-rsa":{packages:{"crypto-browserify>randombytes":!0,"ethereumjs-util>bn.js":!0,"mockttp>express>safe-buffer":!0}},"crypto-browserify>public-encrypt>parse-asn1":{packages:{"crypto-browserify>browserify-cipher>evp_bytestokey":!0,"crypto-browserify>pbkdf2":!0,"crypto-browserify>public-encrypt>parse-asn1>asn1.js":!0,"ethereumjs-util>ethereum-cryptography>browserify-aes":!0,"mockttp>express>safe-buffer":!0}},"crypto-browserify>public-encrypt>parse-asn1>asn1.js":{packages:{"@toruslabs/eccrypto>elliptic>minimalistic-assert":!0,buffer:!0,"duplexify>inherits":!0,"ethereumjs-util>bn.js":!0}},"crypto-browserify>randombytes":{globals:{crypto:!0,msCrypto:!0,"process.nextTick":!0},packages:{"mockttp>express>safe-buffer":!0,process:!0}},"crypto-browserify>randomfill":{globals:{crypto:!0,msCrypto:!0,"process.browser":!0,"process.nextTick":!0},packages:{"crypto-browserify>randombytes":!0,"mockttp>express>safe-buffer":!0,process:!0}},"currency-formatter":{packages:{"currency-formatter>accounting":!0,"currency-formatter>locale-currency":!0,"prop-types>object-assign":!0}},"currency-formatter>accounting":{globals:{define:!0}},"currency-formatter>locale-currency":{globals:{countryCode:!0}},dompurify:{globals:{"console.warn":!0}},eciesjs:{packages:{"@noble/ciphers":!0,"@noble/curves":!0,"@noble/hashes":!0,"eciesjs>@ecies/ciphers":!0}},"eciesjs>@ecies/ciphers":{packages:{"@noble/ciphers":!0}},"eslint-plugin-react>array-includes>is-string":{packages:{"jsdom>form-data>es-set-tostringtag>has-tostringtag":!0,"string.prototype.matchall>call-bound":!0}},"eslint-plugin-react>es-iterator-helpers>has-property-descriptors":{packages:{"string.prototype.matchall>call-bind>es-define-property":!0}},"eslint-plugin-react>es-iterator-helpers>has-proto>dunder-proto":{packages:{"string.prototype.matchall>call-bind>call-bind-apply-helpers":!0,"string.prototype.matchall>gopd":!0}},"eslint-plugin-react>hasown":{packages:{"browserify>has>function-bind":!0}},"eslint>ajv":{globals:{console:!0},packages:{"eslint>ajv>json-schema-traverse":!0,"eslint>fast-deep-equal":!0,"fast-json-stable-stringify":!0,"uri-js":!0}},"eth-ens-namehash":{globals:{Buffer:!0,name:"write"},packages:{buffer:!0,"eth-ens-namehash>idna-uts46-hx":!0,"eth-ens-namehash>js-sha3":!0}},"eth-ens-namehash>idna-uts46-hx":{globals:{define:!0},packages:{"eth-ens-namehash>idna-uts46-hx>punycode":!0}},"eth-ens-namehash>js-sha3":{globals:{define:!0,process:!0},packages:{process:!0}},"eth-lattice-keyring":{globals:{"Buffer.concat":!0,"Buffer.from":!0,"Buffer.isBuffer":!0,addEventListener:!0,browser:!0,clearInterval:!0,open:!0,setInterval:!0},packages:{"@ethereumjs/tx":!0,buffer:!0,"crypto-browserify":!0,"eth-lattice-keyring>@ethereumjs/util":!0,"eth-lattice-keyring>gridplus-sdk":!0,"eth-lattice-keyring>rlp":!0,"ethereumjs-util>bn.js":!0,"webpack>events":!0}},"eth-lattice-keyring>@ethereumjs/util":{globals:{"Buffer.alloc":!0,"Buffer.allocUnsafe":!0,"Buffer.byteLength":!0,"Buffer.concat":!0,"Buffer.from":!0,"Buffer.isBuffer":!0,"console.warn":!0},packages:{buffer:!0,"eth-lattice-keyring>@ethereumjs/util>@ethereumjs/rlp":!0,"eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography":!0,"eth-lattice-keyring>@ethereumjs/util>micro-ftch":!0,"webpack>events":!0}},"eth-lattice-keyring>@ethereumjs/util>@ethereumjs/rlp":{globals:{TextEncoder:!0}},"eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography":{globals:{TextDecoder:!0,crypto:!0},packages:{"eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/curves":!0,"eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/hashes":!0}},"eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/curves":{globals:{TextEncoder:!0},packages:{"eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/hashes":!0}},"eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/hashes":{globals:{TextEncoder:!0,crypto:!0}},"eth-lattice-keyring>@ethereumjs/util>micro-ftch":{globals:{"Buffer.concat":!0,Headers:!0,TextDecoder:!0,URL:!0,btoa:!0,fetch:!0,process:!0},packages:{"browserify>url":!0,"browserify>util":!0,buffer:!0,"https-browserify":!0,process:!0,"stream-http":!0}},"eth-lattice-keyring>gridplus-sdk":{globals:{AbortController:!0,"Buffer.alloc":!0,"Buffer.concat":!0,"Buffer.from":!0,"Buffer.isBuffer":!0,Request:!0,URL:!0,caches:!0,clearTimeout:!0,"console.debug":!0,"console.error":!0,"console.log":!0,"console.warn":!0,fetch:!0,setTimeout:!0,structuredClone:!0},packages:{"@metamask/eth-sig-util":!0,"@toruslabs/eccrypto>elliptic":!0,"bitcoin-address-validation>bech32":!0,buffer:!0,"eth-lattice-keyring>gridplus-sdk>@ethereumjs/rlp":!0,"eth-lattice-keyring>gridplus-sdk>aes-js":!0,"eth-lattice-keyring>gridplus-sdk>bignumber.js":!0,"eth-lattice-keyring>gridplus-sdk>bs58check":!0,"eth-lattice-keyring>gridplus-sdk>cbor":!0,"eth-lattice-keyring>gridplus-sdk>cbor-bigdecimal":!0,"eth-lattice-keyring>gridplus-sdk>crc-32":!0,"eth-lattice-keyring>gridplus-sdk>ox":!0,"eth-lattice-keyring>gridplus-sdk>secp256k1":!0,"eth-lattice-keyring>gridplus-sdk>zod":!0,"ethereumjs-util>bn.js":!0,"ethers>@ethersproject/sha2>hash.js":!0,lodash:!0,uuid:!0,viem:!0,"viem>abitype":!0}},"eth-lattice-keyring>gridplus-sdk>@ethereumjs/rlp":{globals:{TextEncoder:!0}},"eth-lattice-keyring>gridplus-sdk>aes-js":{globals:{define:!0}},"eth-lattice-keyring>gridplus-sdk>bignumber.js":{globals:{crypto:!0,define:!0}},"eth-lattice-keyring>gridplus-sdk>bs58check":{packages:{"@noble/hashes":!0,bs58:!0}},"eth-lattice-keyring>gridplus-sdk>cbor":{globals:{TextDecoder:!0,URL:!0},packages:{buffer:!0,"eth-lattice-keyring>gridplus-sdk>cbor>nofilter":!0,"stream-browserify":!0}},"eth-lattice-keyring>gridplus-sdk>cbor-bigdecimal":{globals:{define:!0},packages:{"eth-lattice-keyring>gridplus-sdk>bignumber.js":!0}},"eth-lattice-keyring>gridplus-sdk>cbor>nofilter":{globals:{TextDecoder:!0},packages:{buffer:!0,"stream-browserify":!0}},"eth-lattice-keyring>gridplus-sdk>crc-32":{globals:{DO_NOT_EXPORT_CRC:!0,define:!0}},"eth-lattice-keyring>gridplus-sdk>ox":{globals:{TextDecoder:!0,TextEncoder:!0,"crypto.getRandomValues":!0},packages:{"@noble/hashes":!0,"eth-lattice-keyring>gridplus-sdk>ox>@noble/curves":!0}},"eth-lattice-keyring>gridplus-sdk>secp256k1":{packages:{"@toruslabs/eccrypto>elliptic":!0}},"eth-lattice-keyring>gridplus-sdk>zod":{globals:{File:!0,JSONSchema:!0,URL:!0,__zod_globalRegistry:"write",atob:!0,btoa:!0,coerce:!0,core:!0,iso:!0,locales:!0,navigator:!0,regexes:!0,util:!0}},"eth-lattice-keyring>rlp":{globals:{TextEncoder:!0}},"eth-method-registry":{packages:{"eth-method-registry>@metamask/ethjs-contract":!0,"eth-method-registry>@metamask/ethjs-query":!0}},"eth-method-registry>@metamask/ethjs-contract":{packages:{"@babel/runtime":!0,"eth-ens-namehash>js-sha3":!0,"eth-method-registry>@metamask/ethjs-contract>@metamask/ethjs-filter":!0,"eth-method-registry>@metamask/ethjs-contract>@metamask/ethjs-util":!0,"eth-method-registry>@metamask/ethjs-contract>ethjs-abi":!0,"eth-method-registry>@metamask/ethjs-query>promise-to-callback":!0}},"eth-method-registry>@metamask/ethjs-contract>@metamask/ethjs-filter":{globals:{clearInterval:!0,setInterval:!0}},"eth-method-registry>@metamask/ethjs-contract>@metamask/ethjs-util":{globals:{"Buffer.byteLength":!0,"Buffer.from":!0},packages:{buffer:!0,"eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format>is-hex-prefixed":!0,"eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format>strip-hex-prefix":!0}},"eth-method-registry>@metamask/ethjs-contract>ethjs-abi":{globals:{Buffer:!0},packages:{buffer:!0,"eth-ens-namehash>js-sha3":!0,"eth-method-registry>@metamask/ethjs-contract>ethjs-abi>number-to-bn":!0,"ethereumjs-util>bn.js":!0}},"eth-method-registry>@metamask/ethjs-contract>ethjs-abi>number-to-bn":{packages:{"eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format>strip-hex-prefix":!0,"ethereumjs-util>bn.js":!0}},"eth-method-registry>@metamask/ethjs-query":{globals:{console:!0},packages:{"eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format":!0,"eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-rpc":!0,"eth-method-registry>@metamask/ethjs-query>promise-to-callback":!0}},"eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format":{packages:{"@metamask/controller-utils>@metamask/ethjs-unit>@metamask/number-to-bn":!0,"eth-method-registry>@metamask/ethjs-contract>@metamask/ethjs-util":!0,"eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format>ethjs-schema":!0,"eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format>strip-hex-prefix":!0}},"eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format>strip-hex-prefix":{packages:{"eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-format>is-hex-prefixed":!0}},"eth-method-registry>@metamask/ethjs-query>@metamask/ethjs-rpc":{packages:{"eth-method-registry>@metamask/ethjs-query>promise-to-callback":!0}},"eth-method-registry>@metamask/ethjs-query>promise-to-callback":{packages:{"eth-method-registry>@metamask/ethjs-query>promise-to-callback>is-fn":!0,"eth-method-registry>@metamask/ethjs-query>promise-to-callback>set-immediate-shim":!0}},"eth-method-registry>@metamask/ethjs-query>promise-to-callback>set-immediate-shim":{globals:{setImmediate:!0,"setTimeout.apply":!0},packages:{"core-js-pure":!0}},"ethereum-cryptography":{globals:{TextDecoder:!0},packages:{"@noble/hashes":!0,"ethereum-cryptography>@noble/curves":!0}},"ethereumjs-util":{globals:{Buffer:!0},packages:{"@ngraveio/bc-ur>assert":!0,buffer:!0,"ethereumjs-util>bn.js":!0,"ethereumjs-util>create-hash":!0,"ethereumjs-util>ethereum-cryptography":!0,"ethereumjs-util>rlp":!0}},"ethereumjs-util>bn.js":{globals:{Buffer:!0}},"ethereumjs-util>create-hash":{packages:{"@ngraveio/bc-ur>sha.js":!0,"duplexify>inherits":!0,"ethereumjs-util>create-hash>cipher-base":!0,"ethereumjs-util>create-hash>md5.js":!0,"ethereumjs-util>create-hash>ripemd160":!0}},"ethereumjs-util>create-hash>cipher-base":{packages:{"browserify>string_decoder":!0,"duplexify>inherits":!0,"mockttp>express>safe-buffer":!0,"stream-browserify":!0}},"ethereumjs-util>create-hash>md5.js":{packages:{"duplexify>inherits":!0,"ethereumjs-util>create-hash>md5.js>hash-base":!0,"mockttp>express>safe-buffer":!0}},"ethereumjs-util>create-hash>md5.js>hash-base":{packages:{"duplexify>inherits":!0,"ethereumjs-util>create-hash>md5.js>hash-base>readable-stream":!0,"mockttp>express>safe-buffer":!0}},"ethereumjs-util>create-hash>md5.js>hash-base>readable-stream":{globals:{"process.nextTick":!0,"process.stderr":!0,"process.stdout":!0},packages:{"@storybook/react>util-deprecate":!0,"browserify>string_decoder":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"webpack>events":!0}},"ethereumjs-util>create-hash>ripemd160":{packages:{buffer:!0,"duplexify>inherits":!0,"ethereumjs-util>create-hash>ripemd160>hash-base":!0}},"ethereumjs-util>create-hash>ripemd160>hash-base":{packages:{"duplexify>inherits":!0,"ethereumjs-util>create-hash>ripemd160>hash-base>readable-stream":!0,"mockttp>express>safe-buffer":!0}},"ethereumjs-util>create-hash>ripemd160>hash-base>readable-stream":{globals:{"process.nextTick":!0,"process.stderr":!0,"process.stdout":!0},packages:{"@storybook/react>util-deprecate":!0,"browserify>string_decoder":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"webpack>events":!0}},"ethereumjs-util>ethereum-cryptography":{globals:{"Buffer.from":!0},packages:{buffer:!0,"crypto-browserify>randombytes":!0,"ethereumjs-util>ethereum-cryptography>keccak":!0,"ethereumjs-util>ethereum-cryptography>secp256k1":!0}},"ethereumjs-util>ethereum-cryptography>browserify-aes":{globals:{"Buffer.concat":!0},packages:{buffer:!0,"crypto-browserify>browserify-cipher>evp_bytestokey":!0,"duplexify>inherits":!0,"ethereumjs-util>create-hash>cipher-base":!0,"ethereumjs-util>ethereum-cryptography>browserify-aes>buffer-xor":!0,"mockttp>express>safe-buffer":!0}},"ethereumjs-util>ethereum-cryptography>browserify-aes>buffer-xor":{globals:{Buffer:!0},packages:{buffer:!0}},"ethereumjs-util>ethereum-cryptography>bs58check":{packages:{"ethereumjs-util>create-hash":!0,"ethereumjs-util>ethereum-cryptography>bs58check>bs58":!0,"mockttp>express>safe-buffer":!0}},"ethereumjs-util>ethereum-cryptography>bs58check>bs58":{packages:{"@ensdomains/content-hash>multihashes>multibase>base-x":!0}},"ethereumjs-util>ethereum-cryptography>keccak":{globals:{"Buffer.alloc":!0,"Buffer.from":!0,"Buffer.isBuffer":!0},packages:{buffer:!0,"ethereumjs-util>ethereum-cryptography>keccak>readable-stream":!0}},"ethereumjs-util>ethereum-cryptography>keccak>readable-stream":{globals:{"process.nextTick":!0,"process.stderr":!0,"process.stdout":!0},packages:{"@storybook/react>util-deprecate":!0,"browserify>string_decoder":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"webpack>events":!0}},"ethereumjs-util>ethereum-cryptography>secp256k1":{packages:{"@toruslabs/eccrypto>elliptic":!0}},"ethereumjs-util>rlp":{globals:{"Buffer.concat":!0,"Buffer.from":!0,"Buffer.isBuffer":!0},packages:{buffer:!0,"ethereumjs-util>bn.js":!0}},ethers:{packages:{"@ethersproject/abi":!0,"@ethersproject/bignumber":!0,"@ethersproject/bytes":!0,"@ethersproject/contracts":!0,"@ethersproject/hdnode":!0,"@ethersproject/providers":!0,"@ethersproject/transactions":!0,"ethers>@ethersproject/abstract-signer":!0,"ethers>@ethersproject/address":!0,"ethers>@ethersproject/base64":!0,"ethers>@ethersproject/basex":!0,"ethers>@ethersproject/constants":!0,"ethers>@ethersproject/hash":!0,"ethers>@ethersproject/json-wallets":!0,"ethers>@ethersproject/keccak256":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/properties":!0,"ethers>@ethersproject/random":!0,"ethers>@ethersproject/rlp":!0,"ethers>@ethersproject/sha2":!0,"ethers>@ethersproject/signing-key":!0,"ethers>@ethersproject/solidity":!0,"ethers>@ethersproject/strings":!0,"ethers>@ethersproject/units":!0,"ethers>@ethersproject/wallet":!0,"ethers>@ethersproject/web":!0,"ethers>@ethersproject/wordlists":!0}},"ethers>@ethersproject/abstract-provider":{packages:{"@ethersproject/bignumber":!0,"@ethersproject/bytes":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/properties":!0}},"ethers>@ethersproject/abstract-signer":{packages:{"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/properties":!0}},"ethers>@ethersproject/address":{packages:{"@ethersproject/bignumber":!0,"@ethersproject/bytes":!0,"ethers>@ethersproject/keccak256":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/rlp":!0}},"ethers>@ethersproject/base64":{globals:{atob:!0,btoa:!0},packages:{"@ethersproject/bytes":!0}},"ethers>@ethersproject/basex":{packages:{"@ethersproject/bytes":!0,"ethers>@ethersproject/properties":!0}},"ethers>@ethersproject/constants":{packages:{"@ethersproject/bignumber":!0}},"ethers>@ethersproject/hash":{packages:{"@ethersproject/bignumber":!0,"@ethersproject/bytes":!0,"ethers>@ethersproject/address":!0,"ethers>@ethersproject/base64":!0,"ethers>@ethersproject/keccak256":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/properties":!0,"ethers>@ethersproject/strings":!0}},"ethers>@ethersproject/json-wallets":{packages:{"@ethersproject/bytes":!0,"@ethersproject/hdnode":!0,"@ethersproject/transactions":!0,"ethers>@ethersproject/address":!0,"ethers>@ethersproject/json-wallets>aes-js":!0,"ethers>@ethersproject/json-wallets>scrypt-js":!0,"ethers>@ethersproject/keccak256":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/pbkdf2":!0,"ethers>@ethersproject/properties":!0,"ethers>@ethersproject/random":!0,"ethers>@ethersproject/strings":!0}},"ethers>@ethersproject/json-wallets>aes-js":{globals:{define:!0}},"ethers>@ethersproject/json-wallets>scrypt-js":{globals:{define:!0,setImmediate:!0,setTimeout:!0},packages:{"core-js-pure":!0}},"ethers>@ethersproject/keccak256":{packages:{"@ethersproject/bytes":!0,"eth-ens-namehash>js-sha3":!0}},"ethers>@ethersproject/logger":{globals:{console:!0}},"ethers>@ethersproject/networks":{packages:{"ethers>@ethersproject/logger":!0}},"ethers>@ethersproject/pbkdf2":{packages:{"@ethersproject/bytes":!0,"ethers>@ethersproject/sha2":!0}},"ethers>@ethersproject/properties":{packages:{"ethers>@ethersproject/logger":!0}},"ethers>@ethersproject/random":{globals:{"crypto.getRandomValues":!0},packages:{"@ethersproject/bytes":!0,"ethers>@ethersproject/logger":!0}},"ethers>@ethersproject/rlp":{packages:{"@ethersproject/bytes":!0,"ethers>@ethersproject/logger":!0}},"ethers>@ethersproject/sha2":{packages:{"@ethersproject/bytes":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/sha2>hash.js":!0}},"ethers>@ethersproject/sha2>hash.js":{packages:{"@toruslabs/eccrypto>elliptic>minimalistic-assert":!0,"duplexify>inherits":!0}},"ethers>@ethersproject/signing-key":{packages:{"@ethersproject/bytes":!0,"ethereumjs-util>bn.js":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/properties":!0,"ethers>@ethersproject/sha2>hash.js":!0}},"ethers>@ethersproject/solidity":{packages:{"@ethersproject/bignumber":!0,"@ethersproject/bytes":!0,"ethers>@ethersproject/keccak256":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/sha2":!0,"ethers>@ethersproject/strings":!0}},"ethers>@ethersproject/strings":{packages:{"@ethersproject/bytes":!0,"ethers>@ethersproject/constants":!0,"ethers>@ethersproject/logger":!0}},"ethers>@ethersproject/units":{packages:{"@ethersproject/bignumber":!0,"ethers>@ethersproject/logger":!0}},"ethers>@ethersproject/wallet":{packages:{"@ethersproject/bytes":!0,"@ethersproject/hdnode":!0,"@ethersproject/transactions":!0,"ethers>@ethersproject/abstract-provider":!0,"ethers>@ethersproject/abstract-signer":!0,"ethers>@ethersproject/address":!0,"ethers>@ethersproject/hash":!0,"ethers>@ethersproject/json-wallets":!0,"ethers>@ethersproject/keccak256":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/properties":!0,"ethers>@ethersproject/random":!0,"ethers>@ethersproject/signing-key":!0}},"ethers>@ethersproject/web":{globals:{clearTimeout:!0,fetch:!0,setTimeout:!0},packages:{"@ethersproject/bytes":!0,"ethers>@ethersproject/base64":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/properties":!0,"ethers>@ethersproject/strings":!0}},"ethers>@ethersproject/wordlists":{packages:{"ethers>@ethersproject/hash":!0,"ethers>@ethersproject/logger":!0,"ethers>@ethersproject/properties":!0}},"extension-port-stream":{globals:{AggregateError:!0,"navigator.userAgent.includes":!0,"performance.now":!0,queueMicrotask:!0,scheduler:!0,setTimeout:!0},packages:{"readable-stream":!0}},"fast-json-patch":{globals:{addEventListener:!0,clearTimeout:!0,removeEventListener:!0,setTimeout:!0}},"fuse.js":{globals:{console:!0,define:!0}},"gulp>vinyl-fs>object.assign":{packages:{"@lavamoat/webpack>json-stable-stringify>object-keys":!0,"string.prototype.matchall>call-bind":!0,"string.prototype.matchall>call-bound":!0,"string.prototype.matchall>define-properties":!0,"string.prototype.matchall>es-object-atoms":!0,"string.prototype.matchall>has-symbols":!0}},he:{globals:{define:!0}},"https-browserify":{packages:{"browserify>url":!0,"stream-http":!0}},"humanize-duration":{globals:{define:!0}},"jsdom>form-data>es-set-tostringtag>has-tostringtag":{packages:{"string.prototype.matchall>has-symbols":!0}},"lightweight-charts":{globals:{Image:!0,ResizeObserver:!0,URL:!0,cancelAnimationFrame:!0,chrome:!0,clearTimeout:!0,devicePixelRatio:!0,"document.activeElement":!0,"document.body":!0,"document.createElement":!0,"document.documentElement":!0,"document.getElementById":!0,"document.getSelection":!0,getComputedStyle:!0,"location.href":!0,"navigator.language":!0,"navigator.platform":!0,"navigator.userAgent.toLowerCase":!0,"navigator.userAgentData":!0,"performance.now":!0,queueMicrotask:!0,requestAnimationFrame:!0,setTimeout:!0},packages:{"lightweight-charts>fancy-canvas":!0}},"lightweight-charts>fancy-canvas":{globals:{ResizeObserver:!0,"document.body":!0}},localforage:{globals:{Blob:!0,BlobBuilder:!0,FileReader:!0,IDBKeyRange:!0,MSBlobBuilder:!0,MozBlobBuilder:!0,OIndexedDB:!0,WebKitBlobBuilder:!0,atob:!0,btoa:!0,"console.error":!0,"console.info":!0,"console.warn":!0,define:!0,fetch:!0,indexedDB:!0,localStorage:!0,mozIndexedDB:!0,msIndexedDB:!0,"navigator.platform":!0,"navigator.userAgent":!0,openDatabase:!0,setTimeout:!0,webkitIndexedDB:!0}},lodash:{globals:{_:!0,clearTimeout:!0,define:!0,setTimeout:!0}},loglevel:{globals:{console:!0,define:!0,"document.cookie":!0,localStorage:!0,log:"write",navigator:!0}},"lottie-web":{globals:{Blob:!0,Howl:!0,OffscreenCanvas:!0,"URL.createObjectURL":!0,Worker:!0,XMLHttpRequest:!0,bodymovin:"write",clearInterval:!0,console:!0,define:!0,"document.body":!0,"document.createElement":!0,"document.createElementNS":!0,"document.getElementsByClassName":!0,"document.getElementsByTagName":!0,"document.querySelectorAll":!0,"document.readyState":!0,"location.origin":!0,"location.pathname":!0,navigator:!0,requestAnimationFrame:!0,setInterval:!0,setTimeout:!0}},luxon:{globals:{Intl:!0}},"mockttp>@httptoolkit/subscriptions-transport-ws>symbol-observable":{globals:{module:!0}},"mockttp>express>qs":{packages:{"string.prototype.matchall>side-channel":!0}},"mockttp>express>safe-buffer":{packages:{buffer:!0}},nanoid:{globals:{"crypto.getRandomValues":!0}},"nock>debug":{globals:{console:!0,document:!0,localStorage:!0,navigator:!0,process:!0},packages:{"mocha>ms":!0,process:!0}},"openai>abort-controller":{globals:{AbortController:!0}},"path-browserify":{globals:{"process.cwd":!0},packages:{process:!0}},process:{globals:{clearTimeout:!0,setTimeout:!0}},"qrcode.react":{globals:{Path2D:!0,devicePixelRatio:!0},packages:{react:!0}},"react-chartjs-2":{globals:{setTimeout:!0},packages:{"chart.js":!0,react:!0}},"react-compiler-runtime":{globals:{"console.error":!0},packages:{react:!0}},"react-devtools-core":{globals:{CSSStyleRule:!0,ElementTypeClass:!0,ElementTypeForwardRef:!0,ElementTypeFunction:!0,ElementTypeMemo:!0,ElementTypeVirtual:!0,ErrorEvent:!0,HTMLElement:!0,LOCAL_STORAGE_COMPONENT_FILTER_PREFERENCES_KEY:!0,LOCAL_STORAGE_OPEN_IN_EDITOR_URL:!0,"Node.ELEMENT_NODE":!0,SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY:!0,SESSION_STORAGE_RECORD_TIMELINE_KEY:!0,SESSION_STORAGE_RELOAD_AND_PROFILE_KEY:!0,URL:!0,WebSocket:!0,__REACT_DEVTOOLS_COMPONENT_FILTERS__:!0,__REACT_DEVTOOLS_GLOBAL_HOOK__:!0,__REACT_DEVTOOLS_TARGET_WINDOW__:!0,cancelAnimationFrame:!0,chrome:!0,clearTimeout:!0,console:!0,define:!0,devicePixelRatio:!0,devtoolsJestTestScheduler:!0,dispatchEvent:!0,document:!0,getComputedStyle:!0,getInObject:!0,innerHeight:!0,innerWidth:!0,"localStorage.getItem":!0,"localStorage.removeItem":!0,"localStorage.setItem":!0,localStorageGetItem:!0,localStorageSetItem:!0,"navigator.userAgent":!0,performance:!0,queueMicrotask:!0,"regeneratorRuntime.mark":!0,"regeneratorRuntime.wrap":!0,reportError:!0,requestAnimationFrame:!0,"sessionStorage.getItem":!0,"sessionStorage.removeItem":!0,"sessionStorage.setItem":!0,sessionStorageGetItem:!0,sessionStorageRemoveItem:!0,sessionStorageSetItem:!0,setInObject:!0,setTimeout:!0}},"react-dom":{globals:{HTMLIFrameElement:!0,MSApp:!0,__REACT_DEVTOOLS_GLOBAL_HOOK__:!0,addEventListener:!0,clearTimeout:!0,clipboardData:!0,"console.error":!0,document:!0,event:!1,queueMicrotask:!0,removeEventListener:!0,reportError:!0,setTimeout:!0},packages:{react:!0,"react-dom>scheduler":!0}},"react-dom>scheduler":{globals:{MessageChannel:!0,SharedArrayBuffer:!0,clearTimeout:!0,"console.error":!0,navigator:!0,performance:!0,setImmediate:!0,setTimeout:!0},packages:{"core-js-pure":!0}},"react-focus-lock":{globals:{addEventListener:!0,"console.error":!0,"console.warn":!0,document:!0,removeEventListener:!0,setTimeout:!0},packages:{"@babel/runtime":!0,"prop-types":!0,react:!0,"react-focus-lock>focus-lock":!0,"react-focus-lock>react-clientside-effect":!0,"react-focus-lock>use-callback-ref":!0,"react-focus-lock>use-sidecar":!0}},"react-focus-lock>focus-lock":{globals:{HTMLIFrameElement:!0,"Node.DOCUMENT_FRAGMENT_NODE":!0,"Node.DOCUMENT_NODE":!0,"Node.DOCUMENT_POSITION_CONTAINED_BY":!0,"Node.DOCUMENT_POSITION_CONTAINS":!0,"Node.ELEMENT_NODE":!0,"console.error":!0,"console.warn":!0,document:!0,getComputedStyle:!0,setTimeout:!0}},"react-focus-lock>react-clientside-effect":{packages:{"@babel/runtime":!0,react:!0}},"react-focus-lock>use-callback-ref":{packages:{react:!0}},"react-focus-lock>use-sidecar":{packages:{tslib:!0}},"react-hot-toast":{globals:{MutationObserver:!0,clearTimeout:!0,matchMedia:!0,setTimeout:!0},packages:{react:!0,"react-hot-toast>goober":!0}},"react-hot-toast>goober":{globals:{__nonce__:!0,_goober:!0,"document.createElement":!0,"document.head":!0}},"react-idle-timer":{globals:{clearTimeout:!0,document:!0,setTimeout:!0},packages:{"prop-types":!0,react:!0}},"react-markdown":{globals:{"console.warn":!0},packages:{"prop-types":!0,react:!0,"react-markdown>comma-separated-tokens":!0,"react-markdown>property-information":!0,"react-markdown>react-is":!0,"react-markdown>remark-parse":!0,"react-markdown>remark-rehype":!0,"react-markdown>space-separated-tokens":!0,"react-markdown>style-to-object":!0,"react-markdown>unified":!0,"react-markdown>unist-util-visit":!0,"react-markdown>vfile":!0}},"react-markdown>property-information":{packages:{"browserify>xtend":!0}},"react-markdown>remark-parse":{packages:{"react-markdown>remark-parse>mdast-util-from-markdown":!0}},"react-markdown>remark-parse>mdast-util-from-markdown":{packages:{"react-markdown>remark-parse>mdast-util-from-markdown>mdast-util-to-string":!0,"react-markdown>remark-parse>mdast-util-from-markdown>micromark":!0,"react-markdown>vfile>unist-util-stringify-position":!0,"react-syntax-highlighter>refractor>parse-entities":!0}},"react-markdown>remark-parse>mdast-util-from-markdown>micromark":{packages:{"react-syntax-highlighter>refractor>parse-entities":!0}},"react-markdown>remark-rehype":{packages:{"react-markdown>remark-rehype>mdast-util-to-hast":!0}},"react-markdown>remark-rehype>mdast-util-to-hast":{globals:{"console.warn":!0},packages:{"@storybook/addon-docs>remark-external-links>mdast-util-definitions":!0,"react-markdown>remark-rehype>mdast-util-to-hast>mdurl":!0,"react-markdown>remark-rehype>mdast-util-to-hast>unist-builder":!0,"react-markdown>remark-rehype>mdast-util-to-hast>unist-util-generated":!0,"react-markdown>remark-rehype>mdast-util-to-hast>unist-util-position":!0,"react-markdown>unist-util-visit":!0}},"react-markdown>style-to-object":{packages:{"react-markdown>style-to-object>inline-style-parser":!0}},"react-markdown>unified":{packages:{"mocha>yargs-unparser>is-plain-obj":!0,"react-markdown>unified>bail":!0,"react-markdown>unified>extend":!0,"react-markdown>unified>is-buffer":!0,"react-markdown>unified>trough":!0,"react-markdown>vfile":!0}},"react-markdown>unist-util-visit":{packages:{"react-markdown>unist-util-visit>unist-util-visit-parents":!0}},"react-markdown>unist-util-visit>unist-util-visit-parents":{packages:{"react-markdown>unist-util-visit>unist-util-is":!0}},"react-markdown>vfile":{globals:{"process.cwd":!0},packages:{"path-browserify":!0,process:!0,"react-markdown>vfile>is-buffer":!0,"react-markdown>vfile>replace-ext":!0,"react-markdown>vfile>vfile-message":!0}},"react-markdown>vfile>replace-ext":{packages:{"path-browserify":!0}},"react-markdown>vfile>vfile-message":{packages:{"react-markdown>vfile>unist-util-stringify-position":!0}},"react-popper":{globals:{document:!0},packages:{"@popperjs/core":!0,react:!0,"react-popper>react-fast-compare":!0}},"react-popper>react-fast-compare":{globals:{Element:!0,"console.warn":!0}},"react-redux":{globals:{document:!0},packages:{"@babel/runtime":!0,"prop-types":!0,react:!0,"react-dom":!0,"react-redux>hoist-non-react-statics":!0,"react-redux>react-is":!0}},"react-redux>hoist-non-react-statics":{packages:{"react-redux>hoist-non-react-statics>react-is":!0}},"react-router-dom":{globals:{FormData:!0,URL:!0,URLSearchParams:!0,__reactRouterVersion:"write",addEventListener:!0,confirm:!0,document:!0,history:!0,"location.href":!0,removeEventListener:!0,scrollTo:!0,scrollY:!0,"sessionStorage.getItem":!0,"sessionStorage.setItem":!0,setTimeout:!0},packages:{react:!0,"react-dom":!0,"react-router-dom>@remix-run/router":!0,"react-router-dom>react-router":!0}},"react-router-dom>@remix-run/router":{globals:{AbortController:!0,DOMException:!0,FormData:!0,Headers:!0,Request:!0,Response:!0,URL:!0,URLSearchParams:!0,console:!0,"document.defaultView":!0,history:!0}},"react-router-dom>react-router":{globals:{"console.error":!0,"console.warn":!0},packages:{react:!0,"react-router-dom>@remix-run/router":!0}},"react-simple-file-input":{globals:{File:!0,FileReader:!0,"console.warn":!0},packages:{"prop-types":!0,react:!0}},"react-syntax-highlighter>refractor>parse-entities":{globals:{"document.createElement":!0}},"react-tippy":{globals:{Element:!0,MSStream:!0,MutationObserver:!0,addEventListener:!0,clearTimeout:!0,"console.error":!0,"console.warn":!0,define:!0,document:!0,getComputedStyle:!0,innerHeight:!0,innerWidth:!0,"navigator.maxTouchPoints":!0,"navigator.msMaxTouchPoints":!0,"navigator.userAgent":!0,performance:!0,requestAnimationFrame:!0,setTimeout:!0},packages:{react:!0,"react-dom":!0,"react-tippy>popper.js":!0}},"react-tippy>popper.js":{globals:{MSInputMethodContext:!0,"Node.DOCUMENT_POSITION_FOLLOWING":!0,cancelAnimationFrame:!0,"console.warn":!0,devicePixelRatio:!0,document:!0,getComputedStyle:!0,innerHeight:!0,innerWidth:!0,"navigator.userAgent":!0,requestAnimationFrame:!0,setTimeout:!0}},"react-toggle-button":{globals:{cancelAnimationFrame:!0,clearTimeout:!0,"console.warn":!0,define:!0,performance:!0,requestAnimationFrame:!0,setTimeout:!0},packages:{react:!0}},"react-transition-group":{globals:{Element:!0,setTimeout:!0},packages:{"@babel/runtime":!0,"prop-types":!0,react:!0,"react-dom":!0,"react-transition-group>dom-helpers":!0}},"readable-stream":{globals:{AbortController:!0,AbortSignal:!0,AggregateError:!0,Blob:!0,queueMicrotask:!0},packages:{"browserify>string_decoder":!0,buffer:!0,"openai>abort-controller":!0,process:!0,"webpack>events":!0}},"readable-stream-2>core-util-is":{globals:{"Buffer.isBuffer":!0},packages:{buffer:!0}},"readable-stream-2>process-nextick-args":{globals:{process:!0},packages:{process:!0}},redux:{globals:{console:!0},packages:{"@babel/runtime":!0}},"remote-redux-devtools":{globals:{"console.log":!0,"console.warn":!0,fetch:!0,setTimeout:!0},packages:{"remote-redux-devtools>jsan":!0,"remote-redux-devtools>redux-devtools-core":!0,"remote-redux-devtools>redux-devtools-instrument":!0,"remote-redux-devtools>rn-host-detect":!0,"remote-redux-devtools>socketcluster-client":!0}},"remote-redux-devtools>jsan":{globals:{"console.warn":!0}},"remote-redux-devtools>redux-devtools-core":{globals:{ErrorUtils:!0,console:!0,devToolsOptions:!0,onerror:"write",serializeState:!0},packages:{lodash:!0,"remote-redux-devtools>jsan":!0,"remote-redux-devtools>redux-devtools-core>get-params":!0,"remote-redux-devtools>redux-devtools-core>nanoid":!0,"remote-redux-devtools>redux-devtools-core>remotedev-serialize":!0}},"remote-redux-devtools>redux-devtools-core>get-params":{globals:{GetParams:"write"}},"remote-redux-devtools>redux-devtools-instrument":{globals:{chrome:!0,"console.error":!0,process:!0,setTimeout:!0},packages:{lodash:!0,"mockttp>@httptoolkit/subscriptions-transport-ws>symbol-observable":!0,process:!0}},"remote-redux-devtools>rn-host-detect":{globals:{__DEV__:!0,__fbBatchedBridgeConfig:!0,console:!0}},"remote-redux-devtools>socketcluster-client":{globals:{WebSocket:!0,WorkerGlobalScope:!0,addEventListener:!0,clearTimeout:!0,localStorage:!0,location:!0,removeEventListener:!0,setTimeout:!0},packages:{"remote-redux-devtools>socketcluster-client>buffer":!0,"remote-redux-devtools>socketcluster-client>clone":!0,"remote-redux-devtools>socketcluster-client>component-emitter":!0,"remote-redux-devtools>socketcluster-client>linked-list":!0,"remote-redux-devtools>socketcluster-client>querystring":!0,"remote-redux-devtools>socketcluster-client>sc-channel":!0,"remote-redux-devtools>socketcluster-client>sc-errors":!0,"remote-redux-devtools>socketcluster-client>sc-formatter":!0,"remote-redux-devtools>socketcluster-client>uuid":!0}},"remote-redux-devtools>socketcluster-client>buffer":{globals:{console:!0},packages:{"base64-js":!0,"buffer>ieee754":!0}},"remote-redux-devtools>socketcluster-client>clone":{globals:{Buffer:!0},packages:{"remote-redux-devtools>socketcluster-client>buffer":!0}},"remote-redux-devtools>socketcluster-client>sc-channel":{packages:{"remote-redux-devtools>socketcluster-client>component-emitter":!0}},"remote-redux-devtools>socketcluster-client>sc-formatter":{globals:{Buffer:!0}},"remote-redux-devtools>socketcluster-client>uuid":{globals:{crypto:!0,msCrypto:!0}},reselect:{globals:{WeakRef:!0,"console.warn":!0}},semver:{globals:{"console.error":!0,process:!0},packages:{process:!0}},"stream-browserify":{packages:{"duplexify>inherits":!0,"stream-browserify>readable-stream":!0,"webpack>events":!0}},"stream-browserify>readable-stream":{globals:{"process.nextTick":!0,"process.stderr":!0,"process.stdout":!0},packages:{"@storybook/react>util-deprecate":!0,"browserify>string_decoder":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"webpack>events":!0}},"stream-http":{globals:{AbortController:!0,Blob:!0,"Buffer.alloc":!0,"Buffer.from":!0,MSStreamReader:!0,ReadableStream:!0,WritableStream:!0,XDomainRequest:!0,XMLHttpRequest:!0,clearTimeout:!0,fetch:!0,"location.protocol.search":!0,"process.nextTick":!0,setTimeout:!0},packages:{"browserify>url":!0,"browserify>xtend":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"stream-http>builtin-status-codes":!0,"stream-http>readable-stream":!0}},"stream-http>readable-stream":{globals:{"process.nextTick":!0,"process.stderr":!0,"process.stdout":!0},packages:{"@storybook/react>util-deprecate":!0,"browserify>string_decoder":!0,buffer:!0,"duplexify>inherits":!0,process:!0,"webpack>events":!0}},"string.prototype.matchall>call-bind":{packages:{"string.prototype.matchall>call-bind>call-bind-apply-helpers":!0,"string.prototype.matchall>call-bind>es-define-property":!0,"string.prototype.matchall>call-bind>set-function-length":!0,"string.prototype.matchall>get-intrinsic":!0}},"string.prototype.matchall>call-bind>call-bind-apply-helpers":{packages:{"browserify>has>function-bind":!0,"string.prototype.matchall>es-errors":!0}},"string.prototype.matchall>call-bind>set-function-length":{packages:{"eslint-plugin-react>es-iterator-helpers>has-property-descriptors":!0,"string.prototype.matchall>define-properties>define-data-property":!0,"string.prototype.matchall>es-errors":!0,"string.prototype.matchall>get-intrinsic":!0,"string.prototype.matchall>gopd":!0}},"string.prototype.matchall>call-bound":{packages:{"string.prototype.matchall>call-bind>call-bind-apply-helpers":!0,"string.prototype.matchall>get-intrinsic":!0}},"string.prototype.matchall>define-properties":{packages:{"@lavamoat/webpack>json-stable-stringify>object-keys":!0,"eslint-plugin-react>es-iterator-helpers>has-property-descriptors":!0,"string.prototype.matchall>define-properties>define-data-property":!0}},"string.prototype.matchall>define-properties>define-data-property":{packages:{"string.prototype.matchall>call-bind>es-define-property":!0,"string.prototype.matchall>es-errors":!0,"string.prototype.matchall>gopd":!0}},"string.prototype.matchall>es-abstract>array-buffer-byte-length":{packages:{"string.prototype.matchall>call-bound":!0,"string.prototype.matchall>es-abstract>is-array-buffer":!0}},"string.prototype.matchall>es-abstract>available-typed-arrays":{packages:{"string.prototype.matchall>es-abstract>typed-array-length>possible-typed-array-names":!0}},"string.prototype.matchall>es-abstract>es-to-primitive>is-symbol":{packages:{"string.prototype.matchall>call-bound":!0,"string.prototype.matchall>es-abstract>safe-regex-test":!0,"string.prototype.matchall>has-symbols":!0}},"string.prototype.matchall>es-abstract>get-proto":{packages:{"eslint-plugin-react>es-iterator-helpers>has-proto>dunder-proto":!0,"string.prototype.matchall>es-object-atoms":!0}},"string.prototype.matchall>es-abstract>is-array-buffer":{packages:{"string.prototype.matchall>call-bind":!0,"string.prototype.matchall>call-bound":!0,"string.prototype.matchall>get-intrinsic":!0}},"string.prototype.matchall>es-abstract>is-callable":{globals:{document:!0}},"string.prototype.matchall>es-abstract>is-regex":{packages:{"eslint-plugin-react>hasown":!0,"jsdom>form-data>es-set-tostringtag>has-tostringtag":!0,"string.prototype.matchall>call-bound":!0,"string.prototype.matchall>gopd":!0}},"string.prototype.matchall>es-abstract>is-shared-array-buffer":{packages:{"string.prototype.matchall>call-bound":!0}},"string.prototype.matchall>es-abstract>object-inspect":{globals:{HTMLElement:!0,WeakRef:!0}},"string.prototype.matchall>es-abstract>safe-regex-test":{packages:{"string.prototype.matchall>call-bound":!0,"string.prototype.matchall>es-abstract>is-regex":!0,"string.prototype.matchall>es-errors":!0}},"string.prototype.matchall>es-abstract>stop-iteration-iterator":{globals:{StopIteration:!0},packages:{"string.prototype.matchall>es-errors":!0,"string.prototype.matchall>internal-slot":!0}},"string.prototype.matchall>es-abstract>typed-array-buffer":{packages:{"browserify>util>is-typed-array":!0,"string.prototype.matchall>call-bound":!0,"string.prototype.matchall>es-errors":!0}},"string.prototype.matchall>get-intrinsic":{globals:{AggregateError:!0,Atomics:!0,FinalizationRegistry:!0,Float16Array:!0,SharedArrayBuffer:!0,WeakRef:!0},packages:{"browserify>has>function-bind":!0,"eslint-plugin-react>array-includes>math-intrinsics":!0,"eslint-plugin-react>hasown":!0,"string.prototype.matchall>call-bind>call-bind-apply-helpers":!0,"string.prototype.matchall>call-bind>es-define-property":!0,"string.prototype.matchall>es-abstract>get-proto":!0,"string.prototype.matchall>es-errors":!0,"string.prototype.matchall>es-object-atoms":!0,"string.prototype.matchall>get-intrinsic>async-function":!0,"string.prototype.matchall>get-intrinsic>async-generator-function":!0,"string.prototype.matchall>get-intrinsic>generator-function":!0,"string.prototype.matchall>gopd":!0,"string.prototype.matchall>has-symbols":!0}},"string.prototype.matchall>internal-slot":{packages:{"eslint-plugin-react>hasown":!0,"string.prototype.matchall>es-errors":!0,"string.prototype.matchall>side-channel":!0}},"string.prototype.matchall>regexp.prototype.flags":{packages:{"string.prototype.matchall>call-bind":!0,"string.prototype.matchall>define-properties":!0,"string.prototype.matchall>es-abstract>get-proto":!0,"string.prototype.matchall>es-errors":!0,"string.prototype.matchall>gopd":!0,"string.prototype.matchall>set-function-name":!0}},"string.prototype.matchall>set-function-name":{packages:{"eslint-plugin-react>es-iterator-helpers>has-property-descriptors":!0,"string.prototype.matchall>define-properties>define-data-property":!0,"string.prototype.matchall>es-errors":!0,"string.prototype.matchall>set-function-name>functions-have-names":!0}},"string.prototype.matchall>side-channel":{packages:{"string.prototype.matchall>es-abstract>object-inspect":!0,"string.prototype.matchall>es-errors":!0,"string.prototype.matchall>side-channel>side-channel-list":!0,"string.prototype.matchall>side-channel>side-channel-map":!0,"string.prototype.matchall>side-channel>side-channel-weakmap":!0}},"string.prototype.matchall>side-channel>side-channel-list":{packages:{"string.prototype.matchall>es-abstract>object-inspect":!0,"string.prototype.matchall>es-errors":!0}},"string.prototype.matchall>side-channel>side-channel-map":{packages:{"string.prototype.matchall>call-bound":!0,"string.prototype.matchall>es-abstract>object-inspect":!0,"string.prototype.matchall>es-errors":!0,"string.prototype.matchall>get-intrinsic":!0}},"string.prototype.matchall>side-channel>side-channel-weakmap":{packages:{"string.prototype.matchall>call-bound":!0,"string.prototype.matchall>es-abstract>object-inspect":!0,"string.prototype.matchall>es-errors":!0,"string.prototype.matchall>get-intrinsic":!0,"string.prototype.matchall>side-channel>side-channel-map":!0}},tslib:{globals:{SuppressedError:!0}},tweetnacl:{globals:{crypto:!0,msCrypto:!0,nacl:"write"}},"uri-js":{globals:{define:!0}},uuid:{globals:{crypto:!0,msCrypto:!0}},viem:{globals:{TextDecoder:!0,TextEncoder:!0},packages:{"@noble/hashes":!0}},"wait-on>axios":{globals:{AbortController:!0,Blob:!0,Buffer:!0,FormData:!0,ReadableStream:!0,Request:!0,Response:!0,TextEncoder:!0,URL:!0,URLSearchParams:!0,WorkerGlobalScope:!0,XMLHttpRequest:!0,btoa:!0,clearTimeout:!0,"console.warn":!0,document:!0,fetch:!0,importScripts:!0,"location.href":!0,navigator:!0,postMessage:!0,process:!0,queueMicrotask:!0,setImmediate:!0,setTimeout:!0},packages:{buffer:!0,"core-js-pure":!0,process:!0}},"wait-on>rxjs":{globals:{clearTimeout:!0,"setTimeout.apply":!0},packages:{tslib:!0}},"web-vitals":{globals:{"PerformanceEventTiming.prototype":!0,PerformanceObserver:!0,addEventListener:!0,"document.addEventListener":!0,"document.prerendering":!0,"document.readyState":!0,"document.visibilityState":!0,"document.wasDiscarded":!0,performance:!0,removeEventListener:!0,requestAnimationFrame:!0,requestIdleCallback:!0,setTimeout:!0}},"webextension-polyfill":{globals:{browser:!0,chrome:!0,"console.error":!0,"console.warn":!0,define:!0}},"webpack>events":{globals:{console:!0}}}},e.ENUM={NAME_globalThis:"G",NAME_scopeTerminator:"ST",NAME_runtimeHandler:"RH",RUNTIME_KEY:"_LM_"},(()=>{let t={exports:{}};function r(e,t){return e&&0!==e.length?`${e}.${t}`:t}function n(e,t,n){let s=Reflect.getOwnPropertyDescriptor(t,e[0])?.enumerable,a=n,o="";for(let t=0;t<e.length-1;t++){o=r(o,e[t]);let n=e[t];if(Reflect.getOwnPropertyDescriptor(a,n)?.get)throw Error(`LavaMoat - "${e[0]}" is writeable elsewhere and both "${o}" and "${e.join(".")}" are allowed for one package. One of these entries is redundant.`);"object"!=typeof a[n]&&(a[n]={}),a=a[n]}Reflect.defineProperty(a,e[e.length-1],{get:()=>{let r=t[e[0]],n=t;for(let t=1;t<e.length;t++)n=r,r=r[e[t]];return"function"==typeof r&&(r=r.bind(n)),r},writeable:!1,enumerable:s,configurable:!1})}function s(e,t,r){let n=function(){return new.target?Reflect.construct(e,arguments,new.target):Reflect.apply(e,t(this)?r:this,arguments)};return Object.defineProperties(n,Object.getOwnPropertyDescriptors(e)),Reflect.getPrototypeOf(n)!==Reflect.getPrototypeOf(e)&&Object.setPrototypeOf(n,Reflect.getPrototypeOf(e)),n}t.exports,t.exports=function({createFunctionWrapper:e=s,handleGlobalWrite:t=!1,knownWritableFields:a=new Set}={}){return{getEndowmentsForConfig:function(e,r,n,s){if(!r.globals)return{};let a=[],i=new Set,l=[];return Object.entries(r.globals).forEach(([e,r])=>{let n=e.split(".");if(n.some(e=>"__proto__"===e))throw Error(`Lavamoat - "__proto__" disallowed when creating minimal view. saw "${e}"`);if(!1===r)return void l.push(e);if("write"===r){if(!t)return;if(n.length>1)throw Error(`LavaMoat - write access is only allowed at the top level, saw "${e}"`);i.add(e),a.push(e);return}if(!0!==r)throw Error(`LavaMoat - unrecognizable policy value (${typeof r}) for path "${e}"`);a.push(e)}),a.sort((e,t)=>e.length-t.length),o(e,a,n,s,l,i)},copyWrappedGlobals:function(e,t,r=["globalThis"]){let n=function(e){let t=[],r=e;for(;r&&("object"==typeof r||"function"==typeof r);)t.push(r),r=Reflect.getPrototypeOf(r);return t}(e),s=n.findIndex(e=>e===Object.prototype),a=-1===s;a&&(s=n.length);let o=n.slice(0,s);o.forEach(t=>{Object.values(Object.getOwnPropertyDescriptors(t)).forEach(t=>{if("get"in t&&t.get)try{Reflect.apply(t.get,e,[])}catch{}})});let i=o.map((e,t)=>{let r=Object.getOwnPropertyDescriptors(e);return a&&t===o.length-1?Object.fromEntries(Object.entries(r).filter(([e])=>!(e in Object.prototype))):r});for(let n of(Object.entries(Object.assign(Object.create(null),...i.reverse())).filter(([e])=>!(e in t)).filter(([e])=>!r.includes(e)).forEach(([r,n])=>{let s=c(n,t,e);Reflect.defineProperty(t,r,s)}),r))n in t||(t[n]=t);return t},getBuiltinForConfig:function(e,t,r){let n=[],s=[];return Object.entries(r).forEach(([e,r])=>{let a=e.split(".");if(t===a[0]){let e=a.slice(1).join(".");!0===r?n.push(e):!1===r&&s.push(e)}}),i(e,n,s)},createFunctionWrapper:e,attenuateBuiltin:i,makeMinimalViewOfRef:o,copyValueAtPath:l,applyGetSetPropDescTransforms:u,applyEndowmentPropDescTransforms:c};function o(e,t,r,s,i=[],c=new Set){let u={};return t.forEach(t=>{let o=t.split(".");a.has(o[0])?c.has(o[0])?function(e,t,r){let n=Reflect.getOwnPropertyDescriptor(t,e)?.enumerable;Reflect.defineProperty(r,e,{configurable:!1,enumerable:n,set(r){t[e]=r},get:()=>t[e]})}(o[0],e,u):n(o,e,u):l("",o,i,e,u,r,s)}),u}function i(e,t,r=[]){return o(e,t.sort(),void 0,void 0,r)}function l(t,n,s,a,o,i=a,c=o){if(0===n.length)throw Error("unable to copy, must have pathParts, was empty");let[m,...d]=n,p=r(t,m),{prop:h}=function(e,t){let r=e;for(;;){if(!r)return{prop:null,receiver:null};let e=typeof r;if("object"===e||"function"===e){let e=Reflect.getOwnPropertyDescriptor(r,t);if(e)return{receiver:r,prop:e};r=Reflect.getPrototypeOf(r)}else r=r.__proto__}}(a,m);if(!h)return;let f=Reflect.getOwnPropertyDescriptor(o,m);if(f){if(!("value"in f))throw Error(`unable to copy on to targetRef, targetRef has a getter at "${p}"`);let e=typeof f.value;if("object"!==e&&"function"!==e)throw Error(`unable to copy on to targetRef, targetRef value is not an obj or func at "${p}"`)}if(d.length>0){let e,{sourceValue:t,sourceWritable:r}=b(h);if(f&&!s.includes(p))e=f.value;else{let t={};Reflect.defineProperty(o,m,{value:t,writable:r,enumerable:h.enumerable,configurable:h.configurable}),e=t}l(p,d,s,t,e);return}if(s.includes(p))return void console.warn(`LavaMoat - conflicting rules exist for "${p}"`);if(!("value"in h))return void Reflect.defineProperty(o,m,u(h,c,i));let{sourceValue:g,sourceWritable:y}=b(h);if("function"!=typeof g)return void Reflect.defineProperty(o,m,h);function b(e){let t,r;if("value"in e)t=e.value,r=e.writable;else if("get"in e&&e.get)t=e.get.call(i),r="set"in e;else throw Error("getEndowmentsForConfig - property descriptor missing a getter");return{sourceValue:t,sourceWritable:r}}Reflect.defineProperty(o,m,{value:e(g,e=>e===c,i),writable:y,enumerable:h.enumerable,configurable:h.configurable})}function c(t,r,n){let s=t;return u(s=function(t,r,n){if(!("value"in t&&"function"==typeof t.value))return t;let s=e(t.value,e=>e===r,n);return{...t,value:s}}(s,r,n),r,n)}function u(t,r,n){let s={...t};return t.get&&(s.get=function(){let s=Reflect.apply(t.get,this===r?n:this,[]);return"function"==typeof s?e(s,e=>e===r,n):s}),t.set&&(s.set=function(e){let s=this===r?n:this;return Reflect.apply(t.set,s,[e])}),s}},t.exports.defaultCreateFunctionWrapper=s,t.exports._test={instrumentDynamicValueAtPath:n},e.endowmentsToolkit=t.exports})(),(()=>{let t={exports:{}},r=t.exports;"event"in globalThis&&(globalThis.event=void 0);let{getOwnPropertyNames:n}=Object;function s(e){let t=[],r=e;for(;r&&("object"==typeof r||"function"==typeof r);)t.push(r),r=Reflect.getPrototypeOf(r);return t}!function(e){if("window"in e&&"object"==typeof e.window&&e!==e.window){let t=e.window,r=s(t),a=s(e);r.pop();let o=r.flatMap(e=>n(e)),i=new Set(a.flatMap(e=>n(e)));for(let r of o)if(!i.has(r)&&r in globalThis&&void 0!==t[r])try{e[r]=e[r]}catch{}}}(globalThis);let{defineProperty:a}=Object,{call:o}=Function.prototype,i=new WeakMap,l=globalThis,c=MessageEvent.prototype,u=new Compartment().globalThis,m=Object.getOwnPropertyDescriptor(c,"source");if(m&&m.get){let e=o.bind(m.get);a(c,"source",{...m,get(){let t=e(this);return t===l||t===l.window?i.get(this)||u:t}})}r.MessageEvent=(e,t,r)=>{let n=e.MessageEvent;n&&(e.MessageEvent=function(e,t){let s=new n(e,t);return i.set(s,r),s},e.MessageEvent.prototype=n.prototype)},r.addEventListener=(e,t,r)=>{let n=e.addEventListener;n&&(e.addEventListener=(e,s,a)=>"message"===e?n.call(t,e,e=>(i.set(e,r),s.call(r,e)),a):n.call(r,e,s,a))},e.repairs=t.exports})(),(()=>{let t,r={exports:{}};r.exports;let{repairIntrinsics:n}=globalThis,s="object"==typeof console?console.warn:()=>{},a=void 0!==n;a?(n(e.options.lockdown),i.forEach(e=>{e()}),hardenIntrinsics()):s("LavaMoatPlugin: runtime execution started without SES present, switching to no-op.");let{keys:o,create:l,freeze:c,assign:u,defineProperty:m,defineProperties:d,getOwnPropertyDescriptors:p,fromEntries:h,entries:f,values:g}=Object,{Proxy:y,Math:b,Date:k}=globalThis,{harden:v}=globalThis,_=new Set;g(e.policy.resources).forEach(e=>{e.globals&&"object"==typeof e.globals&&f(e.globals).forEach(([e,t])=>{"write"===t&&_.add(e)})});let{getEndowmentsForConfig:w,copyWrappedGlobals:x,getBuiltinForConfig:S}=e.endowmentsToolkit({handleGlobalWrite:!0,knownWritableFields:_}),{NAME_globalThis:E,NAME_scopeTerminator:j,NAME_runtimeHandler:T}=e.ENUM,A=c(new y(c(l(null)),c({has:c(()=>!0)}))),C=globalThis,I=["window","self","global","globalThis","frames"],O=o(e.repairs||{}),M=new Map,N=t=>{let r=e.idmap.find(([,e])=>e.includes(t));if(r)return r[0]};e.defaultExport=c((r,n)=>{if(!a)return l(null);if(!M.has(r)){let n=new Compartment({Math:b,Date:k});((r,n)=>{if(r===e.root)x(C,t=n,I),e?.scuttling?.scuttle(C,e.options?.scuttleGlobalThis);else{let s=e.policy.resources[r]||{},a=w(t,s,globalThis,n);O.length>0&&s.globals&&o(s.globals).length>0&&O.forEach(t=>{if(a[t]){let r=e.repairs[t];r&&r(a,C,n)}}),d(n,{...p(a),...h(I.map(e=>[e,{value:n}]))}),e.debug&&e.debug.debugProxy(n,t,r)}})(r,n.globalThis),M.set(r,n)}let i=l(null),{__webpack_require__:f}=n,{module:g}=n;if(f){let t=function(t,...n){"number"!=typeof t&&(t=`${t}`);let s=f.bind(this,t,...n);var a=t;if(void 0===a)throw Error("Requested specifier is undefined");if(e.unenforceable.includes(a)||r===e.root)return s();let i=e.policy.resources[r]||{};if(e.externals[a]){let t=e.externals[a];if(i.builtin){if(i.builtin[t])return s();if(t&&!t.includes(".")&&o(i.builtin).some(e=>e.startsWith(`${t}.`)))return S(s(),t,i.builtin)}if(i.packages){let e=N(t);if(e&&i.packages[e])return s()}}let l=N(a);if(!l){if(e.ctxm.includes(a))throw Error(`'${r}' is trying to load a module dynamically from a dependency it has not been allowed using the following Webpack Context Module: '${a}'`);throw Error(`Requested specifier '${a}' is not allowed as a builtin and is not a known dependency of '${r}'; regenerate policy or add it to policy-override.json.`)}if(l===r||i.packages?.[l])return s();throw Error(`Policy does not allow importing ${l} from ${r}`)};for(let n of(t.e=t=>{if(!e.kch.includes(t))throw Error(`Attempt to load a chunk that was not known at compile time: ${t} from ${r}`);return f.e(t)},["O","n","d","o","r","s","t","b","j"]))t[n]=v(f[n]);t.m=new y({},{has:(e,t)=>(s(`A module attempted to read ${String(t)} directly from webpack's module cache`),!1)}),t.g=M.get(r).globalThis,t.nmd=e=>e===g?f.nmd(g):e,t.hmd=e=>e===g?f.hmd(g):e,i.__webpack_require__=t}let _=u(l(null),n,i);m(_,"module",{get:()=>g,set:()=>{}});let D=_.exports;return m(_,"exports",{get:()=>D,set:e=>{D=e}}),c(_),c(u(l(null),{[j]:A,[T]:_,[E]:M.get(r).globalThis}))}),e.runtime=r.exports})(),r._LM_=e.defaultExport,"undefined"!=typeof harden&&harden(r._LM_)})(),(()=>{"use strict";r(362705);var e=r(555974),t=r(733477);let{chrome:n}=globalThis;function s(){let e=new Date().toISOString();n.storage.session.set({timestamp:e})}s(),setInterval(s,2e3);let a=new t.u(n,{runtime:["onInstalled","onConnect"]});globalThis.stateHooks.lazyListener=a;let i=!1;async function l(){if(i)return;i=!0;let e=performance.now();await Promise.all([r.e(7354),r.e(392),r.e(4633),r.e(8790),r.e(9171),r.e(9523),r.e(6428),r.e(3288),r.e(2913),r.e(4813),r.e(2806),r.e(8190),r.e(6843),r.e(5580),r.e(1620),r.e(388),r.e(6714),r.e(5917),r.e(2040),r.e(7568),r.e(9424),r.e(74)]).then(r.bind(r,600193));let t=performance.now();console.log(`importScripts completed in ${(t-e)/1e3} seconds`)}o.addEventListener("install",l),n.runtime.onConnect.addListener(t=>{console.log("MetaMask service worker: Received connection from port",t.name);try{t.postMessage({data:{method:e.pr},name:"app-init-liveness"})}catch(e){console.error("MetaMask - app-init-liveness check: Failed to message to port",e)}}),"activated"===o.serviceWorker.state&&l()})()})();