@kizenapps/engine 0.0.1-b1f3597

package/dist/chunk-2MW4AGSN.js

@@ -0,0 +1,2415 @@
+import { generateUUIDV4, getPartialLocation } from './chunk-XKKZPZMB.js';
+import { IFRAME_PREFIX, ACTIONS, RESPONSES, COMMUNICATIONS, thirdPartyGlobalNames, getScriptIntegrationType, thirdPartySetupScripts, thirdPartyReadyPredicates } from './chunk-P7GQBCEH.js';
+import { __commonJS, __toESM } from './chunk-5WRI5ZAA.js';
+import DOMPurify from 'dompurify';
+
+// node_modules/.pnpm/jsonify@0.0.1/node_modules/jsonify/lib/parse.js
+var require_parse = __commonJS({
+  "node_modules/.pnpm/jsonify@0.0.1/node_modules/jsonify/lib/parse.js"(exports$1, module) {
+    var at;
+    var ch;
+    var escapee = {
+      '"': '"',
+      "\\": "\\",
+      "/": "/",
+      b: "\b",
+      f: "\f",
+      n: "\n",
+      r: "\r",
+      t: "	"
+    };
+    var text;
+    function error(m) {
+      throw {
+        name: "SyntaxError",
+        message: m,
+        at,
+        text
+      };
+    }
+    function next(c) {
+      if (c && c !== ch) {
+        error("Expected '" + c + "' instead of '" + ch + "'");
+      }
+      ch = text.charAt(at);
+      at += 1;
+      return ch;
+    }
+    function number() {
+      var num;
+      var str = "";
+      if (ch === "-") {
+        str = "-";
+        next("-");
+      }
+      while (ch >= "0" && ch <= "9") {
+        str += ch;
+        next();
+      }
+      if (ch === ".") {
+        str += ".";
+        while (next() && ch >= "0" && ch <= "9") {
+          str += ch;
+        }
+      }
+      if (ch === "e" || ch === "E") {
+        str += ch;
+        next();
+        if (ch === "-" || ch === "+") {
+          str += ch;
+          next();
+        }
+        while (ch >= "0" && ch <= "9") {
+          str += ch;
+          next();
+        }
+      }
+      num = Number(str);
+      if (!isFinite(num)) {
+        error("Bad number");
+      }
+      return num;
+    }
+    function string() {
+      var hex;
+      var i;
+      var str = "";
+      var uffff;
+      if (ch === '"') {
+        while (next()) {
+          if (ch === '"') {
+            next();
+            return str;
+          } else if (ch === "\\") {
+            next();
+            if (ch === "u") {
+              uffff = 0;
+              for (i = 0; i < 4; i += 1) {
+                hex = parseInt(next(), 16);
+                if (!isFinite(hex)) {
+                  break;
+                }
+                uffff = uffff * 16 + hex;
+              }
+              str += String.fromCharCode(uffff);
+            } else if (typeof escapee[ch] === "string") {
+              str += escapee[ch];
+            } else {
+              break;
+            }
+          } else {
+            str += ch;
+          }
+        }
+      }
+      error("Bad string");
+    }
+    function white() {
+      while (ch && ch <= " ") {
+        next();
+      }
+    }
+    function word() {
+      switch (ch) {
+        case "t":
+          next("t");
+          next("r");
+          next("u");
+          next("e");
+          return true;
+        case "f":
+          next("f");
+          next("a");
+          next("l");
+          next("s");
+          next("e");
+          return false;
+        case "n":
+          next("n");
+          next("u");
+          next("l");
+          next("l");
+          return null;
+        default:
+          error("Unexpected '" + ch + "'");
+      }
+    }
+    function array() {
+      var arr = [];
+      if (ch === "[") {
+        next("[");
+        white();
+        if (ch === "]") {
+          next("]");
+          return arr;
+        }
+        while (ch) {
+          arr.push(value());
+          white();
+          if (ch === "]") {
+            next("]");
+            return arr;
+          }
+          next(",");
+          white();
+        }
+      }
+      error("Bad array");
+    }
+    function object() {
+      var key;
+      var obj = {};
+      if (ch === "{") {
+        next("{");
+        white();
+        if (ch === "}") {
+          next("}");
+          return obj;
+        }
+        while (ch) {
+          key = string();
+          white();
+          next(":");
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            error('Duplicate key "' + key + '"');
+          }
+          obj[key] = value();
+          white();
+          if (ch === "}") {
+            next("}");
+            return obj;
+          }
+          next(",");
+          white();
+        }
+      }
+      error("Bad object");
+    }
+    function value() {
+      white();
+      switch (ch) {
+        case "{":
+          return object();
+        case "[":
+          return array();
+        case '"':
+          return string();
+        case "-":
+          return number();
+        default:
+          return ch >= "0" && ch <= "9" ? number() : word();
+      }
+    }
+    module.exports = function(source, reviver) {
+      var result;
+      text = source;
+      at = 0;
+      ch = " ";
+      result = value();
+      white();
+      if (ch) {
+        error("Syntax error");
+      }
+      return typeof reviver === "function" ? (function walk(holder, key) {
+        var k;
+        var v;
+        var val = holder[key];
+        if (val && typeof val === "object") {
+          for (k in value) {
+            if (Object.prototype.hasOwnProperty.call(val, k)) {
+              v = walk(val, k);
+              if (typeof v === "undefined") {
+                delete val[k];
+              } else {
+                val[k] = v;
+              }
+            }
+          }
+        }
+        return reviver.call(holder, key, val);
+      })({ "": result }, "") : result;
+    };
+  }
+});
+
+// node_modules/.pnpm/jsonify@0.0.1/node_modules/jsonify/lib/stringify.js
+var require_stringify = __commonJS({
+  "node_modules/.pnpm/jsonify@0.0.1/node_modules/jsonify/lib/stringify.js"(exports$1, module) {
+    var escapable = /[\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
+    var gap;
+    var indent;
+    var meta = {
+      // table of character substitutions
+      "\b": "\\b",
+      "	": "\\t",
+      "\n": "\\n",
+      "\f": "\\f",
+      "\r": "\\r",
+      '"': '\\"',
+      "\\": "\\\\"
+    };
+    var rep;
+    function quote(string) {
+      escapable.lastIndex = 0;
+      return escapable.test(string) ? '"' + string.replace(escapable, function(a) {
+        var c = meta[a];
+        return typeof c === "string" ? c : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4);
+      }) + '"' : '"' + string + '"';
+    }
+    function str(key, holder) {
+      var i;
+      var k;
+      var v;
+      var length;
+      var mind = gap;
+      var partial;
+      var value = holder[key];
+      if (value && typeof value === "object" && typeof value.toJSON === "function") {
+        value = value.toJSON(key);
+      }
+      if (typeof rep === "function") {
+        value = rep.call(holder, key, value);
+      }
+      switch (typeof value) {
+        case "string":
+          return quote(value);
+        case "number":
+          return isFinite(value) ? String(value) : "null";
+        case "boolean":
+        case "null":
+          return String(value);
+        case "object":
+          if (!value) {
+            return "null";
+          }
+          gap += indent;
+          partial = [];
+          if (Object.prototype.toString.apply(value) === "[object Array]") {
+            length = value.length;
+            for (i = 0; i < length; i += 1) {
+              partial[i] = str(i, value) || "null";
+            }
+            v = partial.length === 0 ? "[]" : gap ? "[\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "]" : "[" + partial.join(",") + "]";
+            gap = mind;
+            return v;
+          }
+          if (rep && typeof rep === "object") {
+            length = rep.length;
+            for (i = 0; i < length; i += 1) {
+              k = rep[i];
+              if (typeof k === "string") {
+                v = str(k, value);
+                if (v) {
+                  partial.push(quote(k) + (gap ? ": " : ":") + v);
+                }
+              }
+            }
+          } else {
+            for (k in value) {
+              if (Object.prototype.hasOwnProperty.call(value, k)) {
+                v = str(k, value);
+                if (v) {
+                  partial.push(quote(k) + (gap ? ": " : ":") + v);
+                }
+              }
+            }
+          }
+          v = partial.length === 0 ? "{}" : gap ? "{\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "}" : "{" + partial.join(",") + "}";
+          gap = mind;
+          return v;
+      }
+    }
+    module.exports = function(value, replacer, space) {
+      var i;
+      gap = "";
+      indent = "";
+      if (typeof space === "number") {
+        for (i = 0; i < space; i += 1) {
+          indent += " ";
+        }
+      } else if (typeof space === "string") {
+        indent = space;
+      }
+      rep = replacer;
+      if (replacer && typeof replacer !== "function" && (typeof replacer !== "object" || typeof replacer.length !== "number")) {
+        throw new Error("JSON.stringify");
+      }
+      return str("", { "": value });
+    };
+  }
+});
+
+// node_modules/.pnpm/jsonify@0.0.1/node_modules/jsonify/index.js
+var require_jsonify = __commonJS({
+  "node_modules/.pnpm/jsonify@0.0.1/node_modules/jsonify/index.js"(exports$1) {
+    exports$1.parse = require_parse();
+    exports$1.stringify = require_stringify();
+  }
+});
+
+// node_modules/.pnpm/isarray@2.0.5/node_modules/isarray/index.js
+var require_isarray = __commonJS({
+  "node_modules/.pnpm/isarray@2.0.5/node_modules/isarray/index.js"(exports$1, module) {
+    var toString = {}.toString;
+    module.exports = Array.isArray || function(arr) {
+      return toString.call(arr) == "[object Array]";
+    };
+  }
+});
+
+// node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js
+var require_isArguments = __commonJS({
+  "node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js"(exports$1, module) {
+    var toStr = Object.prototype.toString;
+    module.exports = function isArguments(value) {
+      var str = toStr.call(value);
+      var isArgs = str === "[object Arguments]";
+      if (!isArgs) {
+        isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
+      }
+      return isArgs;
+    };
+  }
+});
+
+// node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js
+var require_implementation = __commonJS({
+  "node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js"(exports$1, module) {
+    var keysShim;
+    if (!Object.keys) {
+      has = Object.prototype.hasOwnProperty;
+      toStr = Object.prototype.toString;
+      isArgs = require_isArguments();
+      isEnumerable = Object.prototype.propertyIsEnumerable;
+      hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString");
+      hasProtoEnumBug = isEnumerable.call(function() {
+      }, "prototype");
+      dontEnums = [
+        "toString",
+        "toLocaleString",
+        "valueOf",
+        "hasOwnProperty",
+        "isPrototypeOf",
+        "propertyIsEnumerable",
+        "constructor"
+      ];
+      equalsConstructorPrototype = function(o) {
+        var ctor = o.constructor;
+        return ctor && ctor.prototype === o;
+      };
+      excludedKeys = {
+        $applicationCache: true,
+        $console: true,
+        $external: true,
+        $frame: true,
+        $frameElement: true,
+        $frames: true,
+        $innerHeight: true,
+        $innerWidth: true,
+        $onmozfullscreenchange: true,
+        $onmozfullscreenerror: true,
+        $outerHeight: true,
+        $outerWidth: true,
+        $pageXOffset: true,
+        $pageYOffset: true,
+        $parent: true,
+        $scrollLeft: true,
+        $scrollTop: true,
+        $scrollX: true,
+        $scrollY: true,
+        $self: true,
+        $webkitIndexedDB: true,
+        $webkitStorageInfo: true,
+        $window: true
+      };
+      hasAutomationEqualityBug = (function() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        for (var k in window) {
+          try {
+            if (!excludedKeys["$" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === "object") {
+              try {
+                equalsConstructorPrototype(window[k]);
+              } catch (e) {
+                return true;
+              }
+            }
+          } catch (e) {
+            return true;
+          }
+        }
+        return false;
+      })();
+      equalsConstructorPrototypeIfNotBuggy = function(o) {
+        if (typeof window === "undefined" || !hasAutomationEqualityBug) {
+          return equalsConstructorPrototype(o);
+        }
+        try {
+          return equalsConstructorPrototype(o);
+        } catch (e) {
+          return false;
+        }
+      };
+      keysShim = function keys(object) {
+        var isObject = object !== null && typeof object === "object";
+        var isFunction = toStr.call(object) === "[object Function]";
+        var isArguments = isArgs(object);
+        var isString = isObject && toStr.call(object) === "[object String]";
+        var theKeys = [];
+        if (!isObject && !isFunction && !isArguments) {
+          throw new TypeError("Object.keys called on a non-object");
+        }
+        var skipProto = hasProtoEnumBug && isFunction;
+        if (isString && object.length > 0 && !has.call(object, 0)) {
+          for (var i = 0; i < object.length; ++i) {
+            theKeys.push(String(i));
+          }
+        }
+        if (isArguments && object.length > 0) {
+          for (var j = 0; j < object.length; ++j) {
+            theKeys.push(String(j));
+          }
+        } else {
+          for (var name in object) {
+            if (!(skipProto && name === "prototype") && has.call(object, name)) {
+              theKeys.push(String(name));
+            }
+          }
+        }
+        if (hasDontEnumBug) {
+          var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+          for (var k = 0; k < dontEnums.length; ++k) {
+            if (!(skipConstructor && dontEnums[k] === "constructor") && has.call(object, dontEnums[k])) {
+              theKeys.push(dontEnums[k]);
+            }
+          }
+        }
+        return theKeys;
+      };
+    }
+    var has;
+    var toStr;
+    var isArgs;
+    var isEnumerable;
+    var hasDontEnumBug;
+    var hasProtoEnumBug;
+    var dontEnums;
+    var equalsConstructorPrototype;
+    var excludedKeys;
+    var hasAutomationEqualityBug;
+    var equalsConstructorPrototypeIfNotBuggy;
+    module.exports = keysShim;
+  }
+});
+
+// node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js
+var require_object_keys = __commonJS({
+  "node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js"(exports$1, module) {
+    var slice = Array.prototype.slice;
+    var isArgs = require_isArguments();
+    var origKeys = Object.keys;
+    var keysShim = origKeys ? function keys(o) {
+      return origKeys(o);
+    } : require_implementation();
+    var originalKeys = Object.keys;
+    keysShim.shim = function shimObjectKeys() {
+      if (Object.keys) {
+        var keysWorksWithArguments = (function() {
+          var args = Object.keys(arguments);
+          return args && args.length === arguments.length;
+        })(1, 2);
+        if (!keysWorksWithArguments) {
+          Object.keys = function keys(object) {
+            if (isArgs(object)) {
+              return originalKeys(slice.call(object));
+            }
+            return originalKeys(object);
+          };
+        }
+      } else {
+        Object.keys = keysShim;
+      }
+      return Object.keys || keysShim;
+    };
+    module.exports = keysShim;
+  }
+});
+
+// node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js
+var require_es_object_atoms = __commonJS({
+  "node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js"(exports$1, module) {
+    module.exports = Object;
+  }
+});
+
+// node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js
+var require_es_errors = __commonJS({
+  "node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js"(exports$1, module) {
+    module.exports = Error;
+  }
+});
+
+// node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js
+var require_eval = __commonJS({
+  "node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js"(exports$1, module) {
+    module.exports = EvalError;
+  }
+});
+
+// node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js
+var require_range = __commonJS({
+  "node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js"(exports$1, module) {
+    module.exports = RangeError;
+  }
+});
+
+// node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js
+var require_ref = __commonJS({
+  "node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js"(exports$1, module) {
+    module.exports = ReferenceError;
+  }
+});
+
+// node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js
+var require_syntax = __commonJS({
+  "node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js"(exports$1, module) {
+    module.exports = SyntaxError;
+  }
+});
+
+// node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js
+var require_type = __commonJS({
+  "node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js"(exports$1, module) {
+    module.exports = TypeError;
+  }
+});
+
+// node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js
+var require_uri = __commonJS({
+  "node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js"(exports$1, module) {
+    module.exports = URIError;
+  }
+});
+
+// node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js
+var require_abs = __commonJS({
+  "node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js"(exports$1, module) {
+    module.exports = Math.abs;
+  }
+});
+
+// node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js
+var require_floor = __commonJS({
+  "node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js"(exports$1, module) {
+    module.exports = Math.floor;
+  }
+});
+
+// node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js
+var require_max = __commonJS({
+  "node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js"(exports$1, module) {
+    module.exports = Math.max;
+  }
+});
+
+// node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js
+var require_min = __commonJS({
+  "node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js"(exports$1, module) {
+    module.exports = Math.min;
+  }
+});
+
+// node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js
+var require_pow = __commonJS({
+  "node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js"(exports$1, module) {
+    module.exports = Math.pow;
+  }
+});
+
+// node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js
+var require_round = __commonJS({
+  "node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js"(exports$1, module) {
+    module.exports = Math.round;
+  }
+});
+
+// node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js
+var require_isNaN = __commonJS({
+  "node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js"(exports$1, module) {
+    module.exports = Number.isNaN || function isNaN2(a) {
+      return a !== a;
+    };
+  }
+});
+
+// node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js
+var require_sign = __commonJS({
+  "node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js"(exports$1, module) {
+    var $isNaN = require_isNaN();
+    module.exports = function sign(number) {
+      if ($isNaN(number) || number === 0) {
+        return number;
+      }
+      return number < 0 ? -1 : 1;
+    };
+  }
+});
+
+// node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js
+var require_gOPD = __commonJS({
+  "node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js"(exports$1, module) {
+    module.exports = Object.getOwnPropertyDescriptor;
+  }
+});
+
+// node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js
+var require_gopd = __commonJS({
+  "node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js"(exports$1, module) {
+    var $gOPD = require_gOPD();
+    if ($gOPD) {
+      try {
+        $gOPD([], "length");
+      } catch (e) {
+        $gOPD = null;
+      }
+    }
+    module.exports = $gOPD;
+  }
+});
+
+// node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js
+var require_es_define_property = __commonJS({
+  "node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js"(exports$1, module) {
+    var $defineProperty = Object.defineProperty || false;
+    if ($defineProperty) {
+      try {
+        $defineProperty({}, "a", { value: 1 });
+      } catch (e) {
+        $defineProperty = false;
+      }
+    }
+    module.exports = $defineProperty;
+  }
+});
+
+// node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js
+var require_shams = __commonJS({
+  "node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js"(exports$1, module) {
+    module.exports = function hasSymbols() {
+      if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
+        return false;
+      }
+      if (typeof Symbol.iterator === "symbol") {
+        return true;
+      }
+      var obj = {};
+      var sym = /* @__PURE__ */ Symbol("test");
+      var symObj = Object(sym);
+      if (typeof sym === "string") {
+        return false;
+      }
+      if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
+        return false;
+      }
+      if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
+        return false;
+      }
+      var symVal = 42;
+      obj[sym] = symVal;
+      for (var _ in obj) {
+        return false;
+      }
+      if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
+        return false;
+      }
+      var syms = Object.getOwnPropertySymbols(obj);
+      if (syms.length !== 1 || syms[0] !== sym) {
+        return false;
+      }
+      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyDescriptor === "function") {
+        var descriptor = (
+          /** @type {PropertyDescriptor} */
+          Object.getOwnPropertyDescriptor(obj, sym)
+        );
+        if (descriptor.value !== symVal || descriptor.enumerable !== true) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+});
+
+// node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js
+var require_has_symbols = __commonJS({
+  "node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js"(exports$1, module) {
+    var origSymbol = typeof Symbol !== "undefined" && Symbol;
+    var hasSymbolSham = require_shams();
+    module.exports = function hasNativeSymbols() {
+      if (typeof origSymbol !== "function") {
+        return false;
+      }
+      if (typeof Symbol !== "function") {
+        return false;
+      }
+      if (typeof origSymbol("foo") !== "symbol") {
+        return false;
+      }
+      if (typeof /* @__PURE__ */ Symbol("bar") !== "symbol") {
+        return false;
+      }
+      return hasSymbolSham();
+    };
+  }
+});
+
+// node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js
+var require_Reflect_getPrototypeOf = __commonJS({
+  "node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js"(exports$1, module) {
+    module.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
+  }
+});
+
+// node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js
+var require_Object_getPrototypeOf = __commonJS({
+  "node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js"(exports$1, module) {
+    var $Object = require_es_object_atoms();
+    module.exports = $Object.getPrototypeOf || null;
+  }
+});
+
+// node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js
+var require_implementation2 = __commonJS({
+  "node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js"(exports$1, module) {
+    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+    var toStr = Object.prototype.toString;
+    var max = Math.max;
+    var funcType = "[object Function]";
+    var concatty = function concatty2(a, b) {
+      var arr = [];
+      for (var i = 0; i < a.length; i += 1) {
+        arr[i] = a[i];
+      }
+      for (var j = 0; j < b.length; j += 1) {
+        arr[j + a.length] = b[j];
+      }
+      return arr;
+    };
+    var slicy = function slicy2(arrLike, offset) {
+      var arr = [];
+      for (var i = offset, j = 0; i < arrLike.length; i += 1, j += 1) {
+        arr[j] = arrLike[i];
+      }
+      return arr;
+    };
+    var joiny = function(arr, joiner) {
+      var str = "";
+      for (var i = 0; i < arr.length; i += 1) {
+        str += arr[i];
+        if (i + 1 < arr.length) {
+          str += joiner;
+        }
+      }
+      return str;
+    };
+    module.exports = function bind(that) {
+      var target = this;
+      if (typeof target !== "function" || toStr.apply(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+      }
+      var args = slicy(arguments, 1);
+      var bound;
+      var binder = function() {
+        if (this instanceof bound) {
+          var result = target.apply(
+            this,
+            concatty(args, arguments)
+          );
+          if (Object(result) === result) {
+            return result;
+          }
+          return this;
+        }
+        return target.apply(
+          that,
+          concatty(args, arguments)
+        );
+      };
+      var boundLength = max(0, target.length - args.length);
+      var boundArgs = [];
+      for (var i = 0; i < boundLength; i++) {
+        boundArgs[i] = "$" + i;
+      }
+      bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
+      if (target.prototype) {
+        var Empty = function Empty2() {
+        };
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+      }
+      return bound;
+    };
+  }
+});
+
+// node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js
+var require_function_bind = __commonJS({
+  "node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js"(exports$1, module) {
+    var implementation = require_implementation2();
+    module.exports = Function.prototype.bind || implementation;
+  }
+});
+
+// node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js
+var require_functionCall = __commonJS({
+  "node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js"(exports$1, module) {
+    module.exports = Function.prototype.call;
+  }
+});
+
+// node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js
+var require_functionApply = __commonJS({
+  "node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js"(exports$1, module) {
+    module.exports = Function.prototype.apply;
+  }
+});
+
+// node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js
+var require_reflectApply = __commonJS({
+  "node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js"(exports$1, module) {
+    module.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+  }
+});
+
+// node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js
+var require_actualApply = __commonJS({
+  "node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js"(exports$1, module) {
+    var bind = require_function_bind();
+    var $apply = require_functionApply();
+    var $call = require_functionCall();
+    var $reflectApply = require_reflectApply();
+    module.exports = $reflectApply || bind.call($call, $apply);
+  }
+});
+
+// node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js
+var require_call_bind_apply_helpers = __commonJS({
+  "node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js"(exports$1, module) {
+    var bind = require_function_bind();
+    var $TypeError = require_type();
+    var $call = require_functionCall();
+    var $actualApply = require_actualApply();
+    module.exports = function callBindBasic(args) {
+      if (args.length < 1 || typeof args[0] !== "function") {
+        throw new $TypeError("a function is required");
+      }
+      return $actualApply(bind, $call, args);
+    };
+  }
+});
+
+// node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js
+var require_get = __commonJS({
+  "node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js"(exports$1, module) {
+    var callBind = require_call_bind_apply_helpers();
+    var gOPD = require_gopd();
+    var hasProtoAccessor;
+    try {
+      hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */
+      [].__proto__ === Array.prototype;
+    } catch (e) {
+      if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") {
+        throw e;
+      }
+    }
+    var desc = !!hasProtoAccessor && gOPD && gOPD(
+      Object.prototype,
+      /** @type {keyof typeof Object.prototype} */
+      "__proto__"
+    );
+    var $Object = Object;
+    var $getPrototypeOf = $Object.getPrototypeOf;
+    module.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? (
+      /** @type {import('./get')} */
+      function getDunder(value) {
+        return $getPrototypeOf(value == null ? value : $Object(value));
+      }
+    ) : false;
+  }
+});
+
+// node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js
+var require_get_proto = __commonJS({
+  "node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js"(exports$1, module) {
+    var reflectGetProto = require_Reflect_getPrototypeOf();
+    var originalGetProto = require_Object_getPrototypeOf();
+    var getDunderProto = require_get();
+    module.exports = reflectGetProto ? function getProto(O) {
+      return reflectGetProto(O);
+    } : originalGetProto ? function getProto(O) {
+      if (!O || typeof O !== "object" && typeof O !== "function") {
+        throw new TypeError("getProto: not an object");
+      }
+      return originalGetProto(O);
+    } : getDunderProto ? function getProto(O) {
+      return getDunderProto(O);
+    } : null;
+  }
+});
+
+// node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js
+var require_hasown = __commonJS({
+  "node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js"(exports$1, module) {
+    var call = Function.prototype.call;
+    var $hasOwn = Object.prototype.hasOwnProperty;
+    var bind = require_function_bind();
+    module.exports = bind.call(call, $hasOwn);
+  }
+});
+
+// node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js
+var require_get_intrinsic = __commonJS({
+  "node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js"(exports$1, module) {
+    var undefined2;
+    var $Object = require_es_object_atoms();
+    var $Error = require_es_errors();
+    var $EvalError = require_eval();
+    var $RangeError = require_range();
+    var $ReferenceError = require_ref();
+    var $SyntaxError = require_syntax();
+    var $TypeError = require_type();
+    var $URIError = require_uri();
+    var abs = require_abs();
+    var floor = require_floor();
+    var max = require_max();
+    var min = require_min();
+    var pow = require_pow();
+    var round = require_round();
+    var sign = require_sign();
+    var $Function = Function;
+    var getEvalledConstructor = function(expressionSyntax) {
+      try {
+        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+      } catch (e) {
+      }
+    };
+    var $gOPD = require_gopd();
+    var $defineProperty = require_es_define_property();
+    var throwTypeError = function() {
+      throw new $TypeError();
+    };
+    var ThrowTypeError = $gOPD ? (function() {
+      try {
+        arguments.callee;
+        return throwTypeError;
+      } catch (calleeThrows) {
+        try {
+          return $gOPD(arguments, "callee").get;
+        } catch (gOPDthrows) {
+          return throwTypeError;
+        }
+      }
+    })() : throwTypeError;
+    var hasSymbols = require_has_symbols()();
+    var getProto = require_get_proto();
+    var $ObjectGPO = require_Object_getPrototypeOf();
+    var $ReflectGPO = require_Reflect_getPrototypeOf();
+    var $apply = require_functionApply();
+    var $call = require_functionCall();
+    var needsEval = {};
+    var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array);
+    var INTRINSICS = {
+      __proto__: null,
+      "%AggregateError%": typeof AggregateError === "undefined" ? undefined2 : AggregateError,
+      "%Array%": Array,
+      "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer,
+      "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,
+      "%AsyncFromSyncIteratorPrototype%": undefined2,
+      "%AsyncFunction%": needsEval,
+      "%AsyncGenerator%": needsEval,
+      "%AsyncGeneratorFunction%": needsEval,
+      "%AsyncIteratorPrototype%": needsEval,
+      "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics,
+      "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt,
+      "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined2 : BigInt64Array,
+      "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined2 : BigUint64Array,
+      "%Boolean%": Boolean,
+      "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView,
+      "%Date%": Date,
+      "%decodeURI%": decodeURI,
+      "%decodeURIComponent%": decodeURIComponent,
+      "%encodeURI%": encodeURI,
+      "%encodeURIComponent%": encodeURIComponent,
+      "%Error%": $Error,
+      "%eval%": eval,
+      // eslint-disable-line no-eval
+      "%EvalError%": $EvalError,
+      "%Float16Array%": typeof Float16Array === "undefined" ? undefined2 : Float16Array,
+      "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array,
+      "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array,
+      "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry,
+      "%Function%": $Function,
+      "%GeneratorFunction%": needsEval,
+      "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array,
+      "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array,
+      "%Int32Array%": typeof Int32Array === "undefined" ? undefined2 : Int32Array,
+      "%isFinite%": isFinite,
+      "%isNaN%": isNaN,
+      "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2,
+      "%JSON%": typeof JSON === "object" ? JSON : undefined2,
+      "%Map%": typeof Map === "undefined" ? undefined2 : Map,
+      "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
+      "%Math%": Math,
+      "%Number%": Number,
+      "%Object%": $Object,
+      "%Object.getOwnPropertyDescriptor%": $gOPD,
+      "%parseFloat%": parseFloat,
+      "%parseInt%": parseInt,
+      "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise,
+      "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy,
+      "%RangeError%": $RangeError,
+      "%ReferenceError%": $ReferenceError,
+      "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect,
+      "%RegExp%": RegExp,
+      "%Set%": typeof Set === "undefined" ? undefined2 : Set,
+      "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
+      "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined2 : SharedArrayBuffer,
+      "%String%": String,
+      "%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2,
+      "%Symbol%": hasSymbols ? Symbol : undefined2,
+      "%SyntaxError%": $SyntaxError,
+      "%ThrowTypeError%": ThrowTypeError,
+      "%TypedArray%": TypedArray,
+      "%TypeError%": $TypeError,
+      "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined2 : Uint8Array,
+      "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray,
+      "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array,
+      "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array,
+      "%URIError%": $URIError,
+      "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap,
+      "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef,
+      "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet,
+      "%Function.prototype.call%": $call,
+      "%Function.prototype.apply%": $apply,
+      "%Object.defineProperty%": $defineProperty,
+      "%Object.getPrototypeOf%": $ObjectGPO,
+      "%Math.abs%": abs,
+      "%Math.floor%": floor,
+      "%Math.max%": max,
+      "%Math.min%": min,
+      "%Math.pow%": pow,
+      "%Math.round%": round,
+      "%Math.sign%": sign,
+      "%Reflect.getPrototypeOf%": $ReflectGPO
+    };
+    if (getProto) {
+      try {
+        null.error;
+      } catch (e) {
+        errorProto = getProto(getProto(e));
+        INTRINSICS["%Error.prototype%"] = errorProto;
+      }
+    }
+    var errorProto;
+    var doEval = function doEval2(name) {
+      var value;
+      if (name === "%AsyncFunction%") {
+        value = getEvalledConstructor("async function () {}");
+      } else if (name === "%GeneratorFunction%") {
+        value = getEvalledConstructor("function* () {}");
+      } else if (name === "%AsyncGeneratorFunction%") {
+        value = getEvalledConstructor("async function* () {}");
+      } else if (name === "%AsyncGenerator%") {
+        var fn = doEval2("%AsyncGeneratorFunction%");
+        if (fn) {
+          value = fn.prototype;
+        }
+      } else if (name === "%AsyncIteratorPrototype%") {
+        var gen = doEval2("%AsyncGenerator%");
+        if (gen && getProto) {
+          value = getProto(gen.prototype);
+        }
+      }
+      INTRINSICS[name] = value;
+      return value;
+    };
+    var LEGACY_ALIASES = {
+      __proto__: null,
+      "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
+      "%ArrayPrototype%": ["Array", "prototype"],
+      "%ArrayProto_entries%": ["Array", "prototype", "entries"],
+      "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
+      "%ArrayProto_keys%": ["Array", "prototype", "keys"],
+      "%ArrayProto_values%": ["Array", "prototype", "values"],
+      "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
+      "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
+      "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
+      "%BooleanPrototype%": ["Boolean", "prototype"],
+      "%DataViewPrototype%": ["DataView", "prototype"],
+      "%DatePrototype%": ["Date", "prototype"],
+      "%ErrorPrototype%": ["Error", "prototype"],
+      "%EvalErrorPrototype%": ["EvalError", "prototype"],
+      "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
+      "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
+      "%FunctionPrototype%": ["Function", "prototype"],
+      "%Generator%": ["GeneratorFunction", "prototype"],
+      "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
+      "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
+      "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
+      "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
+      "%JSONParse%": ["JSON", "parse"],
+      "%JSONStringify%": ["JSON", "stringify"],
+      "%MapPrototype%": ["Map", "prototype"],
+      "%NumberPrototype%": ["Number", "prototype"],
+      "%ObjectPrototype%": ["Object", "prototype"],
+      "%ObjProto_toString%": ["Object", "prototype", "toString"],
+      "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
+      "%PromisePrototype%": ["Promise", "prototype"],
+      "%PromiseProto_then%": ["Promise", "prototype", "then"],
+      "%Promise_all%": ["Promise", "all"],
+      "%Promise_reject%": ["Promise", "reject"],
+      "%Promise_resolve%": ["Promise", "resolve"],
+      "%RangeErrorPrototype%": ["RangeError", "prototype"],
+      "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
+      "%RegExpPrototype%": ["RegExp", "prototype"],
+      "%SetPrototype%": ["Set", "prototype"],
+      "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
+      "%StringPrototype%": ["String", "prototype"],
+      "%SymbolPrototype%": ["Symbol", "prototype"],
+      "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
+      "%TypedArrayPrototype%": ["TypedArray", "prototype"],
+      "%TypeErrorPrototype%": ["TypeError", "prototype"],
+      "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
+      "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
+      "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
+      "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
+      "%URIErrorPrototype%": ["URIError", "prototype"],
+      "%WeakMapPrototype%": ["WeakMap", "prototype"],
+      "%WeakSetPrototype%": ["WeakSet", "prototype"]
+    };
+    var bind = require_function_bind();
+    var hasOwn = require_hasown();
+    var $concat = bind.call($call, Array.prototype.concat);
+    var $spliceApply = bind.call($apply, Array.prototype.splice);
+    var $replace = bind.call($call, String.prototype.replace);
+    var $strSlice = bind.call($call, String.prototype.slice);
+    var $exec = bind.call($call, RegExp.prototype.exec);
+    var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+    var reEscapeChar = /\\(\\)?/g;
+    var stringToPath = function stringToPath2(string) {
+      var first = $strSlice(string, 0, 1);
+      var last = $strSlice(string, -1);
+      if (first === "%" && last !== "%") {
+        throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
+      } else if (last === "%" && first !== "%") {
+        throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
+      }
+      var result = [];
+      $replace(string, rePropName, function(match, number, quote, subString) {
+        result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
+      });
+      return result;
+    };
+    var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {
+      var intrinsicName = name;
+      var alias;
+      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+        alias = LEGACY_ALIASES[intrinsicName];
+        intrinsicName = "%" + alias[0] + "%";
+      }
+      if (hasOwn(INTRINSICS, intrinsicName)) {
+        var value = INTRINSICS[intrinsicName];
+        if (value === needsEval) {
+          value = doEval(intrinsicName);
+        }
+        if (typeof value === "undefined" && !allowMissing) {
+          throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
+        }
+        return {
+          alias,
+          name: intrinsicName,
+          value
+        };
+      }
+      throw new $SyntaxError("intrinsic " + name + " does not exist!");
+    };
+    module.exports = function GetIntrinsic(name, allowMissing) {
+      if (typeof name !== "string" || name.length === 0) {
+        throw new $TypeError("intrinsic name must be a non-empty string");
+      }
+      if (arguments.length > 1 && typeof allowMissing !== "boolean") {
+        throw new $TypeError('"allowMissing" argument must be a boolean');
+      }
+      if ($exec(/^%?[^%]*%?$/, name) === null) {
+        throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+      }
+      var parts = stringToPath(name);
+      var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
+      var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
+      var intrinsicRealName = intrinsic.name;
+      var value = intrinsic.value;
+      var skipFurtherCaching = false;
+      var alias = intrinsic.alias;
+      if (alias) {
+        intrinsicBaseName = alias[0];
+        $spliceApply(parts, $concat([0, 1], alias));
+      }
+      for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+        var part = parts[i];
+        var first = $strSlice(part, 0, 1);
+        var last = $strSlice(part, -1);
+        if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
+          throw new $SyntaxError("property names with quotes must have matching quotes");
+        }
+        if (part === "constructor" || !isOwn) {
+          skipFurtherCaching = true;
+        }
+        intrinsicBaseName += "." + part;
+        intrinsicRealName = "%" + intrinsicBaseName + "%";
+        if (hasOwn(INTRINSICS, intrinsicRealName)) {
+          value = INTRINSICS[intrinsicRealName];
+        } else if (value != null) {
+          if (!(part in value)) {
+            if (!allowMissing) {
+              throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
+            }
+            return void undefined2;
+          }
+          if ($gOPD && i + 1 >= parts.length) {
+            var desc = $gOPD(value, part);
+            isOwn = !!desc;
+            if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
+              value = desc.get;
+            } else {
+              value = value[part];
+            }
+          } else {
+            isOwn = hasOwn(value, part);
+            value = value[part];
+          }
+          if (isOwn && !skipFurtherCaching) {
+            INTRINSICS[intrinsicRealName] = value;
+          }
+        }
+      }
+      return value;
+    };
+  }
+});
+
+// node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js
+var require_define_data_property = __commonJS({
+  "node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js"(exports$1, module) {
+    var $defineProperty = require_es_define_property();
+    var $SyntaxError = require_syntax();
+    var $TypeError = require_type();
+    var gopd = require_gopd();
+    module.exports = function defineDataProperty(obj, property, value) {
+      if (!obj || typeof obj !== "object" && typeof obj !== "function") {
+        throw new $TypeError("`obj` must be an object or a function`");
+      }
+      if (typeof property !== "string" && typeof property !== "symbol") {
+        throw new $TypeError("`property` must be a string or a symbol`");
+      }
+      if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) {
+        throw new $TypeError("`nonEnumerable`, if provided, must be a boolean or null");
+      }
+      if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) {
+        throw new $TypeError("`nonWritable`, if provided, must be a boolean or null");
+      }
+      if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) {
+        throw new $TypeError("`nonConfigurable`, if provided, must be a boolean or null");
+      }
+      if (arguments.length > 6 && typeof arguments[6] !== "boolean") {
+        throw new $TypeError("`loose`, if provided, must be a boolean");
+      }
+      var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
+      var nonWritable = arguments.length > 4 ? arguments[4] : null;
+      var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
+      var loose = arguments.length > 6 ? arguments[6] : false;
+      var desc = !!gopd && gopd(obj, property);
+      if ($defineProperty) {
+        $defineProperty(obj, property, {
+          configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
+          enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
+          value,
+          writable: nonWritable === null && desc ? desc.writable : !nonWritable
+        });
+      } else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) {
+        obj[property] = value;
+      } else {
+        throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js
+var require_has_property_descriptors = __commonJS({
+  "node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js"(exports$1, module) {
+    var $defineProperty = require_es_define_property();
+    var hasPropertyDescriptors = function hasPropertyDescriptors2() {
+      return !!$defineProperty;
+    };
+    hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
+      if (!$defineProperty) {
+        return null;
+      }
+      try {
+        return $defineProperty([], "length", { value: 1 }).length !== 1;
+      } catch (e) {
+        return true;
+      }
+    };
+    module.exports = hasPropertyDescriptors;
+  }
+});
+
+// node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js
+var require_set_function_length = __commonJS({
+  "node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js"(exports$1, module) {
+    var GetIntrinsic = require_get_intrinsic();
+    var define = require_define_data_property();
+    var hasDescriptors = require_has_property_descriptors()();
+    var gOPD = require_gopd();
+    var $TypeError = require_type();
+    var $floor = GetIntrinsic("%Math.floor%");
+    module.exports = function setFunctionLength(fn, length) {
+      if (typeof fn !== "function") {
+        throw new $TypeError("`fn` is not a function");
+      }
+      if (typeof length !== "number" || length < 0 || length > 4294967295 || $floor(length) !== length) {
+        throw new $TypeError("`length` must be a positive 32-bit integer");
+      }
+      var loose = arguments.length > 2 && !!arguments[2];
+      var functionLengthIsConfigurable = true;
+      var functionLengthIsWritable = true;
+      if ("length" in fn && gOPD) {
+        var desc = gOPD(fn, "length");
+        if (desc && !desc.configurable) {
+          functionLengthIsConfigurable = false;
+        }
+        if (desc && !desc.writable) {
+          functionLengthIsWritable = false;
+        }
+      }
+      if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
+        if (hasDescriptors) {
+          define(
+            /** @type {Parameters<define>[0]} */
+            fn,
+            "length",
+            length,
+            true,
+            true
+          );
+        } else {
+          define(
+            /** @type {Parameters<define>[0]} */
+            fn,
+            "length",
+            length
+          );
+        }
+      }
+      return fn;
+    };
+  }
+});
+
+// node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js
+var require_applyBind = __commonJS({
+  "node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js"(exports$1, module) {
+    var bind = require_function_bind();
+    var $apply = require_functionApply();
+    var actualApply = require_actualApply();
+    module.exports = function applyBind() {
+      return actualApply(bind, $apply, arguments);
+    };
+  }
+});
+
+// node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js
+var require_call_bind = __commonJS({
+  "node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/index.js"(exports$1, module) {
+    var setFunctionLength = require_set_function_length();
+    var $defineProperty = require_es_define_property();
+    var callBindBasic = require_call_bind_apply_helpers();
+    var applyBind = require_applyBind();
+    module.exports = function callBind(originalFunction) {
+      var func = callBindBasic(arguments);
+      var adjustedLength = originalFunction.length - (arguments.length - 1);
+      return setFunctionLength(
+        func,
+        1 + (adjustedLength > 0 ? adjustedLength : 0),
+        true
+      );
+    };
+    if ($defineProperty) {
+      $defineProperty(module.exports, "apply", { value: applyBind });
+    } else {
+      module.exports.apply = applyBind;
+    }
+  }
+});
+
+// node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js
+var require_call_bound = __commonJS({
+  "node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js"(exports$1, module) {
+    var GetIntrinsic = require_get_intrinsic();
+    var callBindBasic = require_call_bind_apply_helpers();
+    var $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
+    module.exports = function callBoundIntrinsic(name, allowMissing) {
+      var intrinsic = (
+        /** @type {(this: unknown, ...args: unknown[]) => unknown} */
+        GetIntrinsic(name, !!allowMissing)
+      );
+      if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
+        return callBindBasic(
+          /** @type {const} */
+          [intrinsic]
+        );
+      }
+      return intrinsic;
+    };
+  }
+});
+
+// node_modules/.pnpm/json-stable-stringify@1.3.0/node_modules/json-stable-stringify/index.js
+var require_json_stable_stringify = __commonJS({
+  "node_modules/.pnpm/json-stable-stringify@1.3.0/node_modules/json-stable-stringify/index.js"(exports$1, module) {
+    var jsonStringify = (typeof JSON !== "undefined" ? JSON : require_jsonify()).stringify;
+    var isArray = require_isarray();
+    var objectKeys = require_object_keys();
+    var callBind = require_call_bind();
+    var callBound = require_call_bound();
+    var $join = callBound("Array.prototype.join");
+    var $indexOf = callBound("Array.prototype.indexOf");
+    var $splice = callBound("Array.prototype.splice");
+    var $sort = callBound("Array.prototype.sort");
+    var strRepeat = function repeat(n, char) {
+      var str = "";
+      for (var i = 0; i < n; i += 1) {
+        str += char;
+      }
+      return str;
+    };
+    var defaultReplacer = function(_parent, _key, value) {
+      return value;
+    };
+    module.exports = function stableStringify(obj) {
+      var opts = arguments.length > 1 ? arguments[1] : void 0;
+      var space = opts && opts.space || "";
+      if (typeof space === "number") {
+        space = strRepeat(space, " ");
+      }
+      var cycles = !!opts && typeof opts.cycles === "boolean" && opts.cycles;
+      var replacer = opts && opts.replacer ? callBind(opts.replacer) : defaultReplacer;
+      if (opts && typeof opts.collapseEmpty !== "undefined" && typeof opts.collapseEmpty !== "boolean") {
+        throw new TypeError("`collapseEmpty` must be a boolean, if provided");
+      }
+      var collapseEmpty = !!opts && opts.collapseEmpty;
+      var cmpOpt = typeof opts === "function" ? opts : opts && opts.cmp;
+      var cmp = cmpOpt && function(node) {
+        var get = (
+          /** @type {NonNullable<typeof cmpOpt>} */
+          cmpOpt.length > 2 && /** @type {import('.').Getter['get']} */
+          function get2(k) {
+            return node[k];
+          }
+        );
+        return function(a, b) {
+          return (
+            /** @type {NonNullable<typeof cmpOpt>} */
+            cmpOpt(
+              { key: a, value: node[a] },
+              { key: b, value: node[b] },
+              // @ts-expect-error TS doesn't understand the optimization used here
+              get ? (
+                /** @type {import('.').Getter} */
+                { __proto__: null, get }
+              ) : void 0
+            )
+          );
+        };
+      };
+      var seen = [];
+      return (
+        /** @type {(parent: import('.').Node, key: string | number, node: unknown, level: number) => string | undefined} */
+        (function stringify2(parent, key, node, level) {
+          var indent = space ? "\n" + strRepeat(level, space) : "";
+          var colonSeparator = space ? ": " : ":";
+          if (node && /** @type {{ toJSON?: unknown }} */
+          node.toJSON && typeof /** @type {{ toJSON?: unknown }} */
+          node.toJSON === "function") {
+            node = /** @type {{ toJSON: Function }} */
+            node.toJSON();
+          }
+          node = replacer(parent, key, node);
+          if (node === void 0) {
+            return;
+          }
+          if (typeof node !== "object" || node === null) {
+            return jsonStringify(node);
+          }
+          var groupOutput = function(out2, brackets) {
+            return collapseEmpty && out2.length === 0 ? brackets : (brackets === "[]" ? "[" : "{") + $join(out2, ",") + indent + (brackets === "[]" ? "]" : "}");
+          };
+          if (isArray(node)) {
+            var out = [];
+            for (var i = 0; i < node.length; i++) {
+              var item = stringify2(node, i, node[i], level + 1) || jsonStringify(null);
+              out[out.length] = indent + space + item;
+            }
+            return groupOutput(out, "[]");
+          }
+          if ($indexOf(seen, node) !== -1) {
+            if (cycles) {
+              return jsonStringify("__cycle__");
+            }
+            throw new TypeError("Converting circular structure to JSON");
+          } else {
+            seen[seen.length] = /** @type {import('.').NonArrayNode} */
+            node;
+          }
+          var keys = $sort(objectKeys(node), cmp && cmp(
+            /** @type {import('.').NonArrayNode} */
+            node
+          ));
+          var out = [];
+          for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            var value = stringify2(
+              /** @type {import('.').Node} */
+              node,
+              key,
+              /** @type {import('.').NonArrayNode} */
+              node[key],
+              level + 1
+            );
+            if (!value) {
+              continue;
+            }
+            var keyValue = jsonStringify(key) + colonSeparator + value;
+            out[out.length] = indent + space + keyValue;
+          }
+          $splice(seen, $indexOf(seen, node), 1);
+          return groupOutput(out, "{}");
+        })({ "": obj }, "", obj, 0)
+      );
+    };
+  }
+});
+
+// src/util/encode.ts
+var import_json_stable_stringify = __toESM(require_json_stable_stringify(), 1);
+
+// src/util/flags.ts
+var isFlagEnabled = (identifier) => {
+  const flag = localStorage.getItem(`kizen-flag-${identifier}`);
+  return flag === "true";
+};
+
+// src/util/encode.ts
+var getHash = (str = "") => {
+  return str.split("").reduce((prevHash, currVal) => (prevHash << 5) - prevHash + currVal.charCodeAt(0) | 0, 0);
+};
+var getStableHash = (obj) => {
+  try {
+    return getHash((0, import_json_stable_stringify.default)(obj));
+  } catch (ex) {
+    const isDebug = isFlagEnabled("script-runner-logging");
+    if (isDebug) {
+      console.warn("Failed to stringify object for hashing:", ex);
+    }
+    return getHash(String(Math.random()));
+  }
+};
+var isRelative = (url) => {
+  return url.startsWith("/");
+};
+var allowedAllowValues = [
+  "microphone",
+  "speaker-selection",
+  "autoplay",
+  "camera",
+  "display-capture",
+  "hid"
+];
+var allowedSandboxValues = ["allow-popups", "allow-scripts", "allow-same-origin"];
+var refreshTimeout = 3e4;
+var refreshInterval = 100;
+var WorkerManager = class {
+  worker;
+  scriptUIRef;
+  onStateChange;
+  done;
+  onError;
+  waitForFrame = false;
+  plugin;
+  executionPlugin;
+  frameId;
+  onShowToast;
+  onClearToasts;
+  sessionData = {};
+  setSessionData;
+  pluginComponentId;
+  onShowModal;
+  onShowCreateRecordModal;
+  onShowCreateRelatedRecordModal;
+  onReleaseBlockingScript;
+  pluginApiName;
+  onNetworkError;
+  onNetworkRequest;
+  invalidateCache;
+  // todo
+  getPendingCacheCount;
+  // todo
+  createFileId;
+  performFileUpload;
+  pushHistory;
+  appPath;
+  constructor(args) {
+    this.scriptUIRef = args.scriptUIRef;
+    this.onStateChange = args.onStateChange;
+    this.done = args.done;
+    this.onError = args.onError;
+    this.onReleaseBlockingScript = args.onReleaseBlockingScript;
+    this.worker = args.worker;
+    this.worker.onmessage = this.handleMessage;
+    this.plugin = args.plugin;
+    this.executionPlugin = args.executionPlugin;
+    this.onShowToast = args.onShowToast;
+    this.onClearToasts = args.onClearToasts;
+    this.pluginComponentId = args.pluginComponentId;
+    this.onShowModal = args.onShowModal;
+    this.onShowCreateRecordModal = args.onShowCreateRecordModal;
+    this.onShowCreateRelatedRecordModal = args.onShowCreateRelatedRecordModal;
+    this.onNetworkError = args.onNetworkError;
+    this.onNetworkRequest = args.onNetworkRequest;
+    this.invalidateCache = args.invalidateCache;
+    this.getPendingCacheCount = args.getPendingCacheCount;
+    this.createFileId = args.createFileId;
+    this.performFileUpload = args.performFileUpload;
+    this.pushHistory = args.pushHistory;
+    this.appPath = args.appPath;
+    if (this.plugin) {
+      this.frameId = `${IFRAME_PREFIX}-${this.plugin.plugin_api_name}-${this.plugin.api_name}`;
+    }
+    this.pluginApiName = this.executionPlugin?.plugin_api_name ?? this.plugin?.plugin_api_name ?? "";
+    if (this.pluginApiName) {
+      this.sessionData = args.sessionData[this.pluginApiName];
+      this.setSessionData = (state) => {
+        args.setSessionData?.(this.pluginApiName, state);
+      };
+    } else {
+      this.setSessionData = () => {
+        this.onError?.({
+          message: "Script must be associated with a plugin to use session data"
+        });
+      };
+    }
+  }
+  handleMessage = async (rawEvent) => {
+    const event = JSON.parse(rawEvent.data);
+    const { action } = event;
+    switch (action) {
+      case ACTIONS.QUERY_REQUEST: {
+        const consideredEvent = event;
+        await this.handleQueryRequest(
+          consideredEvent.id,
+          consideredEvent.method,
+          consideredEvent.url,
+          consideredEvent.payload,
+          consideredEvent.options
+        );
+        return;
+      }
+      case ACTIONS.UI_OUTPUT: {
+        const consideredEvent = event;
+        this.handleUIOutput(consideredEvent.markup);
+        return;
+      }
+      case ACTIONS.IFRAME_OUTPUT: {
+        const consideredEvent = event;
+        this.handleIframeOutput(
+          consideredEvent.url,
+          consideredEvent.allow,
+          consideredEvent.sandbox,
+          consideredEvent.preserve
+        );
+        return;
+      }
+      case ACTIONS.POSTFORMDATA_REQUEST: {
+        const consideredEvent = event;
+        this.handleFormPostRequest(
+          consideredEvent.id,
+          consideredEvent.url,
+          consideredEvent.payload,
+          consideredEvent.createNewTab
+        );
+        return;
+      }
+      case ACTIONS.UPLOADFILE_REQUEST: {
+        const consideredEvent = event;
+        await this.handleUploadFileRequest(consideredEvent.id, consideredEvent.payload);
+        return;
+      }
+      case ACTIONS.SETSTATE: {
+        const consideredEvent = event;
+        this.onStateChange?.(consideredEvent.state);
+        return;
+      }
+      case ACTIONS.DONE: {
+        const consideredEvent = event;
+        this.handleDone(consideredEvent.preserve, consideredEvent.result);
+        return;
+      }
+      case RESPONSES.ERROR: {
+        const consideredEvent = event;
+        this.onError?.({ message: consideredEvent.error });
+        return;
+      }
+      case ACTIONS.OPEN_WINDOW: {
+        const consideredEvent = event;
+        this.handleOpenWindow(
+          consideredEvent.url,
+          consideredEvent.target,
+          consideredEvent.features
+        );
+        return;
+      }
+      case ACTIONS.COMMUNICATE: {
+        const consideredEvent = event;
+        this.handleCommunication(
+          consideredEvent.type,
+          consideredEvent.recipient,
+          consideredEvent.args,
+          consideredEvent.params
+        );
+        return;
+      }
+      case ACTIONS.HIDE: {
+        const consideredEvent = event;
+        const { config } = consideredEvent;
+        let triggerHidden = false;
+        if (config.hideTrigger) {
+          triggerHidden = true;
+        }
+        this.onStateChange?.({ hidden: true, triggerHidden });
+        return;
+      }
+      case ACTIONS.SHOW: {
+        const consideredEvent = event;
+        const { config } = consideredEvent;
+        let triggerHidden = false;
+        if (config.showTrigger === false) {
+          triggerHidden = true;
+        }
+        this.onStateChange?.({ hidden: false, triggerHidden });
+        return;
+      }
+      case ACTIONS.EXPAND: {
+        this.onStateChange?.({ minimized: false });
+        return;
+      }
+      case ACTIONS.COLLAPSE: {
+        this.onStateChange?.({ minimized: true });
+        return;
+      }
+      case ACTIONS.HIDE_HEADER: {
+        this.onStateChange?.({ hideHeader: true });
+        return;
+      }
+      case ACTIONS.SHOW_HEADER: {
+        this.onStateChange?.({ hideHeader: false });
+        return;
+      }
+      case ACTIONS.COPY_TO_CLIPBOARD: {
+        const consideredEvent = event;
+        await this.copyToClipboard(consideredEvent.text);
+        return;
+      }
+      case ACTIONS.OPEN_CREATE_RECORD_MODAL_REQUEST: {
+        const consideredEvent = event;
+        this.handleCreateRecordRequest(consideredEvent.id, consideredEvent.entityId);
+        return;
+      }
+      case ACTIONS.OPEN_CREATE_RELATED_RECORD_MODAL_REQUEST: {
+        const consideredEvent = event;
+        this.handleCreateRelatedRecordRequest(
+          consideredEvent.id,
+          consideredEvent.objectId,
+          consideredEvent.relatedEntityId
+        );
+        return;
+      }
+      case ACTIONS.SHOW_TOAST: {
+        const consideredEvent = event;
+        this.showToast(consideredEvent.message, consideredEvent.toastOptions);
+        return;
+      }
+      case ACTIONS.CLEAR_TOASTS: {
+        this.clearToasts();
+        return;
+      }
+      case ACTIONS.REFRESH_TIMELINE: {
+        const consideredEvent = event;
+        this.handleRefreshTimeline(consideredEvent.entityId);
+        return;
+      }
+      case ACTIONS.REFRESH_ENTITY: {
+        const consideredEvent = event;
+        await this.handleRefreshEntity(consideredEvent.entityId, consideredEvent.id);
+        return;
+      }
+      case ACTIONS.UPDATE_SESSION_DATA: {
+        const consideredEvent = event;
+        this.handleSetSessionData(consideredEvent.update);
+        return;
+      }
+      case ACTIONS.INSTALL_THIRD_PARTY_SCRIPT_REQUEST: {
+        const consideredEvent = event;
+        this.handleInstallThirdPartyScriptRequest(
+          consideredEvent.id,
+          consideredEvent.url,
+          consideredEvent.args
+        );
+        return;
+      }
+      case ACTIONS.PROMPT_REQUEST: {
+        const consideredEvent = event;
+        this.handlePromptRequest(consideredEvent.id, consideredEvent.config, false);
+        return;
+      }
+      case ACTIONS.DYNAMIC_PROMPT_REQUEST: {
+        const consideredEvent = event;
+        this.handlePromptRequest(consideredEvent.id, consideredEvent.config, true);
+        return;
+      }
+      case ACTIONS.RELEASE_BLOCKING_SCRIPT: {
+        this.handleReleaseBlockingScript();
+        return;
+      }
+      case ACTIONS.AUTHORIZE: {
+        const consideredEvent = event;
+        this.handleAuthorize(consideredEvent.serviceName, consideredEvent.config);
+        return;
+      }
+      default:
+        return;
+    }
+  };
+  handleCommunication = (type, recipient, args, params) => {
+    if (type === COMMUNICATIONS.SEND_MESSAGE_TO_FRAME) {
+      if (this.frameId) {
+        const target = document.getElementById(this.frameId);
+        if (target) {
+          target.contentWindow?.postMessage(
+            {
+              ...args?.payload ?? {},
+              __kizen: {
+                recipient,
+                frameId: this.frameId
+              }
+            },
+            args?.path ?? "*"
+          );
+        }
+      }
+    } else if (type === COMMUNICATIONS.CALL_THIRD_PARTY_SCRIPT) {
+      this.handleCallThirdPartyScript(recipient.type, params);
+    } else {
+      const pluginApiName = this.executionPlugin?.plugin_api_name ?? this.plugin?.plugin_api_name;
+      const event = new CustomEvent(`integration:${type}`, {
+        detail: {
+          recipient: {
+            ...recipient,
+            plugin: pluginApiName
+          },
+          args
+        }
+      });
+      window.dispatchEvent(event);
+    }
+  };
+  handleDone = (preserve, result) => {
+    if (!this.waitForFrame) {
+      this.done(preserve, result);
+    }
+  };
+  postMessage = (action, data) => {
+    this.worker.postMessage(
+      JSON.stringify({
+        action,
+        ...data
+      })
+    );
+  };
+  handleSetSessionData = (state) => {
+    this.setSessionData(state);
+  };
+  handleQueryRequest = async (id, method, url, payload, options) => {
+    try {
+      const data = await this.onNetworkRequest?.(method, url, payload, options);
+      this.postMessage(RESPONSES.QUERY_RESPONSE, { data, id });
+    } catch (ex) {
+      this.onNetworkError?.(ex);
+      this.postMessage(RESPONSES.QUERY_RESPONSE, { error: ex, id });
+    }
+  };
+  handleUIOutput = (markup) => {
+    if (this.scriptUIRef?.current) {
+      const sanitizedMarkup = DOMPurify.sanitize(markup);
+      this.scriptUIRef.current.innerHTML = sanitizedMarkup;
+    }
+  };
+  onLoad = (payload) => {
+    if (payload.iframe) {
+      this.waitForFrame = false;
+      this.handleDone(payload.preserve);
+    }
+  };
+  handleIframeOutput = (url, allow = [], sandbox = [], preserve = false) => {
+    if (this.scriptUIRef?.current) {
+      const parsedAllowList = allow.filter((a) => allowedAllowValues.includes(a));
+      const parsedSandboxList = sandbox.filter((s) => allowedSandboxValues.includes(s));
+      this.waitForFrame = true;
+      const element = document.createElement("iframe");
+      element.src = url;
+      element.allow = parsedAllowList.join("; ");
+      parsedSandboxList.forEach((s) => {
+        element.sandbox.add(s);
+      });
+      element.style.border = "none";
+      element.style.width = "100%";
+      element.style.height = "100%";
+      element.onload = this.onLoad.bind(this, { iframe: element, preserve });
+      if (this.frameId) {
+        element.id = this.frameId;
+      }
+      this.scriptUIRef.current.replaceChildren(element);
+    }
+  };
+  handleCreateRecordRequest = (promiseId, objectId) => {
+    this.onShowCreateRecordModal?.(objectId, (result) => {
+      this.postMessage(RESPONSES.CREATE_RECORD_RESPONSE, {
+        id: promiseId,
+        data: result
+      });
+    });
+  };
+  handleCreateRelatedRecordRequest = (promiseId, objectId, relatedEntityId) => {
+    this.onShowCreateRelatedRecordModal?.(objectId, relatedEntityId, (result) => {
+      this.postMessage(RESPONSES.CREATE_RELATED_RECORD_RESPONSE, {
+        id: promiseId,
+        data: result
+      });
+    });
+  };
+  showToast = (message, options) => {
+    this.onShowToast?.({
+      message,
+      variant: options?.variant ?? "success",
+      autohide: options?.autohide ?? true
+    });
+  };
+  clearToasts = () => {
+    this.onClearToasts?.();
+  };
+  copyToClipboard = async (text) => {
+    try {
+      await navigator.clipboard.writeText(text);
+    } catch (err) {
+      this.onError?.({
+        message: err.message
+      });
+    }
+  };
+  handleRefreshTimeline = (entityId) => {
+    this.invalidateCache?.("timeline", entityId);
+  };
+  // When we refresh a set of react-query keys, we need to wait for the queries to settle and finish refetching
+  waitForIdleState = (search) => {
+    return new Promise((resolve) => {
+      let count = 0;
+      const interval = setInterval(() => {
+        const fetchCount = this.getPendingCacheCount?.(search) ?? 0;
+        if (fetchCount === 0) {
+          clearInterval(interval);
+          resolve(true);
+        } else {
+          count += 1;
+          if (count > Math.floor(refreshTimeout / refreshInterval)) {
+            clearInterval(interval);
+            resolve(false);
+          }
+        }
+      }, refreshInterval);
+    });
+  };
+  handleRefreshEntity = async (entityId, promiseId) => {
+    this.invalidateCache?.("entity", entityId);
+    const result = await this.waitForIdleState(entityId);
+    this.postMessage(RESPONSES.REFRESH_ENTITY_RESPONSE, {
+      id: promiseId,
+      data: {
+        success: result
+      }
+    });
+  };
+  handleFormPostRequest = (id, url, payload, createNewTab) => {
+    const form = document.createElement("form");
+    form.method = "POST";
+    form.action = url;
+    if (createNewTab) {
+      form.target = "_blank";
+    }
+    for (const key in payload) {
+      const field = document.createElement("input");
+      field.type = "hidden";
+      field.name = key;
+      field.value = payload[key];
+      form.appendChild(field);
+    }
+    document.body.appendChild(form);
+    form.submit();
+    if (createNewTab) {
+      document.body.removeChild(form);
+    }
+    this.postMessage(RESPONSES.POSTFORMDATA_RESPONSE, { success: true, id });
+  };
+  handleUploadFileRequest = async (id, payload) => {
+    if (!this.performFileUpload) {
+      this.postMessage(RESPONSES.UPLOADFILE_RESPONSE, { error: "File upload not supported", id });
+      return;
+    }
+    const { file: encodedFile, isPublic = false, fileName } = payload;
+    const decodedFile = await fetch(encodedFile);
+    const fileBlob = await decodedFile.blob();
+    const file = new File([fileBlob], fileName ?? `upload-${(/* @__PURE__ */ new Date()).toISOString()}`, {
+      type: fileBlob.type
+    });
+    file.$id = this.createFileId?.() ?? generateUUIDV4();
+    const result = await this.performFileUpload({
+      file,
+      id: file.$id,
+      publicFile: isPublic,
+      source: "field_value",
+      handleProgress: (p) => {
+        this.postMessage(RESPONSES.UPLOADFILE_PROGRESS, {
+          fileId: p.id,
+          progress: p.progress
+        });
+      },
+      businessId: void 0
+    });
+    this.postMessage(RESPONSES.UPLOADFILE_RESPONSE, { data: result, id });
+  };
+  waitForReadyState = (predicate, cb, iterations = 0) => {
+    if (!predicate) {
+      cb?.(true);
+    }
+    if (predicate?.()) {
+      cb?.(true);
+    } else if (iterations < 20) {
+      setTimeout(() => {
+        this.waitForReadyState(predicate, cb, iterations + 1);
+      }, iterations * 50);
+    } else {
+      cb?.(false);
+    }
+  };
+  handleCallThirdPartyScript = (scriptType, args = []) => {
+    if (scriptType && thirdPartyGlobalNames[scriptType]) {
+      const globalName = thirdPartyGlobalNames[scriptType];
+      const fn = window[globalName];
+      fn?.(...args);
+    }
+  };
+  handleReleaseBlockingScript = () => {
+    return this.onReleaseBlockingScript?.(this.executionPlugin);
+  };
+  handlePromptRequest = (id, config, dynamic = false) => {
+    if (this.onShowModal) {
+      this.onShowModal(
+        {
+          ...config,
+          pluginApiName: this.pluginApiName ?? "",
+          dynamic
+        },
+        (result = {}) => {
+          this.postMessage(RESPONSES.PROMPT_RESPONSE, {
+            id,
+            data: result
+          });
+        }
+      );
+    } else {
+      this.postMessage(RESPONSES.PROMPT_RESPONSE, {
+        id,
+        data: { canceled: true }
+      });
+    }
+  };
+  handleInstallThirdPartyScriptRequest = (id, url, args = {}) => {
+    const type = getScriptIntegrationType(url);
+    if (!type) {
+      this.postMessage(RESPONSES.INSTALL_THIRD_PARTY_SCRIPT_RESPONSE, {
+        data: { success: false, url },
+        id
+      });
+      return;
+    }
+    const setupFn = thirdPartySetupScripts[type];
+    setupFn(args);
+    const script = document.createElement("script");
+    script.onload = () => {
+      this.waitForReadyState(thirdPartyReadyPredicates[type], (matched) => {
+        this.postMessage(RESPONSES.INSTALL_THIRD_PARTY_SCRIPT_RESPONSE, {
+          data: { success: true, url, matched },
+          id
+        });
+      });
+    };
+    script.onerror = () => {
+      this.postMessage(RESPONSES.INSTALL_THIRD_PARTY_SCRIPT_RESPONSE, {
+        data: { success: false, url },
+        id
+      });
+    };
+    script.src = url;
+    script.setAttribute("data-script-url", url);
+    const exists = document.querySelectorAll('[data-script-url="' + url + '"]').length > 0;
+    if (!exists) {
+      document.documentElement.firstChild?.appendChild(script);
+    } else {
+      this.waitForReadyState(thirdPartyReadyPredicates[type], (matched) => {
+        this.postMessage(RESPONSES.INSTALL_THIRD_PARTY_SCRIPT_RESPONSE, {
+          data: { success: true, url, reused: true, matched },
+          id
+        });
+      });
+    }
+  };
+  handleOpenWindow = (url, target, features) => {
+    if (!isRelative(url) || target === "_blank" || !this.pushHistory) {
+      window.open(url, target, features);
+    } else {
+      this.pushHistory(url);
+    }
+  };
+  handleAuthorize = (serviceName, config = {}) => {
+    const params = new URLSearchParams();
+    if (config.successRedirectPath) {
+      params.append("success_redirect_path", config.successRedirectPath);
+    }
+    if (config.errorRedirectPath) {
+      params.append("error_redirect_path", config.errorRedirectPath);
+    }
+    if (!this.appPath) {
+      this.onError?.({
+        message: "App path is not defined."
+      });
+      return;
+    }
+    if (!this.pluginApiName) {
+      this.onError?.({
+        message: "Plugin API name is not defined."
+      });
+      return;
+    }
+    const paramString = params.toString();
+    this.handleOpenWindow(
+      `${this.appPath}/external-integrations/business-plugin-apps/${this.pluginApiName}/services/${encodeURIComponent(
+        serviceName
+      )}/authorize${paramString ? `?${paramString}` : ""}`,
+      "_blank",
+      ""
+    );
+  };
+  run = (scriptBody, setup, args) => {
+    const location = getPartialLocation();
+    this.postMessage(ACTIONS.RUN, {
+      script: scriptBody,
+      setup,
+      args,
+      sessionData: this.sessionData,
+      pluginComponentId: this.pluginComponentId,
+      pluginApiName: this.pluginApiName,
+      location
+    });
+  };
+};
+
+// src/run.ts
+var runScript = async ({
+  scriptBody,
+  user,
+  teamMember,
+  business,
+  onError,
+  onReleaseBlockingScript,
+  setLoadingState,
+  clientObject,
+  scriptUIRef,
+  onStateChange,
+  workerName,
+  context,
+  args = "",
+  plugin,
+  onShowToast,
+  onClearToasts,
+  terminators,
+  executionPlugin,
+  sessionData,
+  setSessionData,
+  onShowModal,
+  onShowCreateRecordModal,
+  onShowCreateRelatedRecordModal,
+  onNetworkError,
+  onNetworkRequest,
+  appPath,
+  pushHistory,
+  createFileId,
+  performFileUpload,
+  getPendingCacheCount,
+  invalidateCache
+}) => {
+  const isDebug = isFlagEnabled("script-runner-logging");
+  let worker;
+  if (workerName === "recordDetail") {
+    worker = new Worker(new URL("./workers/recordDetail.worker.js", import.meta.url), {
+      type: "module"
+    });
+  } else if (workerName === "genericPlugin") {
+    worker = new Worker(new URL("./workers/generic.worker.js", import.meta.url), {
+      type: "module"
+    });
+  } else if (workerName === "floatingFramePlugin") {
+    worker = new Worker(new URL("./workers/floatingFrame.worker.js", import.meta.url), {
+      type: "module"
+    });
+  } else {
+    worker = new Worker(new URL("./workers/calendarSource.worker.js", import.meta.url), {
+      type: "module"
+    });
+  }
+  return new Promise((resolve) => {
+    const hashedScript = getHash(scriptBody);
+    const hashedArgs = getHash(args);
+    let workerId = `${plugin?.plugin_api_name ?? ""}-${plugin?.api_name ?? ""}-${String(hashedScript)}-${String(hashedArgs)}`;
+    let componentId = `${plugin?.plugin_api_name ?? ""}-${plugin?.api_name ?? ""}`;
+    if (executionPlugin?.field_type) {
+      workerId = `${executionPlugin.plugin_api_name ?? ""}-${executionPlugin.field_type}-${String(hashedScript)}-${String(hashedArgs)}`;
+      componentId = `${executionPlugin.plugin_api_name ?? ""}-${executionPlugin.field_type ?? executionPlugin.script_id}`;
+    } else if (executionPlugin) {
+      workerId = `${executionPlugin.plugin_api_name ?? ""}-${executionPlugin.api_name}-${String(hashedScript)}-${String(hashedArgs)}`;
+      componentId = `${executionPlugin.plugin_api_name ?? ""}-${executionPlugin.api_name}`;
+    }
+    if (terminators.current[workerId]) {
+      terminators.current[workerId]?.forEach((fn) => {
+        fn();
+      });
+      terminators.current[workerId] = [];
+    }
+    terminators.current[workerId] ??= [];
+    terminators.current[workerId]?.push(() => {
+      worker.terminate();
+    });
+    const instance = new WorkerManager({
+      worker,
+      done: (preserve, result) => {
+        setLoadingState(false);
+        if (!preserve) {
+          terminators.current[workerId]?.forEach((fn) => {
+            fn();
+          });
+          terminators.current[workerId] = [];
+        }
+        resolve(result);
+      },
+      onError,
+      onReleaseBlockingScript,
+      scriptUIRef,
+      onStateChange,
+      plugin,
+      executionPlugin,
+      onShowToast,
+      onClearToasts,
+      sessionData,
+      setSessionData,
+      pluginComponentId: componentId,
+      onShowModal,
+      onShowCreateRecordModal,
+      onShowCreateRelatedRecordModal,
+      onNetworkError,
+      pushHistory,
+      onNetworkRequest,
+      appPath,
+      createFileId,
+      performFileUpload,
+      getPendingCacheCount,
+      invalidateCache
+    });
+    setLoadingState(true);
+    instance.run(
+      scriptBody,
+      {
+        ...context,
+        user,
+        teamMember,
+        business,
+        clientObject,
+        appPath,
+        isDebug
+      },
+      args
+    );
+  });
+};
+var runUnknownExpression = (expression, values) => {
+  const worker = new Worker(new URL("./workers/expression.worker.js", import.meta.url), {
+    type: "module"
+  });
+  return new Promise((resolve) => {
+    worker.onmessage = (e) => {
+      const data = JSON.parse(e.data);
+      worker.terminate();
+      resolve(data.result);
+    };
+    const isDebug = isFlagEnabled("script-runner-logging");
+    worker.postMessage(JSON.stringify({ expression, args: values, isDebug }));
+  });
+};
+var runExpression = async (expression, values) => {
+  const result = await runUnknownExpression(expression, values);
+  return result;
+};
+var runStringExpression = async (expression, values) => {
+  const result = await runUnknownExpression(expression, values);
+  return result;
+};
+var runOptionExpression = async (expression, values) => {
+  const result = await runUnknownExpression(expression, values);
+  return result;
+};
+var runObjectExpression = async (expression, values) => {
+  const result = await runUnknownExpression(expression, values);
+  return result;
+};
+
+// src/index.ts
+var version = "0.0.1-b1f3597";
+
+export { getHash, getStableHash, isFlagEnabled, runExpression, runObjectExpression, runOptionExpression, runScript, runStringExpression, version };
+//# sourceMappingURL=chunk-2MW4AGSN.js.map
+//# sourceMappingURL=chunk-2MW4AGSN.js.map