/* Partytown 0.7.5 - MIT builder.io */
((self) => {
  const WinIdKey = Symbol();
  const InstanceIdKey = Symbol();
  const InstanceDataKey = Symbol();
  const NamespaceKey = Symbol();
  const ApplyPathKey = Symbol();
  const InstanceStateKey = Symbol();
  const HookContinue = Symbol();
  const HookPrevent = Symbol();
  const webWorkerInstances = new Map();
  const webWorkerRefsByRefId = {};
  const webWorkerRefIdsByRef = new WeakMap();
  const postMessages = [];
  const webWorkerCtx = {};
  const webWorkerlocalStorage = new Map();
  const webWorkerSessionStorage = new Map();
  const environments = {};
  const cachedDimensions = new Map();
  const cachedStructure = new Map();
  const commaSplit = (str) => str.split(",");
  const partytownLibUrl = (url) => {
    url = webWorkerCtx.$libPath$ + url;
    if (new URL(url).origin != location.origin) {
      throw "Invalid " + url;
    }
    return url;
  };
  const getterDimensionPropNames = commaSplit(
    "clientWidth,clientHeight,clientTop,clientLeft,innerWidth,innerHeight,offsetWidth,offsetHeight,offsetTop,offsetLeft,outerWidth,outerHeight,pageXOffset,pageYOffset,scrollWidth,scrollHeight,scrollTop,scrollLeft"
  );
  const elementStructurePropNames = commaSplit(
    "childElementCount,children,firstElementChild,lastElementChild,nextElementSibling,previousElementSibling"
  );
  const structureChangingMethodNames = commaSplit(
    "insertBefore,remove,removeChild,replaceChild"
  );
  const dimensionChangingSetterNames = commaSplit(
    "className,width,height,hidden,innerHTML,innerText,textContent"
  );
  const dimensionChangingMethodNames = commaSplit(
    "setAttribute,setAttributeNS,setProperty"
  );
  const eventTargetMethods = commaSplit(
    "addEventListener,dispatchEvent,removeEventListener"
  );
  const nonBlockingMethods = eventTargetMethods.concat(
    dimensionChangingMethodNames,
    commaSplit("add,observe,remove,unobserve")
  );
  const IS_TAG_REG = /^[A-Z_]([A-Z0-9-]*[A-Z0-9])?$/;
  const noop = () => {};
  const len = (obj) => obj.length;
  const getConstructorName = (obj) => {
    var _a, _b, _c;
    try {
      const constructorName =
        null === (_a = null == obj ? void 0 : obj.constructor) || void 0 === _a
          ? void 0
          : _a.name;
      if (constructorName) {
        return constructorName;
      }
    } catch (e) {}
    try {
      const zoneJsConstructorName =
        null ===
          (_c =
            null ===
              (_b =
                null == obj ? void 0 : obj.__zone_symbol__originalInstance) ||
            void 0 === _b
              ? void 0
              : _b.constructor) || void 0 === _c
          ? void 0
          : _c.name;
      if (zoneJsConstructorName) {
        return zoneJsConstructorName;
      }
    } catch (e) {}
    return "";
  };
  const EMPTY_ARRAY = [];
  const randomId = () =>
    Math.round(Math.random() * Number.MAX_SAFE_INTEGER).toString(36);
  const SCRIPT_TYPE = "text/partytown";
  const defineProperty = (obj, memberName, descriptor) =>
    Object.defineProperty(obj, memberName, {
      ...descriptor,
      configurable: true,
    });
  const defineConstructorName = (Cstr, value) =>
    defineProperty(Cstr, "name", {
      value: value,
    });
  const definePrototypeProperty = (Cstr, memberName, descriptor) =>
    defineProperty(Cstr.prototype, memberName, descriptor);
  const definePrototypePropertyDescriptor = (Cstr, propertyDescriptorMap) =>
    Object.defineProperties(Cstr.prototype, propertyDescriptorMap);
  const definePrototypeValue = (Cstr, memberName, value) =>
    definePrototypeProperty(Cstr, memberName, {
      value: value,
      writable: true,
    });
  const hasInstanceStateValue = (instance, stateKey) =>
    stateKey in instance[InstanceStateKey];
  const getInstanceStateValue = (instance, stateKey) =>
    instance[InstanceStateKey][stateKey];
  const setInstanceStateValue = (instance, stateKey, stateValue) =>
    (instance[InstanceStateKey][stateKey] = stateValue);
  const setWorkerRef = (ref, refId) => {
    if (!(refId = webWorkerRefIdsByRef.get(ref))) {
      webWorkerRefIdsByRef.set(ref, (refId = randomId()));
      webWorkerRefsByRefId[refId] = ref;
    }
    return refId;
  };
  const getOrCreateNodeInstance = (
    winId,
    instanceId,
    nodeName,
    namespace,
    instance
  ) => {
    instance = webWorkerInstances.get(instanceId);
    if (!instance && nodeName && environments[winId]) {
      instance = environments[winId].$createNode$(
        nodeName,
        instanceId,
        namespace
      );
      webWorkerInstances.set(instanceId, instance);
    }
    return instance;
  };
  const definePrototypeNodeType = (Cstr, nodeType) =>
    definePrototypeValue(Cstr, "nodeType", nodeType);
  const cachedTreeProps = (Cstr, treeProps) =>
    treeProps.map((propName) =>
      definePrototypeProperty(Cstr, propName, {
        get() {
          let cacheKey = getInstanceCacheKey(this, propName);
          let result = cachedStructure.get(cacheKey);
          if (!result) {
            result = getter(this, [propName]);
            cachedStructure.set(cacheKey, result);
          }
          return result;
        },
      })
    );
  const getInstanceCacheKey = (instance, memberName, args) =>
    [
      instance[WinIdKey],
      instance[InstanceIdKey],
      memberName,
      ...(args || EMPTY_ARRAY).map((arg) =>
        String(arg && arg[WinIdKey] ? arg[InstanceIdKey] : arg)
      ),
    ].join(".");
  const cachedProps = (Cstr, propNames) =>
    commaSplit(propNames).map((propName) =>
      definePrototypeProperty(Cstr, propName, {
        get() {
          hasInstanceStateValue(this, propName) ||
            setInstanceStateValue(this, propName, getter(this, [propName]));
          return getInstanceStateValue(this, propName);
        },
        set(val) {
          getInstanceStateValue(this, propName) !== val &&
            setter(this, [propName], val);
          setInstanceStateValue(this, propName, val);
        },
      })
    );
  const cachedDimensionProps = (Cstr) =>
    getterDimensionPropNames.map((propName) =>
      definePrototypeProperty(Cstr, propName, {
        get() {
          const dimension = cachedDimensions.get(
            getInstanceCacheKey(this, propName)
          );
          if ("number" == typeof dimension) {
            return dimension;
          }
          const groupedDimensions = getter(
            this,
            [propName],
            getterDimensionPropNames
          );
          if (groupedDimensions && "object" == typeof groupedDimensions) {
            Object.entries(groupedDimensions).map(
              ([dimensionPropName, value]) =>
                cachedDimensions.set(
                  getInstanceCacheKey(this, dimensionPropName),
                  value
                )
            );
            return groupedDimensions[propName];
          }
          return groupedDimensions;
        },
      })
    );
  const cachedDimensionMethods = (Cstr, dimensionMethodNames) =>
    dimensionMethodNames.map((methodName) => {
      Cstr.prototype[methodName] = function (...args) {
        let cacheKey = getInstanceCacheKey(this, methodName, args);
        let dimensions = cachedDimensions.get(cacheKey);
        if (!dimensions) {
          dimensions = callMethod(this, [methodName], args);
          cachedDimensions.set(cacheKey, dimensions);
        }
        return dimensions;
      };
    });
  const serializeForMain = ($winId$, $instanceId$, value, added, type) =>
    void 0 !== value && (type = typeof value)
      ? "string" === type ||
        "boolean" === type ||
        "number" === type ||
        null == value
        ? [0, value]
        : "function" === type
        ? [
            4,
            {
              $winId$: $winId$,
              $instanceId$: $instanceId$,
              $refId$: setWorkerRef(value),
            },
          ]
        : (added = added || new Set()) && Array.isArray(value)
        ? added.has(value)
          ? [1, []]
          : added.add(value) && [
              1,
              value.map((v) =>
                serializeForMain($winId$, $instanceId$, v, added)
              ),
            ]
        : "object" === type
        ? value[InstanceIdKey]
          ? [3, [value[WinIdKey], value[InstanceIdKey]]]
          : value instanceof Event
          ? [
              5,
              serializeObjectForMain(
                $winId$,
                $instanceId$,
                value,
                false,
                added
              ),
            ]
          : supportsTrustedHTML && value instanceof TrustedHTML
          ? [0, value.toString()]
          : value instanceof ArrayBuffer
          ? [8, value]
          : ArrayBuffer.isView(value)
          ? [9, value.buffer, getConstructorName(value)]
          : [
              2,
              serializeObjectForMain($winId$, $instanceId$, value, true, added),
            ]
        : void 0
      : value;
  const supportsTrustedHTML = "undefined" != typeof TrustedHTML;
  const serializeObjectForMain = (
    winId,
    instanceId,
    obj,
    includeFunctions,
    added,
    serializedObj,
    propName,
    propValue
  ) => {
    serializedObj = {};
    if (!added.has(obj)) {
      added.add(obj);
      for (propName in obj) {
        propValue = obj[propName];
        (includeFunctions || "function" != typeof propValue) &&
          (serializedObj[propName] = serializeForMain(
            winId,
            instanceId,
            propValue,
            added
          ));
      }
    }
    return serializedObj;
  };
  const serializeInstanceForMain = (instance, value) =>
    instance
      ? serializeForMain(instance[WinIdKey], instance[InstanceIdKey], value)
      : [0, value];
  const deserializeFromMain = (
    winId,
    instanceId,
    applyPath,
    serializedValueTransfer,
    serializedType,
    serializedValue,
    obj,
    key
  ) => {
    if (serializedValueTransfer) {
      serializedType = serializedValueTransfer[0];
      serializedValue = serializedValueTransfer[1];
      if (
        0 === serializedType ||
        11 === serializedType ||
        12 === serializedType
      ) {
        return serializedValue;
      }
      if (4 === serializedType) {
        return deserializeRefFromMain(applyPath, serializedValue);
      }
      if (6 === serializedType) {
        return winId && applyPath.length > 0
          ? (...args) =>
              callMethod(environments[winId].$window$, applyPath, args, 1)
          : noop;
      }
      if (3 === serializedType) {
        return getOrCreateSerializedInstance(serializedValue);
      }
      if (7 === serializedType) {
        return new NodeList(serializedValue.map(getOrCreateSerializedInstance));
      }
      if (10 === serializedType) {
        return new Attr(serializedValue);
      }
      if (1 === serializedType) {
        return serializedValue.map((v) =>
          deserializeFromMain(winId, instanceId, applyPath, v)
        );
      }
      if (14 === serializedType) {
        return new CustomError(serializedValue);
      }
      obj = {};
      for (key in serializedValue) {
        obj[key] = deserializeFromMain(
          winId,
          instanceId,
          [...applyPath, key],
          serializedValue[key]
        );
      }
      if (13 === serializedType) {
        return new environments[winId].$window$.CSSStyleDeclaration(
          winId,
          instanceId,
          applyPath,
          obj
        );
      }
      if (5 === serializedType) {
        if ("message" === obj.type && obj.origin) {
          let postMessageKey = JSON.stringify(obj.data);
          let postMessageData = postMessages.find(
            (pm) => pm.$data$ === postMessageKey
          );
          let env;
          if (postMessageData) {
            env = environments[postMessageData.$winId$];
            if (env) {
              obj.source = env.$window$;
              obj.origin = env.$location$.origin;
            }
          }
        }
        return new Proxy(new Event(obj.type, obj), {
          get: (target, propName) =>
            propName in obj
              ? obj[propName]
              : "function" == typeof target[String(propName)]
              ? noop
              : target[String(propName)],
        });
      }
      if (2 === serializedType) {
        return obj;
      }
    }
  };
  const getOrCreateSerializedInstance = ([winId, instanceId, nodeName]) =>
    instanceId === winId && environments[winId]
      ? environments[winId].$window$
      : getOrCreateNodeInstance(winId, instanceId, nodeName);
  const deserializeRefFromMain = (
    applyPath,
    {
      $winId$: $winId$,
      $instanceId$: $instanceId$,
      $nodeName$: $nodeName$,
      $refId$: $refId$,
    }
  ) => {
    webWorkerRefsByRefId[$refId$] ||
      webWorkerRefIdsByRef.set(
        (webWorkerRefsByRefId[$refId$] = function (...args) {
          const instance = getOrCreateNodeInstance(
            $winId$,
            $instanceId$,
            $nodeName$
          );
          return callMethod(instance, applyPath, args);
        }),
        $refId$
      );
    return webWorkerRefsByRefId[$refId$];
  };
  class CustomError extends Error {
    constructor(errorObject) {
      super(errorObject.message);
      this.name = errorObject.name;
      this.message = errorObject.message;
      this.stack = errorObject.stack;
    }
  }
  class NodeList {
    constructor(nodes) {
      (this._ = nodes).map((node, index) => (this[index] = node));
    }
    entries() {
      return this._.entries();
    }
    forEach(cb, thisArg) {
      this._.map(cb, thisArg);
    }
    item(index) {
      return this[index];
    }
    keys() {
      return this._.keys();
    }
    get length() {
      return len(this._);
    }
    values() {
      return this._.values();
    }
    [Symbol.iterator]() {
      return this._[Symbol.iterator]();
    }
  }
  const Attr = class {
    constructor(serializedAttr) {
      this.name = serializedAttr[0];
      this.value = serializedAttr[1];
    }
    get nodeName() {
      return this.name;
    }
    get nodeType() {
      return 2;
    }
  };
  const warnCrossOrgin = (apiType, apiName, env) =>
    console.warn(
      `Partytown unable to ${apiType} cross-origin ${apiName}: ` +
        env.$location$
    );
  const logWorker = (msg, winId) => {
    try {
      const config = webWorkerCtx.$config$;
      if (config.logStackTraces) {
        const frames = new Error().stack.split("\n");
        const i = frames.findIndex((f) => f.includes("logWorker"));
        msg += "\n" + frames.slice(i + 1).join("\n");
      }
      let prefix;
      let color;
      if (winId) {
        prefix = `Worker (${normalizedWinId(winId)}) 🎉`;
        color = winColor(winId);
      } else {
        prefix = self.name;
        color = "#9844bf";
      }
      if (webWorkerCtx.lastLog !== msg) {
        webWorkerCtx.lastLog = msg;
        console.debug.apply(console, [
          `%c${prefix}`,
          `background: ${color}; color: white; padding: 2px 3px; border-radius: 2px; font-size: 0.8em;`,
          msg,
        ]);
      }
    } catch (e) {}
  };
  const winIds = [];
  const normalizedWinId = (winId) => {
    winIds.includes(winId) || winIds.push(winId);
    return winIds.indexOf(winId) + 1;
  };
  const winColor = (winId) => {
    const colors = ["#00309e", "#ea3655", "#eea727"];
    const index = normalizedWinId(winId) - 1;
    return colors[index] || colors[colors.length - 1];
  };
  const getTargetProp = (target, applyPath) => {
    let n = "";
    if (target) {
      const cstrName = getConstructorName(target);
      if ("Window" === cstrName) {
        n = "";
      } else if ("string" == typeof target[InstanceDataKey]) {
        let nodeName = target[InstanceDataKey];
        n =
          "#text" === nodeName
            ? "textNode."
            : "#comment" === nodeName
            ? "commentNode."
            : "#document" === nodeName
            ? "document."
            : "html" === nodeName
            ? "doctype."
            : nodeName.toLowerCase() + ".";
      } else {
        n =
          "nodeType" in target && 2 === target.nodeType
            ? "attributes."
            : "CanvasRenderingContext2D" === cstrName
            ? "context2D."
            : "CanvasRenderingContextWebGL" === cstrName
            ? "contextWebGL."
            : "CSSStyleDeclaration" === cstrName
            ? "style."
            : "MutationObserver" === cstrName
            ? "mutationObserver."
            : "NamedNodeMap" === cstrName
            ? "namedNodeMap."
            : "ResizeObserver" === cstrName
            ? "resizeObserver."
            : cstrName.substring(0, 1).toLowerCase() +
              cstrName.substring(1) +
              ".";
      }
      target[ApplyPathKey] &&
        target[ApplyPathKey].length &&
        (n += [...target[ApplyPathKey]].join(".") + ".");
    }
    if (applyPath.length > 1) {
      const first = applyPath.slice(0, applyPath.length - 1);
      const last = applyPath[applyPath.length - 1];
      if (!isNaN(last)) {
        return n + `${first.join(".")}[${last}]`;
      }
    }
    return n + applyPath.join(".");
  };
  const getLogValue = (applyPath, v) => {
    const type = typeof v;
    if (void 0 === v) {
      return "undefined";
    }
    if ("boolean" === type || "number" === type || null == v) {
      return JSON.stringify(v);
    }
    if ("string" === type) {
      return applyPath.includes("cookie")
        ? JSON.stringify(v.slice(0, 10) + "...")
        : JSON.stringify(v.length > 50 ? v.slice(0, 40) + "..." : v);
    }
    if (Array.isArray(v)) {
      return `[${v.map(getLogValue).join(", ")}]`;
    }
    if ("object" === type) {
      const instanceId = v[InstanceIdKey];
      const cstrName = getConstructorName(v);
      if ("string" == typeof instanceId) {
        if ("Window" === cstrName) {
          return "window";
        }
        if ("string" == typeof v[InstanceDataKey]) {
          if (1 === v.nodeType) {
            return `<${v[InstanceDataKey].toLowerCase()}>`;
          }
          if (10 === v.nodeType) {
            return `<!DOCTYPE ${v[InstanceDataKey]}>`;
          }
          if (v.nodeType <= 11) {
            return v[InstanceDataKey];
          }
        }
        return "¯\\_(ツ)_/¯ instance obj";
      }
      return v[Symbol.iterator]
        ? `[${Array.from(v)
            .map((i) => getLogValue(applyPath, i))
            .join(", ")}]`
        : "value" in v
        ? "string" == typeof v.value
          ? `"${v.value}"`
          : objToString(v.value)
        : objToString(v);
    }
    return ((v) => "object" == typeof v && v && v.then)(v)
      ? "Promise"
      : "function" === type
      ? `ƒ() ${v.name || ""}`.trim()
      : `¯\\_(ツ)_/¯ ${String(v)}`.trim();
  };
  const objToString = (obj) => {
    const s = [];
    for (let key in obj) {
      const value = obj[key];
      const type = typeof value;
      "string" === type
        ? s.push(`${key}: "${value}"`)
        : "function" === type
        ? s.push(`${key}: ƒ`)
        : Array.isArray(type)
        ? s.push(`${key}: [..]`)
        : "object" === type && value
        ? s.push(`${key}: {..}`)
        : s.push(`${key}: ${String(value)}`);
    }
    let str = s.join(", ");
    str.length > 200 && (str = str.substring(0, 200) + "..");
    return `{ ${str} }`;
  };
  const logDimensionCacheClearStyle = (target, propName) => {
    (webWorkerCtx.$config$.logGetters || webWorkerCtx.$config$.logSetters) &&
      logWorker(
        `Dimension cache cleared from style.${propName} setter`,
        target[WinIdKey]
      );
  };
  const logDimensionCacheClearMethod = (target, methodName) => {
    (webWorkerCtx.$config$.logGetters || webWorkerCtx.$config$.logCalls) &&
      logWorker(
        `Dimension cache cleared from method call ${methodName}()`,
        target[WinIdKey]
      );
  };
  const taskQueue = [];
  const queue = (
    instance,
    $applyPath$,
    callType,
    $assignInstanceId$,
    $groupedGetters$,
    buffer
  ) => {
    if (instance[ApplyPathKey]) {
      taskQueue.push({
        $winId$: instance[WinIdKey],
        $instanceId$: instance[InstanceIdKey],
        $applyPath$: [...instance[ApplyPathKey], ...$applyPath$],
        $assignInstanceId$: $assignInstanceId$,
        $groupedGetters$: $groupedGetters$,
      });
      taskQueue[len(taskQueue) - 1].$debug$ = ((
        target,
        applyPath,
        callType
      ) => {
        let m = getTargetProp(target, applyPath);
        1 === callType
          ? (m += " (blocking)")
          : 2 === callType
          ? (m += " (non-blocking)")
          : 3 === callType && (m += " (non-blocking, no-side-effect)");
        return m.trim();
      })(instance, $applyPath$, callType);
      buffer &&
        3 !== callType &&
        console.error("buffer must be sent NonBlockingNoSideEffect");
      if (3 === callType) {
        webWorkerCtx.$postMessage$(
          [
            12,
            {
              $msgId$: randomId(),
              $tasks$: [...taskQueue],
            },
          ],
          buffer
            ? [buffer instanceof ArrayBuffer ? buffer : buffer.buffer]
            : void 0
        );
        taskQueue.length = 0;
      } else if (1 === callType) {
        return sendToMain(true);
      }
      webWorkerCtx.$asyncMsgTimer$ = setTimeout(sendToMain, 20);
    }
  };
  const sendToMain = (isBlocking) => {
    clearTimeout(webWorkerCtx.$asyncMsgTimer$);
    if (len(taskQueue)) {
      webWorkerCtx.$config$.logMainAccess &&
        logWorker(`Main access, tasks sent: ${taskQueue.length}`);
      const endTask = taskQueue[len(taskQueue) - 1];
      const accessReq = {
        $msgId$: randomId(),
        $tasks$: [...taskQueue],
      };
      taskQueue.length = 0;
      if (isBlocking) {
        const accessRsp = ((webWorkerCtx, accessReq) => {
          const xhr = new XMLHttpRequest();
          xhr.open("POST", partytownLibUrl("proxytown"), false);
          xhr.send(JSON.stringify(accessReq));
          return JSON.parse(xhr.responseText);
        })(0, accessReq);
        const isPromise = accessRsp.$isPromise$;
        const rtnValue = deserializeFromMain(
          endTask.$winId$,
          endTask.$instanceId$,
          endTask.$applyPath$,
          accessRsp.$rtnValue$
        );
        if (accessRsp.$error$) {
          if (isPromise) {
            return Promise.reject(accessRsp.$error$);
          }
          throw new Error(accessRsp.$error$);
        }
        return isPromise ? Promise.resolve(rtnValue) : rtnValue;
      }
      webWorkerCtx.$postMessage$([12, accessReq]);
    }
  };
  const getter = (instance, applyPath, groupedGetters, rtnValue) => {
    if (webWorkerCtx.$config$.get) {
      rtnValue = webWorkerCtx.$config$.get(
        createHookOptions(instance, applyPath)
      );
      if (rtnValue !== HookContinue) {
        return rtnValue;
      }
    }
    rtnValue = queue(instance, applyPath, 1, void 0, groupedGetters);
    ((
      target,
      applyPath,
      rtnValue,
      restrictedToWorker = false,
      groupedGetters = false
    ) => {
      if (webWorkerCtx.$config$.logGetters) {
        try {
          const msg = `Get ${getTargetProp(
            target,
            applyPath
          )}, returned: ${getLogValue(applyPath, rtnValue)}${
            restrictedToWorker ? " (restricted to worker)" : ""
          }${groupedGetters ? " (grouped getter)" : ""}`;
          msg.includes("Symbol(") || logWorker(msg, target[WinIdKey]);
        } catch (e) {}
      }
    })(instance, applyPath, rtnValue, false, !!groupedGetters);
    return rtnValue;
  };
  const setter = (instance, applyPath, value, hookSetterValue) => {
    if (webWorkerCtx.$config$.set) {
      hookSetterValue = webWorkerCtx.$config$.set({
        value: value,
        prevent: HookPrevent,
        ...createHookOptions(instance, applyPath),
      });
      if (hookSetterValue === HookPrevent) {
        return;
      }
      hookSetterValue !== HookContinue && (value = hookSetterValue);
    }
    if (dimensionChangingSetterNames.some((s) => applyPath.includes(s))) {
      cachedDimensions.clear();
      ((target, propName) => {
        (webWorkerCtx.$config$.logGetters ||
          webWorkerCtx.$config$.logSetters) &&
          logWorker(
            `Dimension cache cleared from setter "${propName}"`,
            target[WinIdKey]
          );
      })(instance, applyPath[applyPath.length - 1]);
    }
    applyPath = [...applyPath, serializeInstanceForMain(instance, value), 0];
    ((target, applyPath, value, restrictedToWorker = false) => {
      if (webWorkerCtx.$config$.logSetters) {
        try {
          applyPath = applyPath.slice(0, applyPath.length - 2);
          logWorker(
            `Set ${getTargetProp(target, applyPath)}, value: ${getLogValue(
              applyPath,
              value
            )}${restrictedToWorker ? " (restricted to worker)" : ""}`,
            target[WinIdKey]
          );
        } catch (e) {}
      }
    })(instance, applyPath, value);
    queue(instance, applyPath, 2);
  };
  const callMethod = (
    instance,
    applyPath,
    args,
    callType,
    assignInstanceId,
    buffer,
    rtnValue,
    methodName
  ) => {
    if (webWorkerCtx.$config$.apply) {
      rtnValue = webWorkerCtx.$config$.apply({
        args: args,
        ...createHookOptions(instance, applyPath),
      });
      if (rtnValue !== HookContinue) {
        return rtnValue;
      }
    }
    methodName = applyPath[len(applyPath) - 1];
    applyPath = [...applyPath, serializeInstanceForMain(instance, args)];
    callType = callType || (nonBlockingMethods.includes(methodName) ? 2 : 1);
    if (
      "setAttribute" === methodName &&
      hasInstanceStateValue(instance, args[0])
    ) {
      setInstanceStateValue(instance, args[0], args[1]);
    } else if (structureChangingMethodNames.includes(methodName)) {
      cachedDimensions.clear();
      cachedStructure.clear();
      ((target, methodName) => {
        (webWorkerCtx.$config$.logGetters || webWorkerCtx.$config$.logCalls) &&
          logWorker(
            `Dimension and DOM structure cache cleared from method call ${methodName}()`,
            target[WinIdKey]
          );
      })(instance, methodName);
    } else if (dimensionChangingMethodNames.includes(methodName)) {
      callType = 2;
      cachedDimensions.clear();
      logDimensionCacheClearMethod(instance, methodName);
    }
    rtnValue = queue(
      instance,
      applyPath,
      callType,
      assignInstanceId,
      void 0,
      buffer
    );
    ((target, applyPath, args, rtnValue) => {
      if (webWorkerCtx.$config$.logCalls) {
        try {
          applyPath = applyPath.slice(0, applyPath.length - 1);
          logWorker(
            `Call ${getTargetProp(target, applyPath)}(${args
              .map((v) => getLogValue(applyPath, v))
              .join(", ")}), returned: ${getLogValue(applyPath, rtnValue)}`,
            target[WinIdKey]
          );
        } catch (e) {}
      }
    })(instance, applyPath, args, rtnValue);
    return rtnValue;
  };
  const constructGlobal = (instance, cstrName, args) => {
    ((target, cstrName, args) => {
      if (webWorkerCtx.$config$.logCalls) {
        try {
          logWorker(
            `Construct new ${cstrName}(${args
              .map((v) => getLogValue([], v))
              .join(", ")})`,
            target[WinIdKey]
          );
        } catch (e) {}
      }
    })(instance, cstrName, args);
    queue(instance, [1, cstrName, serializeInstanceForMain(instance, args)], 1);
  };
  const createHookOptions = (instance, applyPath) => ({
    name: applyPath.join("."),
    continue: HookContinue,
    nodeName: instance[InstanceDataKey],
    constructor: getConstructorName(instance),
    instance: instance,
    window: environments[instance[WinIdKey]].$window$,
  });
  const addStorageApi = (win, storageName, storages, isSameOrigin, env) => {
    let getItems = (items) => {
      items = storages.get(win.origin);
      items || storages.set(win.origin, (items = []));
      return items;
    };
    let getIndexByKey = (key) =>
      getItems().findIndex((i) => i[STORAGE_KEY] === key);
    let index;
    let item;
    let storage = {
      getItem(key) {
        index = getIndexByKey(key);
        return index > -1 ? getItems()[index][STORAGE_VALUE] : null;
      },
      setItem(key, value) {
        index = getIndexByKey(key);
        index > -1
          ? (getItems()[index][STORAGE_VALUE] = value)
          : getItems().push([key, value]);
        isSameOrigin
          ? callMethod(win, [storageName, "setItem"], [key, value], 2)
          : warnCrossOrgin("set", storageName, env);
      },
      removeItem(key) {
        index = getIndexByKey(key);
        index > -1 && getItems().splice(index, 1);
        isSameOrigin
          ? callMethod(win, [storageName, "removeItem"], [key], 2)
          : warnCrossOrgin("remove", storageName, env);
      },
      key(index) {
        item = getItems()[index];
        return item ? item[STORAGE_KEY] : null;
      },
      clear() {
        getItems().length = 0;
        isSameOrigin
          ? callMethod(win, [storageName, "clear"], EMPTY_ARRAY, 2)
          : warnCrossOrgin("clear", storageName, env);
      },
      get length() {
        return getItems().length;
      },
    };
    win[storageName] = new Proxy(storage, {
      get: (target, key) =>
        Reflect.has(target, key)
          ? Reflect.get(target, key)
          : target.getItem(key),
      set(target, key, value) {
        target.setItem(key, value);
        return true;
      },
      has: (target, key) =>
        !!Reflect.has(target, key) ||
        ("string" == typeof key && null !== target.getItem(key)),
      deleteProperty(target, key) {
        target.removeItem(key);
        return true;
      },
    });
  };
  const STORAGE_KEY = 0;
  const STORAGE_VALUE = 1;
  const createCSSStyleDeclarationCstr = (win, WorkerBase, cstrName) => {
    win[cstrName] = defineConstructorName(
      class extends WorkerBase {
        constructor(winId, instanceId, applyPath, styles) {
          super(winId, instanceId, applyPath, styles || {});
          return new Proxy(this, {
            get(target, propName) {
              if (target[propName]) {
                return target[propName];
              }
              target[propName] ||
                "string" != typeof propName ||
                target[InstanceDataKey][propName] ||
                (target[InstanceDataKey][propName] = getter(target, [
                  propName,
                ]));
              return target[InstanceDataKey][propName];
            },
            set(target, propName, propValue) {
              target[InstanceDataKey][propName] = propValue;
              setter(target, [propName], propValue);
              logDimensionCacheClearStyle(target, propName);
              cachedDimensions.clear();
              return true;
            },
          });
        }
        setProperty(...args) {
          this[InstanceDataKey][args[0]] = args[1];
          callMethod(this, ["setProperty"], args, 2);
          logDimensionCacheClearStyle(this, args[0]);
          cachedDimensions.clear();
        }
        getPropertyValue(propName) {
          return this[propName];
        }
        removeProperty(propName) {
          let value = this[InstanceDataKey][propName];
          callMethod(this, ["removeProperty"], [propName], 2);
          logDimensionCacheClearStyle(this, propName);
          cachedDimensions.clear();
          this[InstanceDataKey][propName] = void 0;
          return value;
        }
      },
      cstrName
    );
  };
  const createCSSStyleSheetConstructor = (win, cssStyleSheetCstrName) => {
    win[cssStyleSheetCstrName] = defineConstructorName(
      class {
        constructor(ownerNode) {
          this.ownerNode = ownerNode;
        }
        get cssRules() {
          const ownerNode = this.ownerNode;
          return new Proxy(
            {},
            {
              get(target, propKey) {
                const propName = String(propKey);
                return "item" === propName
                  ? (index) => getCssRule(ownerNode, index)
                  : "length" === propName
                  ? getCssRules(ownerNode).length
                  : isNaN(propName)
                  ? target[propKey]
                  : getCssRule(ownerNode, propName);
              },
            }
          );
        }
        insertRule(ruleText, index) {
          const cssRules = getCssRules(this.ownerNode);
          index = void 0 === index ? 0 : index;
          if (index >= 0 && index <= cssRules.length) {
            callMethod(
              this.ownerNode,
              ["sheet", "insertRule"],
              [ruleText, index],
              2
            );
            cssRules.splice(index, 0, 0);
          }
          logDimensionCacheClearMethod(this.ownerNode, "insertRule");
          cachedDimensions.clear();
          return index;
        }
        deleteRule(index) {
          callMethod(this.ownerNode, ["sheet", "deleteRule"], [index], 2);
          getCssRules(this.ownerNode).splice(index, 1);
          logDimensionCacheClearMethod(this.ownerNode, "deleteRule");
          cachedDimensions.clear();
        }
        get type() {
          return "text/css";
        }
      },
      cssStyleSheetCstrName
    );
    const HTMLStyleDescriptorMap = {
      sheet: {
        get() {
          return new win[cssStyleSheetCstrName](this);
        },
      },
    };
    definePrototypePropertyDescriptor(
      win.HTMLStyleElement,
      HTMLStyleDescriptorMap
    );
  };
  const getCssRules = (ownerNode, cssRules) => {
    cssRules = getInstanceStateValue(ownerNode, 2);
    if (!cssRules) {
      cssRules = getter(ownerNode, ["sheet", "cssRules"]);
      setInstanceStateValue(ownerNode, 2, cssRules);
    }
    return cssRules;
  };
  const getCssRule = (ownerNode, index, cssRules) => {
    cssRules = getCssRules(ownerNode);
    0 === cssRules[index] &&
      (cssRules[index] = getter(ownerNode, [
        "sheet",
        "cssRules",
        parseInt(index, 10),
      ]));
    return cssRules[index];
  };
  const runScriptContent = (
    env,
    instanceId,
    scriptContent,
    winId,
    errorMsg
  ) => {
    try {
      webWorkerCtx.$config$.logScriptExecution &&
        logWorker(
          `Execute script: ${scriptContent
            .substring(0, 100)
            .split("\n")
            .map((l) => l.trim())
            .join(" ")
            .trim()
            .substring(0, 60)}...`,
          winId
        );
      env.$currentScriptId$ = instanceId;
      run(env, scriptContent);
    } catch (contentError) {
      console.error(scriptContent, contentError);
      errorMsg = String(contentError.stack || contentError);
    }
    env.$currentScriptId$ = "";
    return errorMsg;
  };
  const run = (env, scriptContent, scriptUrl) => {
    env.$runWindowLoadEvent$ = 1;
    scriptContent =
      `with(this){${scriptContent
        .replace(/\bthis\b/g, "(thi$(this)?window:this)")
        .replace(/\/\/# so/g, "//Xso")}\n;function thi$(t){return t===this}};${(
        webWorkerCtx.$config$.globalFns || []
      )
        .filter((globalFnName) => /[a-zA-Z_$][0-9a-zA-Z_$]*/.test(globalFnName))
        .map((g) => `(typeof ${g}=='function'&&(this.${g}=${g}))`)
        .join(";")};` + (scriptUrl ? "\n//# sourceURL=" + scriptUrl : "");
    env.$isSameOrigin$ ||
      (scriptContent = scriptContent.replace(
        /.postMessage\(/g,
        `.postMessage('${env.$winId$}',`
      ));
    new Function(scriptContent).call(env.$window$);
    env.$runWindowLoadEvent$ = 0;
  };
  const runStateLoadHandlers = (instance, type, handlers) => {
    handlers = getInstanceStateValue(instance, type);
    handlers &&
      setTimeout(() =>
        handlers.map((cb) =>
          cb({
            type: type,
          })
        )
      );
  };
  const resolveToUrl = (
    env,
    url,
    type,
    baseLocation,
    resolvedUrl,
    configResolvedUrl
  ) => {
    baseLocation = env.$location$;
    while (!baseLocation.host) {
      env = environments[env.$parentWinId$];
      baseLocation = env.$location$;
      if (env.$winId$ === env.$parentWinId$) {
        break;
      }
    }
    resolvedUrl = new URL(url || "", baseLocation);
    if (type && webWorkerCtx.$config$.resolveUrl) {
      configResolvedUrl = webWorkerCtx.$config$.resolveUrl(
        resolvedUrl,
        baseLocation,
        type
      );
      if (configResolvedUrl) {
        return configResolvedUrl;
      }
    }
    return resolvedUrl;
  };
  const resolveUrl = (env, url, type) => resolveToUrl(env, url, type) + "";
  const getPartytownScript = () =>
    `<script src="${partytownLibUrl("partytown.js?v=0.7.5")}"><\/script>`;
  const createImageConstructor = (env) =>
    class HTMLImageElement {
      constructor() {
        this.s = "";
        this.l = [];
        this.e = [];
        this.style = {};
      }
      get src() {
        return this.s;
      }
      set src(src) {
        webWorkerCtx.$config$.logImageRequests &&
          logWorker(
            `Image() request: ${resolveUrl(env, src, "image")}`,
            env.$winId$
          );
        this.s = src;
        fetch(resolveUrl(env, src, "image"), {
          mode: "no-cors",
          credentials: "include",
          keepalive: true,
        }).then(
          (rsp) => {
            rsp.ok || 0 === rsp.status
              ? this.l.map((cb) =>
                  cb({
                    type: "load",
                  })
                )
              : this.e.map((cb) =>
                  cb({
                    type: "error",
                  })
                );
          },
          () =>
            this.e.forEach((cb) =>
              cb({
                type: "error",
              })
            )
        );
      }
      addEventListener(eventName, cb) {
        "load" === eventName && this.l.push(cb);
        "error" === eventName && this.e.push(cb);
      }
      get onload() {
        return this.l[0];
      }
      set onload(cb) {
        this.l = [cb];
      }
      get onerror() {
        return this.e[0];
      }
      set onerror(cb) {
        this.e = [cb];
      }
    };
  const HTMLSrcElementDescriptorMap = {
    addEventListener: {
      value(...args) {
        const eventName = args[0];
        const callbacks = getInstanceStateValue(this, eventName) || [];
        callbacks.push(args[1]);
        setInstanceStateValue(this, eventName, callbacks);
      },
    },
    async: {
      get: noop,
      set: noop,
    },
    defer: {
      get: noop,
      set: noop,
    },
    onload: {
      get() {
        let callbacks = getInstanceStateValue(this, "load");
        return (callbacks && callbacks[0]) || null;
      },
      set(cb) {
        setInstanceStateValue(this, "load", cb ? [cb] : null);
      },
    },
    onerror: {
      get() {
        let callbacks = getInstanceStateValue(this, "error");
        return (callbacks && callbacks[0]) || null;
      },
      set(cb) {
        setInstanceStateValue(this, "error", cb ? [cb] : null);
      },
    },
    getAttribute: {
      value(attrName) {
        return "src" === attrName
          ? this.src
          : callMethod(this, ["getAttribute"], [attrName]);
      },
    },
    setAttribute: {
      value(attrName, attrValue) {
        scriptAttrPropNames.includes(attrName)
          ? (this[attrName] = attrValue)
          : callMethod(this, ["setAttribute"], [attrName, attrValue]);
      },
    },
  };
  const scriptAttrPropNames = commaSplit("src,type");
  const patchHTMLScriptElement = (WorkerHTMLScriptElement, env) => {
    const HTMLScriptDescriptorMap = {
      innerHTML: innerHTMLDescriptor,
      innerText: innerHTMLDescriptor,
      src: {
        get() {
          return getInstanceStateValue(this, 4) || "";
        },
        set(url) {
          const orgUrl = resolveUrl(env, url, null);
          const config = webWorkerCtx.$config$;
          url = resolveUrl(env, url, "script");
          setInstanceStateValue(this, 4, url);
          setter(this, ["src"], url);
          orgUrl !== url && setter(this, ["dataset", "ptsrc"], orgUrl);
          if (this.type && config.loadScriptsOnMainThread) {
            const shouldExecuteScriptViaMainThread =
              config.loadScriptsOnMainThread.some(
                (scriptUrl) => scriptUrl === url
              );
            shouldExecuteScriptViaMainThread &&
              setter(this, ["type"], "text/javascript");
          }
        },
      },
      textContent: innerHTMLDescriptor,
      type: {
        get() {
          return getter(this, ["type"]);
        },
        set(type) {
          if (!isScriptJsType(type)) {
            setInstanceStateValue(this, 5, type);
            setter(this, ["type"], type);
          }
        },
      },
      ...HTMLSrcElementDescriptorMap,
    };
    definePrototypePropertyDescriptor(
      WorkerHTMLScriptElement,
      HTMLScriptDescriptorMap
    );
  };
  const innerHTMLDescriptor = {
    get() {
      const type = getter(this, ["type"]);
      return isScriptJsType(type)
        ? getInstanceStateValue(this, 3) || ""
        : getter(this, ["innerHTML"]);
    },
    set(scriptContent) {
      setInstanceStateValue(this, 3, scriptContent);
    },
  };
  const isScriptJsType = (scriptType) =>
    !scriptType || "text/javascript" === scriptType;
  const createNodeCstr = (win, env, WorkerBase) => {
    const config = webWorkerCtx.$config$;
    const WorkerNode = defineConstructorName(
      class extends WorkerBase {
        appendChild(node) {
          return this.insertBefore(node, null);
        }
        get href() {}
        set href(_) {}
        insertBefore(newNode, referenceNode) {
          var _a, _b;
          const winId = (newNode[WinIdKey] = this[WinIdKey]);
          const instanceId = newNode[InstanceIdKey];
          const nodeName = newNode[InstanceDataKey];
          const isScript = "SCRIPT" === nodeName;
          const isIFrame = "INPUT" === nodeName;
          if (isScript) {
            const scriptContent = getInstanceStateValue(newNode, 3);
            const scriptType = getInstanceStateValue(newNode, 5);
            if (scriptContent) {
              if (isScriptJsType(scriptType)) {
                const scriptId = newNode.id;
                const loadOnMainThread =
                  scriptId &&
                  (null ===
                    (_b =
                      null === (_a = config.loadScriptsOnMainThread) ||
                      void 0 === _a
                        ? void 0
                        : _a.includes) || void 0 === _b
                    ? void 0
                    : _b.call(_a, scriptId));
                if (loadOnMainThread) {
                  setter(newNode, ["type"], "text/javascript");
                } else {
                  const errorMsg = runScriptContent(
                    env,
                    instanceId,
                    scriptContent,
                    winId,
                    ""
                  );
                  const datasetType = errorMsg ? "pterror" : "ptid";
                  const datasetValue = errorMsg || instanceId;
                  setter(newNode, ["type"], "text/partytown-x");
                  setter(newNode, ["dataset", datasetType], datasetValue);
                }
              }
              setter(newNode, ["innerHTML"], scriptContent);
            }
          }
          callMethod(this, ["insertBefore"], [newNode, referenceNode], 2);
          if (isIFrame) {
            const src = getInstanceStateValue(newNode, 0);
            if (src && src.startsWith("javascript:")) {
              const scriptContent = src.split("javascript:")[1];
              runScriptContent(env, instanceId, scriptContent, winId, "");
            }
            ((winId, iframe) => {
              let i = 0;
              let type;
              let handlers;
              let callback = () => {
                if (
                  environments[winId] &&
                  environments[winId].$isInitialized$ &&
                  !environments[winId].$isLoading$
                ) {
                  type = getInstanceStateValue(iframe, 1) ? "error" : "load";
                  handlers = getInstanceStateValue(iframe, type);
                  handlers &&
                    handlers.map((handler) =>
                      handler({
                        type: type,
                      })
                    );
                } else if (i++ > 2e3) {
                  handlers = getInstanceStateValue(iframe, "error");
                  handlers &&
                    handlers.map((handler) =>
                      handler({
                        type: "error",
                      })
                    );
                } else {
                  setTimeout(callback, 9);
                }
              };
              callback();
            })(instanceId, newNode);
          }
          if (isScript) {
            sendToMain(true);
            webWorkerCtx.$postMessage$([7, winId]);
          }
          return newNode;
        }
        get nodeName() {
          return "#s" === this[InstanceDataKey]
            ? "#document-fragment"
            : this[InstanceDataKey];
        }
        get nodeType() {
          return 3;
        }
        get ownerDocument() {
          return env.$document$;
        }
      },
      "Node"
    );
    cachedTreeProps(
      WorkerNode,
      commaSplit(
        "childNodes,firstChild,isConnected,lastChild,nextSibling,parentElement,parentNode,previousSibling"
      )
    );
    win.Node = WorkerNode;
  };
  const htmlMedia = commaSplit("AUDIO,CANVAS,VIDEO");
  const windowMediaConstructors = commaSplit("Audio,MediaSource");
  const patchDocument = (WorkerDocument, env, isDocumentImplementation) => {
    const DocumentDescriptorMap = {
      body: {
        get: () => env.$body$,
      },
      cookie: {
        get() {
          if (env.$isSameOrigin$) {
            return getter(this, ["cookie"]);
          }
          warnCrossOrgin("get", "cookie", env);
          return "";
        },
        set(value) {
          if (env.$isSameOrigin$) {
            setter(this, ["cookie"], value);
          } else {
            warnCrossOrgin("set", "cookie", env);
          }
        },
      },
      createElement: {
        value(tagName) {
          tagName = tagName.toUpperCase();
          if (!IS_TAG_REG.test(tagName)) {
            throw tagName + " not valid";
          }
          const isIframe = "IFRAME" === tagName;
          const winId = this[WinIdKey];
          const instanceId = (isIframe ? "f_" : "") + randomId();
          callMethod(this, ["createElement"], [tagName], 2, instanceId);
          const elm = getOrCreateNodeInstance(winId, instanceId, tagName);
          if (isIframe) {
            const env = createEnvironment(
              {
                $winId$: instanceId,
                $parentWinId$: winId,
                $url$: "about:blank",
              },
              true
            );
            env.$window$.fetch = fetch;
            setter(elm, ["srcdoc"], getPartytownScript());
          } else if ("SCRIPT" === tagName) {
            const scriptType = getInstanceStateValue(elm, 5);
            isScriptJsType(scriptType) &&
              setter(elm, ["type"], "text/partytown");
          }
          return elm;
        },
      },
      createElementNS: {
        value(namespace, tagName) {
          const instanceId = randomId();
          const nsElm = getOrCreateNodeInstance(
            this[WinIdKey],
            instanceId,
            tagName,
            namespace
          );
          callMethod(
            this,
            ["createElementNS"],
            [namespace, tagName],
            2,
            instanceId
          );
          return nsElm;
        },
      },
      createTextNode: {
        value(text) {
          const winId = this[WinIdKey];
          const instanceId = randomId();
          const textNode = getOrCreateNodeInstance(winId, instanceId, "#text");
          callMethod(this, ["createTextNode"], [text], 2, instanceId);
          return textNode;
        },
      },
      createEvent: {
        value: (type) => new Event(type),
      },
      currentScript: {
        get() {
          return env.$currentScriptId$
            ? getOrCreateNodeInstance(
                this[WinIdKey],
                env.$currentScriptId$,
                "SCRIPT"
              )
            : null;
        },
      },
      defaultView: {
        get: () => (isDocumentImplementation ? null : env.$window$),
      },
      documentElement: {
        get: () => env.$documentElement$,
      },
      getElementsByTagName: {
        value(tagName) {
          tagName = tagName.toUpperCase();
          return "BODY" === tagName
            ? [env.$body$]
            : "HEAD" === tagName
            ? [env.$head$]
            : callMethod(this, ["getElementsByTagName"], [tagName]);
        },
      },
      head: {
        get: () => env.$head$,
      },
      images: {
        get() {
          return getter(this, ["images"]);
        },
      },
      implementation: {
        get() {
          return {
            hasFeature: () => true,
            createHTMLDocument: (title) => {
              const $winId$ = randomId();
              callMethod(
                this,
                ["implementation", "createHTMLDocument"],
                [title],
                1,
                {
                  $winId$: $winId$,
                }
              );
              const docEnv = createEnvironment(
                {
                  $winId$: $winId$,
                  $parentWinId$: $winId$,
                  $url$: env.$location$ + "",
                  $visibilityState$: "hidden",
                },
                true,
                true
              );
              return docEnv.$document$;
            },
          };
        },
      },
      location: {
        get: () => env.$location$,
        set(url) {
          env.$location$.href = url + "";
        },
      },
      nodeType: {
        value: 9,
      },
      parentNode: {
        value: null,
      },
      parentElement: {
        value: null,
      },
      readyState: {
        value: "complete",
      },
      visibilityState: {
        get: () => env.$visibilityState$ || "visible",
      },
    };
    definePrototypePropertyDescriptor(WorkerDocument, DocumentDescriptorMap);
    cachedProps(WorkerDocument, "compatMode,referrer,forms");
  };
  const patchDocumentElementChild = (WokerDocumentElementChild, env) => {
    const DocumentElementChildDescriptorMap = {
      parentElement: {
        get() {
          return this.parentNode;
        },
      },
      parentNode: {
        get: () => env.$documentElement$,
      },
    };
    definePrototypePropertyDescriptor(
      WokerDocumentElementChild,
      DocumentElementChildDescriptorMap
    );
  };
  const patchElement = (WorkerElement, WorkerHTMLElement) => {
    const ElementDescriptorMap = {
      localName: {
        get() {
          return this[InstanceDataKey].toLowerCase();
        },
      },
      namespaceURI: {
        get() {
          return this[NamespaceKey] || "http://www.w3.org/1999/xhtml";
        },
      },
      nodeType: {
        value: 1,
      },
      tagName: {
        get() {
          return this[InstanceDataKey];
        },
      },
    };
    definePrototypePropertyDescriptor(WorkerElement, ElementDescriptorMap);
    cachedTreeProps(WorkerElement, elementStructurePropNames);
    cachedProps(WorkerElement, "id");
    cachedDimensionProps(WorkerHTMLElement);
    cachedDimensionMethods(
      WorkerHTMLElement,
      commaSplit("getClientRects,getBoundingClientRect")
    );
  };
  const patchHTMLAnchorElement = (WorkerHTMLAnchorElement, env) => {
    const HTMLAnchorDescriptorMap = {};
    commaSplit(
      "hash,host,hostname,href,origin,pathname,port,protocol,search"
    ).map((anchorProp) => {
      HTMLAnchorDescriptorMap[anchorProp] = {
        get() {
          let value = getInstanceStateValue(this, 4);
          let href;
          if ("string" != typeof value) {
            href = getter(this, ["href"]);
            setInstanceStateValue(this, 4, href);
            value = new URL(href)[anchorProp];
          }
          return resolveToUrl(env, value, null)[anchorProp];
        },
        set(value) {
          let url;
          if ("href" === anchorProp) {
            if (
              ((url) => {
                try {
                  new URL(url);
                  return true;
                } catch (_) {
                  return false;
                }
              })(value)
            ) {
              url = new URL(value);
            } else {
              const baseHref = env.$location$.href;
              url = resolveToUrl(env, baseHref, null);
              url.href = new URL(value + "", url.href);
            }
          } else {
            url = resolveToUrl(env, this.href, null);
            url[anchorProp] = value;
          }
          setInstanceStateValue(this, 4, url.href);
          setter(this, ["href"], url.href);
        },
      };
    });
    definePrototypePropertyDescriptor(
      WorkerHTMLAnchorElement,
      HTMLAnchorDescriptorMap
    );
  };
  const patchHTMLIFrameElement = (WorkerHTMLIFrameElement, env) => {
    const HTMLIFrameDescriptorMap = {
      contentDocument: {
        get() {
          return getIframeEnv(this).$document$;
        },
      },
      contentWindow: {
        get() {
          return getIframeEnv(this).$window$;
        },
      },
      src: {
        get() {
          let src = getInstanceStateValue(this, 0);
          if (src && src.startsWith("javascript:")) {
            return src;
          }
          src = getIframeEnv(this).$location$.href;
          return src.startsWith("about:") ? "" : src;
        },
        set(src) {
          if (src) {
            if (src.startsWith("javascript:")) {
              setInstanceStateValue(this, 0, src);
            } else if (!src.startsWith("about:")) {
              let xhr = new XMLHttpRequest();
              let xhrStatus;
              let env = getIframeEnv(this);
              env.$location$.href = src = resolveUrl(env, src, "input");
              env.$isLoading$ = 1;
              setInstanceStateValue(this, 1, void 0);
              xhr.open("GET", src, false);
              xhr.send();
              xhrStatus = xhr.status;
              if (xhrStatus > 199 && xhrStatus < 300) {
                setter(
                  this,
                  ["srcdoc"],
                  `<base href="${src}">` +
                    (function (text) {
                      return text.replace(SCRIPT_TAG_REGEXP, (_, attrs) => {
                        const parts = [];
                        let hasType = false;
                        let match;
                        while ((match = ATTR_REGEXP.exec(attrs))) {
                          let [keyValue] = match;
                          if (keyValue.startsWith("type=")) {
                            hasType = true;
                            keyValue = keyValue.replace(
                              /(application|text)\/javascript/,
                              SCRIPT_TYPE
                            );
                          }
                          parts.push(keyValue);
                        }
                        hasType || parts.push('type="text/partytown"');
                        return `<script ${parts.join(" ")}>`;
                      });
                    })(xhr.responseText) +
                    getPartytownScript()
                );
                sendToMain(true);
                webWorkerCtx.$postMessage$([7, env.$winId$]);
              } else {
                setInstanceStateValue(this, 1, xhrStatus);
                env.$isLoading$ = 0;
              }
            }
          }
        },
      },
      ...HTMLSrcElementDescriptorMap,
    };
    definePrototypePropertyDescriptor(
      WorkerHTMLIFrameElement,
      HTMLIFrameDescriptorMap
    );
  };
  const ATTR_REGEXP_STR =
    "((?:\\w|-)+(?:=(?:(?:\\w|-)+|'[^']*'|\"[^\"]*\")?)?)";
  const SCRIPT_TAG_REGEXP = new RegExp(
    `<script\\s*((${ATTR_REGEXP_STR}\\s*)*)>`,
    "mg"
  );
  const ATTR_REGEXP = new RegExp(ATTR_REGEXP_STR, "mg");
  const getIframeEnv = (iframe) => {
    const $winId$ = iframe[InstanceIdKey];
    environments[$winId$] ||
      createEnvironment(
        {
          $winId$: $winId$,
          $parentWinId$: iframe[WinIdKey],
          $url$: getter(iframe, ["src"]) || "about:blank",
        },
        true
      );
    return environments[$winId$];
  };
  const patchSvgElement = (WorkerSVGGraphicsElement) => {
    const getMatrix = (elm, methodName) => {
      const {
        a: a,
        b: b,
        c: c,
        d: d,
        e: e,
        f: f,
      } = callMethod(elm, [methodName], EMPTY_ARRAY);
      return new DOMMatrixReadOnly([a, b, c, d, e, f]);
    };
    const SVGGraphicsElementDescriptorMap = {
      ...WorkerSVGGraphicsElement,
      getCTM: {
        value: function () {
          return getMatrix(this, "getCTM");
        },
      },
      getScreenCTM: {
        value: function () {
          return getMatrix(this, "getScreenCTM");
        },
      },
    };
    definePrototypePropertyDescriptor(
      WorkerSVGGraphicsElement,
      SVGGraphicsElementDescriptorMap
    );
  };
  const createNamedNodeMapCstr = (win, WorkerBase) => {
    win.NamedNodeMap = defineConstructorName(
      class NamedNodeMap extends WorkerBase {
        constructor(winId, instanceId, applyPath) {
          super(winId, instanceId, applyPath);
          return new Proxy(this, {
            get(target, propName) {
              const handler = NAMED_NODE_MAP_HANDLERS[propName];
              return handler
                ? handler.bind(target, [propName])
                : getter(target, [propName]);
            },
            set(target, propName, propValue) {
              const handler = NAMED_NODE_MAP_HANDLERS[propName];
              if (handler) {
                throw new Error(
                  "Can't set read-only property: " + String(propName)
                );
              }
              setter(target, [propName], propValue);
              return true;
            },
          });
        }
      },
      "NamedNodeMap"
    );
  };
  function method(applyPath, ...args) {
    return callMethod(this, applyPath, args, 1);
  }
  const NAMED_NODE_MAP_HANDLERS = {
    getNamedItem: method,
    getNamedItemNS: method,
    item: method,
    removeNamedItem: method,
    removeNamedItemNS: method,
    setNamedItem: method,
    setNamedItemNS: method,
  };
  const createWindow = (
    $winId$,
    $parentWinId$,
    url,
    $visibilityState$,
    isIframeWindow,
    isDocumentImplementation
  ) => {
    let cstrInstanceId;
    let cstrNodeName;
    let cstrNamespace;
    const WorkerBase = class {
      constructor(winId, instanceId, applyPath, instanceData, namespace) {
        this[WinIdKey] = winId || $winId$;
        this[InstanceIdKey] = instanceId || cstrInstanceId || randomId();
        this[ApplyPathKey] = applyPath || [];
        this[InstanceDataKey] = instanceData || cstrNodeName;
        this[NamespaceKey] = namespace || cstrNamespace;
        this[InstanceStateKey] = {};
        cstrInstanceId = cstrNodeName = cstrNamespace = void 0;
      }
    };
    const WorkerLocation = defineConstructorName(
      class extends URL {
        assign() {
          logWorker("location.assign(), noop");
        }
        reload() {
          logWorker("location.reload(), noop");
        }
        replace() {
          logWorker("location.replace(), noop");
        }
      },
      "Location"
    );
    const $location$ = new WorkerLocation(url);
    const $isSameOrigin$ =
      $location$.origin === webWorkerCtx.$origin$ ||
      "about:blank" === $location$.origin;
    const $isTopWindow$ = $parentWinId$ === $winId$;
    const env = {};
    const getChildEnvs = () => {
      let childEnv = [];
      let envWinId;
      let otherEnv;
      for (envWinId in environments) {
        otherEnv = environments[envWinId];
        otherEnv.$parentWinId$ !== $winId$ ||
          otherEnv.$isTopWindow$ ||
          childEnv.push(otherEnv);
      }
      return childEnv;
    };
    const WorkerWindow = defineConstructorName(
      class extends WorkerBase {
        constructor() {
          super($winId$, $winId$);
          let win = this;
          let value;
          let historyState;
          let hasInitializedMedia = 0;
          let initWindowMedia = () => {
            if (!hasInitializedMedia) {
              (() => {
                if (!webWorkerCtx.$initWindowMedia$) {
                  self.$bridgeToMedia$ = [
                    getter,
                    setter,
                    callMethod,
                    constructGlobal,
                    definePrototypePropertyDescriptor,
                    randomId,
                    WinIdKey,
                    InstanceIdKey,
                    ApplyPathKey,
                  ];
                  webWorkerCtx.$importScripts$(
                    partytownLibUrl("partytown-media.js?v=0.7.5")
                  );
                  webWorkerCtx.$initWindowMedia$ = self.$bridgeFromMedia$;
                  delete self.$bridgeFromMedia$;
                }
                return webWorkerCtx.$initWindowMedia$;
              })()(
                WorkerBase,
                WorkerEventTargetProxy,
                env,
                win,
                windowMediaConstructors
              );
              hasInitializedMedia = 1;
            }
          };
          let nodeCstrs = {};
          let $createNode$ = (nodeName, instanceId, namespace) => {
            htmlMedia.includes(nodeName) && initWindowMedia();
            const NodeCstr = nodeCstrs[nodeName]
              ? nodeCstrs[nodeName]
              : nodeName.includes("-")
              ? nodeCstrs.UNKNOWN
              : nodeCstrs.I;
            cstrInstanceId = instanceId;
            cstrNodeName = nodeName;
            cstrNamespace = namespace;
            return new NodeCstr();
          };
          win.Window = WorkerWindow;
          win.name = name + `${normalizedWinId($winId$)} (${$winId$})`;
          createNodeCstr(win, env, WorkerBase);
          ((win) => {
            win.NodeList = defineConstructorName(NodeList, "NodeList");
          })(win);
          createNamedNodeMapCstr(win, WorkerBase);
          createCSSStyleDeclarationCstr(win, WorkerBase, "CSSStyleDeclaration");
          ((win, WorkerBase, cstrName) => {
            win[cstrName] = defineConstructorName(
              class extends WorkerBase {
                now() {
                  return performance.now();
                }
              },
              cstrName
            );
          })(win, WorkerBase, "Performance");
          ((win, nodeCstrs) => {
            const registry = new Map();
            win.customElements = {
              define(tagName, Cstr, opts) {
                registry.set(tagName, Cstr);
                nodeCstrs[tagName.toUpperCase()] = Cstr;
                const ceData = [Cstr.name, Cstr.observedAttributes];
                callMethod(
                  win,
                  ["customElements", "define"],
                  [tagName, ceData, opts]
                );
              },
              get: (tagName) =>
                registry.get(tagName) ||
                callMethod(win, ["customElements", "get"], [tagName]),
              whenDefined: (tagName) =>
                registry.has(tagName)
                  ? Promise.resolve()
                  : callMethod(
                      win,
                      ["customElements", "whenDefined"],
                      [tagName]
                    ),
              upgrade: (elm) =>
                callMethod(win, ["customElements", "upgrade"], [elm]),
            };
          })(win, nodeCstrs);
          webWorkerCtx.$interfaces$.map(
            ([cstrName, superCstrName, members, interfaceType, nodeName]) => {
              const SuperCstr = TrapConstructors[cstrName]
                ? WorkerTrapProxy
                : "EventTarget" === superCstrName
                ? WorkerEventTargetProxy
                : "Object" === superCstrName
                ? WorkerBase
                : win[superCstrName];
              const Cstr = (win[cstrName] = defineConstructorName(
                12 === interfaceType
                  ? class extends WorkerBase {
                      constructor(...args) {
                        super();
                        constructGlobal(this, cstrName, args);
                      }
                    }
                  : win[cstrName] || class extends SuperCstr {},
                cstrName
              ));
              nodeName && (nodeCstrs[nodeName] = Cstr);
              members.map(([memberName, memberType, staticValue]) => {
                memberName in Cstr.prototype ||
                  memberName in SuperCstr.prototype ||
                  ("string" == typeof memberType
                    ? definePrototypeProperty(Cstr, memberName, {
                        get() {
                          if (!hasInstanceStateValue(this, memberName)) {
                            const instanceId = this[InstanceIdKey];
                            const applyPath = [
                              ...this[ApplyPathKey],
                              memberName,
                            ];
                            const PropCstr = win[memberType];
                            PropCstr &&
                              setInstanceStateValue(
                                this,
                                memberName,
                                new PropCstr($winId$, instanceId, applyPath)
                              );
                          }
                          return getInstanceStateValue(this, memberName);
                        },
                        set(value) {
                          setInstanceStateValue(this, memberName, value);
                        },
                      })
                    : 5 === memberType
                    ? definePrototypeValue(
                        Cstr,
                        memberName,
                        function (...args) {
                          return callMethod(this, [memberName], args);
                        }
                      )
                    : memberType > 0 &&
                      (void 0 !== staticValue
                        ? definePrototypeValue(Cstr, memberName, staticValue)
                        : definePrototypeProperty(Cstr, memberName, {
                            get() {
                              return getter(this, [memberName]);
                            },
                            set(value) {
                              return setter(this, [memberName], value);
                            },
                          })));
              });
            }
          );
          commaSplit(
            "atob,btoa,crypto,indexedDB,setTimeout,setInterval,clearTimeout,clearInterval"
          ).map((globalName) => {
            delete WorkerWindow.prototype[globalName];
            if (!(globalName in win)) {
              value = self[globalName];
              null != value &&
                (win[globalName] =
                  "function" != typeof value ||
                  value.toString().startsWith("class")
                    ? value
                    : value.bind(self));
            }
          });
          Object.getOwnPropertyNames(self).map((globalName) => {
            globalName in win || (win[globalName] = self[globalName]);
          });
          windowMediaConstructors.map((cstrName) =>
            defineProperty(win, cstrName, {
              get() {
                initWindowMedia();
                return win[cstrName];
              },
            })
          );
          "trustedTypes" in self && (win.trustedTypes = self.trustedTypes);
          patchElement(win.Element, win.HTMLElement);
          patchDocument(win.Document, env, isDocumentImplementation);
          ((WorkerDocumentFragment) => {
            definePrototypeNodeType(WorkerDocumentFragment, 11);
            cachedTreeProps(WorkerDocumentFragment, elementStructurePropNames);
          })(win.DocumentFragment);
          patchHTMLAnchorElement(win.HTMLAnchorElement, env);
          ((WorkerHTMLFormElement) => {
            definePrototypePropertyDescriptor(WorkerHTMLFormElement, {});
            cachedProps(WorkerHTMLFormElement, "elements");
          })(win.HTMLFormElement);
          patchHTMLIFrameElement(win.HTMLIFrameElement);
          patchHTMLScriptElement(win.HTMLScriptElement, env);
          patchSvgElement(win.SVGGraphicsElement);
          patchDocumentElementChild(win.HTMLHeadElement, env);
          patchDocumentElementChild(win.HTMLBodyElement, env);
          ((WorkerHTMLHtmlElement, env) => {
            const DocumentElementDescriptorMap = {
              parentElement: {
                value: null,
              },
              parentNode: {
                get: () => env.$document$,
              },
            };
            definePrototypePropertyDescriptor(
              WorkerHTMLHtmlElement,
              DocumentElementDescriptorMap
            );
          })(win.HTMLHtmlElement, env);
          createCSSStyleSheetConstructor(win, "CSSStyleSheet");
          definePrototypeNodeType(win.Comment, 8);
          definePrototypeNodeType(win.DocumentType, 10);
          Object.assign(env, {
            $winId$: $winId$,
            $parentWinId$: $parentWinId$,
            $window$: new Proxy(win, {
              get: (win, propName) => {
                var _a;
                if ("string" != typeof propName || isNaN(propName)) {
                  return (
                    null === (_a = webWorkerCtx.$config$.mainWindowAccessors) ||
                    void 0 === _a
                      ? void 0
                      : _a.includes(propName)
                  )
                    ? getter(this, [propName])
                    : win[propName];
                }
                {
                  let frame = getChildEnvs()[propName];
                  return frame ? frame.$window$ : void 0;
                }
              },
              has: () => true,
            }),
            $document$: $createNode$("#document", $winId$ + ".d"),
            $documentElement$: $createNode$("HTML", $winId$ + ".e"),
            $head$: $createNode$("HEAD", $winId$ + ".h"),
            $body$: $createNode$("BODY", $winId$ + ".b"),
            $location$: $location$,
            $visibilityState$: $visibilityState$,
            $isSameOrigin$: $isSameOrigin$,
            $isTopWindow$: $isTopWindow$,
            $createNode$: $createNode$,
          });
          win.requestAnimationFrame = (cb) =>
            setTimeout(() => cb(performance.now()), 9);
          win.cancelAnimationFrame = (id) => clearTimeout(id);
          win.requestIdleCallback = (cb, start) => {
            start = Date.now();
            return setTimeout(
              () =>
                cb({
                  didTimeout: false,
                  timeRemaining: () => Math.max(0, 50 - (Date.now() - start)),
                }),
              1
            );
          };
          win.cancelIdleCallback = (id) => clearTimeout(id);
          addStorageApi(
            win,
            "localStorage",
            webWorkerlocalStorage,
            $isSameOrigin$,
            env
          );
          addStorageApi(
            win,
            "sessionStorage",
            webWorkerSessionStorage,
            $isSameOrigin$,
            env
          );
          $isSameOrigin$ || (win.indexeddb = void 0);
          if (isIframeWindow) {
            historyState = {};
            win.history = {
              pushState(stateObj) {
                historyState = stateObj;
              },
              replaceState(stateObj) {
                historyState = stateObj;
              },
              get state() {
                return historyState;
              },
              length: 0,
            };
            win.indexeddb = void 0;
          } else {
            const originalPushState = win.history.pushState.bind(win.history);
            const originalReplaceState = win.history.replaceState.bind(
              win.history
            );
            win.history.pushState = (stateObj, _, newUrl) => {
              false !== env.$propagateHistoryChange$ &&
                originalPushState(stateObj, _, newUrl);
            };
            win.history.replaceState = (stateObj, _, newUrl) => {
              false !== env.$propagateHistoryChange$ &&
                originalReplaceState(stateObj, _, newUrl);
            };
          }
          win.Worker = void 0;
        }
        addEventListener(...args) {
          "load" === args[0]
            ? env.$runWindowLoadEvent$ &&
              setTimeout(() =>
                args[1]({
                  type: "load",
                })
              )
            : callMethod(this, ["addEventListener"], args, 2);
        }
        get body() {
          return env.$body$;
        }
        get document() {
          return env.$document$;
        }
        get documentElement() {
          return env.$documentElement$;
        }
        fetch(input, init) {
          input =
            "string" == typeof input || input instanceof URL
              ? String(input)
              : input.url;
          return fetch(resolveUrl(env, input, "fetch"), init);
        }
        get frames() {
          return env.$window$;
        }
        get frameElement() {
          return $isTopWindow$
            ? null
            : getOrCreateNodeInstance($parentWinId$, $winId$, "INPUT");
        }
        get globalThis() {
          return env.$window$;
        }
        get head() {
          return env.$head$;
        }
        get length() {
          return getChildEnvs().length;
        }
        get location() {
          return $location$;
        }
        set location(loc) {
          $location$.href = loc + "";
        }
        get Image() {
          return createImageConstructor(env);
        }
        get navigator() {
          return ((env) => {
            let key;
            let nav = {
              sendBeacon: (url, body) => {
                if (webWorkerCtx.$config$.logSendBeaconRequests) {
                  try {
                    logWorker(
                      `sendBeacon: ${resolveUrl(env, url, null)}${
                        body ? ", data: " + JSON.stringify(body) : ""
                      }`
                    );
                  } catch (e) {
                    console.error(e);
                  }
                }
                try {
                  fetch(resolveUrl(env, url, null), {
                    method: "POST",
                    body: body,
                    mode: "no-cors",
                    keepalive: true,
                  });
                  return true;
                } catch (e) {
                  console.error(e);
                  return false;
                }
              },
            };
            for (key in navigator) {
              nav[key] = navigator[key];
            }
            return nav;
          })(env);
        }
        get origin() {
          return $location$.origin;
        }
        set origin(_) {}
        get parent() {
          for (let envWinId in environments) {
            if (environments[envWinId].$winId$ === $parentWinId$) {
              return environments[envWinId].$window$;
            }
          }
          return env.$window$;
        }
        postMessage(...args) {
          if (environments[args[0]]) {
            len(postMessages) > 50 && postMessages.splice(0, 5);
            postMessages.push({
              $winId$: args[0],
              $data$: JSON.stringify(args[1]),
            });
            args = args.slice(1);
          }
          callMethod(this, ["postMessage"], args, 3);
        }
        get self() {
          return env.$window$;
        }
        get top() {
          for (let envWinId in environments) {
            if (environments[envWinId].$isTopWindow$) {
              return environments[envWinId].$window$;
            }
          }
          return env.$window$;
        }
        get window() {
          return env.$window$;
        }
        get XMLHttpRequest() {
          const Xhr = XMLHttpRequest;
          const str = String(Xhr);
          const ExtendedXhr = defineConstructorName(
            class extends Xhr {
              open(...args) {
                args[1] = resolveUrl(env, args[1], "xhr");
                super.open(...args);
              }
              set withCredentials(_) {}
              toString() {
                return str;
              }
            },
            getConstructorName(Xhr)
          );
          ExtendedXhr.prototype.constructor.toString = () => str;
          return ExtendedXhr;
        }
      },
      "Window"
    );
    const WorkerTrapProxy = class extends WorkerBase {
      constructor(winId, instanceId, applyPath, nodeName) {
        super(winId, instanceId, applyPath, nodeName);
        return new Proxy(this, {
          get: (instance, propName) => getter(instance, [propName]),
          set(instance, propName, propValue) {
            setter(instance, [propName], propValue);
            return true;
          },
        });
      }
    };
    const WorkerEventTargetProxy = class extends WorkerBase {};
    eventTargetMethods.map(
      (methodName) =>
        (WorkerEventTargetProxy.prototype[methodName] = function (...args) {
          return callMethod(this, [methodName], args, 2);
        })
    );
    cachedProps(WorkerWindow, "devicePixelRatio");
    cachedDimensionProps(WorkerWindow);
    cachedDimensionMethods(WorkerWindow, ["getComputedStyle"]);
    new WorkerWindow();
    return env;
  };
  const TrapConstructors = {
    DOMStringMap: 1,
    NamedNodeMap: 1,
  };
  const createEnvironment = (
    {
      $winId$: $winId$,
      $parentWinId$: $parentWinId$,
      $url$: $url$,
      $visibilityState$: $visibilityState$,
    },
    isIframeWindow,
    isDocumentImplementation
  ) => {
    if (!environments[$winId$]) {
      environments[$winId$] = createWindow(
        $winId$,
        $parentWinId$,
        $url$,
        $visibilityState$,
        isIframeWindow,
        isDocumentImplementation
      );
      {
        const winType = $winId$ === $parentWinId$ ? "top" : "input";
        logWorker(
          `Created ${winType} window ${normalizedWinId($winId$)} environment`,
          $winId$
        );
      }
    }
    webWorkerCtx.$postMessage$([7, $winId$]);
    return environments[$winId$];
  };
  const queuedEvents = [];
  const receiveMessageFromSandboxToWorker = (ev) => {
    const msg = ev.data;
    const msgType = msg[0];
    const msgValue = msg[1];
    if (webWorkerCtx.$isInitialized$) {
      if (7 === msgType) {
        (async (initScript) => {
          let winId = initScript.$winId$;
          let instanceId = initScript.$instanceId$;
          let instance = getOrCreateNodeInstance(winId, instanceId, "SCRIPT");
          let scriptContent = initScript.$content$;
          let scriptSrc = initScript.$url$;
          let scriptOrgSrc = initScript.$orgUrl$;
          let errorMsg = "";
          let env = environments[winId];
          let rsp;
          let javascriptContentTypes = [
            "text/jscript",
            "text/javascript",
            "text/x-javascript",
            "application/javascript",
            "application/x-javascript",
            "text/ecmascript",
            "text/x-ecmascript",
            "application/ecmascript",
          ];
          if (scriptSrc) {
            try {
              scriptSrc = resolveToUrl(env, scriptSrc, "script") + "";
              setInstanceStateValue(instance, 4, scriptSrc);
              webWorkerCtx.$config$.logScriptExecution &&
                logWorker(`Execute script src: ${scriptOrgSrc}`, winId);
              rsp = await fetch(scriptSrc);
              if (rsp.ok) {
                let responseContentType = rsp.headers.get("content-type");
                let shouldExecute = javascriptContentTypes.some((ct) => {
                  var _a, _b, _c;
                  return null ===
                    (_c =
                      null ===
                        (_a =
                          null == responseContentType
                            ? void 0
                            : responseContentType.toLowerCase) || void 0 === _a
                        ? void 0
                        : (_b = _a.call(responseContentType)).includes) ||
                    void 0 === _c
                    ? void 0
                    : _c.call(_b, ct);
                });
                if (shouldExecute) {
                  scriptContent = await rsp.text();
                  env.$currentScriptId$ = instanceId;
                  run(env, scriptContent, scriptOrgSrc || scriptSrc);
                }
                runStateLoadHandlers(instance, "load");
              } else {
                errorMsg = rsp.statusText;
                runStateLoadHandlers(instance, "error");
              }
            } catch (urlError) {
              console.error(urlError);
              errorMsg = String(urlError.stack || urlError);
              runStateLoadHandlers(instance, "error");
            }
          } else {
            scriptContent &&
              (errorMsg = runScriptContent(
                env,
                instanceId,
                scriptContent,
                winId,
                errorMsg
              ));
          }
          env.$currentScriptId$ = "";
          webWorkerCtx.$postMessage$([6, winId, instanceId, errorMsg]);
        })(msgValue);
      } else if (9 === msgType) {
        (({
          $winId$: $winId$,
          $instanceId$: $instanceId$,
          $refId$: $refId$,
          $thisArg$: $thisArg$,
          $args$: $args$,
        }) => {
          if (webWorkerRefsByRefId[$refId$]) {
            try {
              webWorkerRefsByRefId[$refId$].apply(
                deserializeFromMain($winId$, $instanceId$, [], $thisArg$),
                deserializeFromMain($winId$, $instanceId$, [], $args$)
              );
            } catch (e) {
              console.error(e);
            }
          }
        })(msgValue);
      } else if (10 === msgType) {
        (({ $winId$: $winId$, $forward$: $forward$, $args$: $args$ }) => {
          try {
            let target = environments[$winId$].$window$;
            let i = 0;
            let l = len($forward$);
            for (; i < l; i++) {
              i + 1 < l
                ? (target = target[$forward$[i]])
                : target[$forward$[i]].apply(
                    target,
                    deserializeFromMain(null, $winId$, [], $args$)
                  );
            }
          } catch (e) {
            console.error(e);
          }
        })(msgValue);
      } else if (5 === msgType) {
        createEnvironment(msgValue);
      } else if (8 === msgType) {
        if (1 !== environments[msgValue].$isInitialized$) {
          const winId = msgValue;
          const env = environments[winId];
          const winType = env.$winId$ === env.$parentWinId$ ? "top" : "iframe";
          logWorker(
            `Initialized ${winType} window ${normalizedWinId(
              winId
            )} environment 🎉`,
            winId
          );
        }
        environments[msgValue].$isInitialized$ = 1;
        environments[msgValue].$isLoading$ = 0;
      } else if (14 === msgType) {
        environments[msgValue].$visibilityState$ = msg[2];
      } else if (13 === msgType) {
        const $winId$ = msgValue.$winId$;
        const env = environments[$winId$];
        env.$location$.href = msgValue.url;
        !(function ($winId$, env, data) {
          const history = env.$window$.history;
          switch (data.type) {
            case 0:
              env.$propagateHistoryChange$ = false;
              try {
                history.pushState(data.state, "", data.newUrl);
              } catch (e) {}
              env.$propagateHistoryChange$ = true;
              break;

            case 1:
              env.$propagateHistoryChange$ = false;
              try {
                history.replaceState(data.state, "", data.newUrl);
              } catch (e) {}
              env.$propagateHistoryChange$ = true;
          }
        })(msgValue.$winId$, env, msgValue);
      } else {
        15 === msgType &&
          ((_type, winId, instanceId, callbackName, args) => {
            const elm = getOrCreateNodeInstance(winId, instanceId);
            elm &&
              "function" == typeof elm[callbackName] &&
              elm[callbackName].apply(elm, args);
          })(...msg);
      }
    } else if (1 === msgType) {
      ((initWebWorkerData) => {
        const config = (webWorkerCtx.$config$ = JSON.parse(
          initWebWorkerData.$config$
        ));
        const locOrigin = initWebWorkerData.$origin$;
        webWorkerCtx.$importScripts$ = importScripts.bind(self);
        webWorkerCtx.$interfaces$ = initWebWorkerData.$interfaces$;
        webWorkerCtx.$libPath$ = initWebWorkerData.$libPath$;
        webWorkerCtx.$origin$ = locOrigin;
        webWorkerCtx.$postMessage$ = postMessage.bind(self);
        webWorkerCtx.$sharedDataBuffer$ = initWebWorkerData.$sharedDataBuffer$;
        webWorkerlocalStorage.set(locOrigin, initWebWorkerData.$localStorage$);
        webWorkerSessionStorage.set(
          locOrigin,
          initWebWorkerData.$sessionStorage$
        );
        self.importScripts = void 0;
        delete self.postMessage;
        delete self.WorkerGlobalScope;
        commaSplit("resolveUrl,get,set,apply").map((configName) => {
          config[configName] &&
            (config[configName] = new Function(
              "return " + config[configName]
            )());
        });
      })(msgValue);
      webWorkerCtx.$postMessage$([2]);
    } else if (3 === msgType) {
      webWorkerCtx.$interfaces$ = [...webWorkerCtx.$interfaces$, ...msgValue];
      webWorkerCtx.$isInitialized$ = 1;
      logWorker("Initialized web worker");
      webWorkerCtx.$postMessage$([4]);
      queuedEvents.length &&
        logWorker(`Queued ready messages: ${queuedEvents.length}`);
      [...queuedEvents].map(receiveMessageFromSandboxToWorker);
      queuedEvents.length = 0;
    } else {
      queuedEvents.push(ev);
    }
  };
  self.onmessage = receiveMessageFromSandboxToWorker;
  postMessage([0]);
})(self);