@d-i-t-a/reader 2.4.10 → 2.5.0

package/dist/injectables/click/click.js

@@ -170,6 +170,201 @@
     }
   });
 
+  // node_modules/es-object-atoms/index.js
+  var require_es_object_atoms = __commonJS({
+    "node_modules/es-object-atoms/index.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = Object;
+    }
+  });
+
+  // node_modules/es-errors/index.js
+  var require_es_errors = __commonJS({
+    "node_modules/es-errors/index.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = Error;
+    }
+  });
+
+  // node_modules/es-errors/eval.js
+  var require_eval = __commonJS({
+    "node_modules/es-errors/eval.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = EvalError;
+    }
+  });
+
+  // node_modules/es-errors/range.js
+  var require_range = __commonJS({
+    "node_modules/es-errors/range.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = RangeError;
+    }
+  });
+
+  // node_modules/es-errors/ref.js
+  var require_ref = __commonJS({
+    "node_modules/es-errors/ref.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = ReferenceError;
+    }
+  });
+
+  // node_modules/es-errors/syntax.js
+  var require_syntax = __commonJS({
+    "node_modules/es-errors/syntax.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = SyntaxError;
+    }
+  });
+
+  // node_modules/es-errors/type.js
+  var require_type = __commonJS({
+    "node_modules/es-errors/type.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = TypeError;
+    }
+  });
+
+  // node_modules/es-errors/uri.js
+  var require_uri = __commonJS({
+    "node_modules/es-errors/uri.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = URIError;
+    }
+  });
+
+  // node_modules/math-intrinsics/abs.js
+  var require_abs = __commonJS({
+    "node_modules/math-intrinsics/abs.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = Math.abs;
+    }
+  });
+
+  // node_modules/math-intrinsics/floor.js
+  var require_floor = __commonJS({
+    "node_modules/math-intrinsics/floor.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = Math.floor;
+    }
+  });
+
+  // node_modules/math-intrinsics/max.js
+  var require_max = __commonJS({
+    "node_modules/math-intrinsics/max.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = Math.max;
+    }
+  });
+
+  // node_modules/math-intrinsics/min.js
+  var require_min = __commonJS({
+    "node_modules/math-intrinsics/min.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = Math.min;
+    }
+  });
+
+  // node_modules/math-intrinsics/pow.js
+  var require_pow = __commonJS({
+    "node_modules/math-intrinsics/pow.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = Math.pow;
+    }
+  });
+
+  // node_modules/math-intrinsics/round.js
+  var require_round = __commonJS({
+    "node_modules/math-intrinsics/round.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = Math.round;
+    }
+  });
+
+  // node_modules/math-intrinsics/isNaN.js
+  var require_isNaN = __commonJS({
+    "node_modules/math-intrinsics/isNaN.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = Number.isNaN || function isNaN2(a) {
+        return a !== a;
+      };
+    }
+  });
+
+  // node_modules/math-intrinsics/sign.js
+  var require_sign = __commonJS({
+    "node_modules/math-intrinsics/sign.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      var $isNaN = require_isNaN();
+      module.exports = function sign(number) {
+        if ($isNaN(number) || number === 0) {
+          return number;
+        }
+        return number < 0 ? -1 : 1;
+      };
+    }
+  });
+
+  // node_modules/gopd/gOPD.js
+  var require_gOPD = __commonJS({
+    "node_modules/gopd/gOPD.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = Object.getOwnPropertyDescriptor;
+    }
+  });
+
+  // node_modules/gopd/index.js
+  var require_gopd = __commonJS({
+    "node_modules/gopd/index.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      var $gOPD = require_gOPD();
+      if ($gOPD) {
+        try {
+          $gOPD([], "length");
+        } catch (e) {
+          $gOPD = null;
+        }
+      }
+      module.exports = $gOPD;
+    }
+  });
+
+  // node_modules/es-define-property/index.js
+  var require_es_define_property = __commonJS({
+    "node_modules/es-define-property/index.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      var $defineProperty = Object.defineProperty || false;
+      if ($defineProperty) {
+        try {
+          $defineProperty({}, "a", { value: 1 });
+        } catch (e) {
+          $defineProperty = false;
+        }
+      }
+      module.exports = $defineProperty;
+    }
+  });
+
   // node_modules/has-symbols/shams.js
   var require_shams = __commonJS({
     "node_modules/has-symbols/shams.js"(exports, module) {
@@ -183,7 +378,7 @@
           return true;
         }
         var obj = {};
-        var sym = Symbol("test");
+        var sym = /* @__PURE__ */ Symbol("test");
         var symObj = Object(sym);
         if (typeof sym === "string") {
           return false;
@@ -196,7 +391,7 @@
         }
         var symVal = 42;
         obj[sym] = symVal;
-        for (sym in obj) {
+        for (var _ in obj) {
           return false;
         }
         if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
@@ -213,7 +408,10 @@
           return false;
         }
         if (typeof Object.getOwnPropertyDescriptor === "function") {
-          var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+          var descriptor = (
+            /** @type {PropertyDescriptor} */
+            Object.getOwnPropertyDescriptor(obj, sym)
+          );
           if (descriptor.value !== symVal || descriptor.enumerable !== true) {
             return false;
           }
@@ -240,7 +438,7 @@
         if (typeof origSymbol("foo") !== "symbol") {
           return false;
         }
-        if (typeof Symbol("bar") !== "symbol") {
+        if (typeof /* @__PURE__ */ Symbol("bar") !== "symbol") {
           return false;
         }
         return hasSymbolSham();
@@ -248,18 +446,22 @@
     }
   });
 
-  // node_modules/has-proto/index.js
-  var require_has_proto = __commonJS({
-    "node_modules/has-proto/index.js"(exports, module) {
+  // node_modules/get-proto/Reflect.getPrototypeOf.js
+  var require_Reflect_getPrototypeOf = __commonJS({
+    "node_modules/get-proto/Reflect.getPrototypeOf.js"(exports, module) {
       "use strict";
       init_polyfills();
-      var test = {
-        foo: {}
-      };
-      var $Object = Object;
-      module.exports = function hasProto() {
-        return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object);
-      };
+      module.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
+    }
+  });
+
+  // node_modules/get-proto/Object.getPrototypeOf.js
+  var require_Object_getPrototypeOf = __commonJS({
+    "node_modules/get-proto/Object.getPrototypeOf.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      var $Object = require_es_object_atoms();
+      module.exports = $Object.getPrototypeOf || null;
     }
   });
 
@@ -350,13 +552,126 @@
     }
   });
 
-  // node_modules/has/src/index.js
-  var require_src = __commonJS({
-    "node_modules/has/src/index.js"(exports, module) {
+  // node_modules/call-bind-apply-helpers/functionCall.js
+  var require_functionCall = __commonJS({
+    "node_modules/call-bind-apply-helpers/functionCall.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = Function.prototype.call;
+    }
+  });
+
+  // node_modules/call-bind-apply-helpers/functionApply.js
+  var require_functionApply = __commonJS({
+    "node_modules/call-bind-apply-helpers/functionApply.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = Function.prototype.apply;
+    }
+  });
+
+  // node_modules/call-bind-apply-helpers/reflectApply.js
+  var require_reflectApply = __commonJS({
+    "node_modules/call-bind-apply-helpers/reflectApply.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      module.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+    }
+  });
+
+  // node_modules/call-bind-apply-helpers/actualApply.js
+  var require_actualApply = __commonJS({
+    "node_modules/call-bind-apply-helpers/actualApply.js"(exports, module) {
       "use strict";
       init_polyfills();
       var bind = require_function_bind();
-      module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
+      var $apply = require_functionApply();
+      var $call = require_functionCall();
+      var $reflectApply = require_reflectApply();
+      module.exports = $reflectApply || bind.call($call, $apply);
+    }
+  });
+
+  // node_modules/call-bind-apply-helpers/index.js
+  var require_call_bind_apply_helpers = __commonJS({
+    "node_modules/call-bind-apply-helpers/index.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      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/dunder-proto/get.js
+  var require_get = __commonJS({
+    "node_modules/dunder-proto/get.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      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/get-proto/index.js
+  var require_get_proto = __commonJS({
+    "node_modules/get-proto/index.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      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/hasown/index.js
+  var require_hasown = __commonJS({
+    "node_modules/hasown/index.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      var call = Function.prototype.call;
+      var $hasOwn = Object.prototype.hasOwnProperty;
+      var bind = require_function_bind();
+      module.exports = bind.call(call, $hasOwn);
     }
   });
 
@@ -366,27 +681,34 @@
       "use strict";
       init_polyfills();
       var undefined2;
-      var $SyntaxError = SyntaxError;
+      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 $TypeError = TypeError;
       var getEvalledConstructor = function(expressionSyntax) {
         try {
           return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
         } catch (e) {
         }
       };
-      var $gOPD = Object.getOwnPropertyDescriptor;
-      if ($gOPD) {
-        try {
-          $gOPD({}, "");
-        } catch (e) {
-          $gOPD = null;
-        }
-      }
+      var $gOPD = require_gopd();
+      var $defineProperty = require_es_define_property();
       var throwTypeError = function() {
         throw new $TypeError();
       };
-      var ThrowTypeError = $gOPD ? function() {
+      var ThrowTypeError = $gOPD ? (function() {
         try {
           arguments.callee;
           return throwTypeError;
@@ -397,15 +719,17 @@
             return throwTypeError;
           }
         }
-      }() : throwTypeError;
+      })() : throwTypeError;
       var hasSymbols = require_has_symbols()();
-      var hasProto = require_has_proto()();
-      var getProto = Object.getPrototypeOf || (hasProto ? function(x) {
-        return x.__proto__;
-      } : null);
+      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,
@@ -426,10 +750,11 @@
         "%decodeURIComponent%": decodeURIComponent,
         "%encodeURI%": encodeURI,
         "%encodeURIComponent%": encodeURIComponent,
-        "%Error%": Error,
+        "%Error%": $Error,
         "%eval%": eval,
         // eslint-disable-line no-eval
-        "%EvalError%": EvalError,
+        "%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,
@@ -446,13 +771,14 @@
         "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
         "%Math%": Math,
         "%Number%": Number,
-        "%Object%": Object,
+        "%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,
+        "%RangeError%": $RangeError,
+        "%ReferenceError%": $ReferenceError,
         "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect,
         "%RegExp%": RegExp,
         "%Set%": typeof Set === "undefined" ? undefined2 : Set,
@@ -469,10 +795,22 @@
         "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray,
         "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array,
         "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array,
-        "%URIError%": URIError,
+        "%URIError%": $URIError,
         "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap,
         "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef,
-        "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet
+        "%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 {
@@ -506,6 +844,7 @@
         return value;
       };
       var LEGACY_ALIASES = {
+        __proto__: null,
         "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
         "%ArrayPrototype%": ["Array", "prototype"],
         "%ArrayProto_entries%": ["Array", "prototype", "entries"],
@@ -559,12 +898,12 @@
         "%WeakSetPrototype%": ["WeakSet", "prototype"]
       };
       var bind = require_function_bind();
-      var hasOwn = require_src();
-      var $concat = bind.call(Function.call, Array.prototype.concat);
-      var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
-      var $replace = bind.call(Function.call, String.prototype.replace);
-      var $strSlice = bind.call(Function.call, String.prototype.slice);
-      var $exec = bind.call(Function.call, RegExp.prototype.exec);
+      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) {
@@ -644,7 +983,7 @@
               if (!allowMissing) {
                 throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
               }
-              return void 0;
+              return void undefined2;
             }
             if ($gOPD && i + 1 >= parts.length) {
               var desc = $gOPD(value, part);
@@ -668,42 +1007,163 @@
     }
   });
 
-  // node_modules/call-bind/index.js
-  var require_call_bind = __commonJS({
-    "node_modules/call-bind/index.js"(exports, module) {
+  // node_modules/define-data-property/index.js
+  var require_define_data_property = __commonJS({
+    "node_modules/define-data-property/index.js"(exports, module) {
       "use strict";
       init_polyfills();
-      var bind = require_function_bind();
-      var GetIntrinsic = require_get_intrinsic();
-      var $apply = GetIntrinsic("%Function.prototype.apply%");
-      var $call = GetIntrinsic("%Function.prototype.call%");
-      var $reflectApply = GetIntrinsic("%Reflect.apply%", true) || bind.call($call, $apply);
-      var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true);
-      var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
-      var $max = GetIntrinsic("%Math.max%");
-      if ($defineProperty) {
+      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/has-property-descriptors/index.js
+  var require_has_property_descriptors = __commonJS({
+    "node_modules/has-property-descriptors/index.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      var $defineProperty = require_es_define_property();
+      var hasPropertyDescriptors = function hasPropertyDescriptors2() {
+        return !!$defineProperty;
+      };
+      hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
+        if (!$defineProperty) {
+          return null;
+        }
         try {
-          $defineProperty({}, "a", { value: 1 });
+          return $defineProperty([], "length", { value: 1 }).length !== 1;
         } catch (e) {
-          $defineProperty = null;
+          return true;
         }
-      }
-      module.exports = function callBind(originalFunction) {
-        var func = $reflectApply(bind, $call, arguments);
-        if ($gOPD && $defineProperty) {
-          var desc = $gOPD(func, "length");
-          if (desc.configurable) {
-            $defineProperty(
-              func,
+      };
+      module.exports = hasPropertyDescriptors;
+    }
+  });
+
+  // node_modules/set-function-length/index.js
+  var require_set_function_length = __commonJS({
+    "node_modules/set-function-length/index.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      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",
-              { value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }
+              length
             );
           }
         }
-        return func;
+        return fn;
+      };
+    }
+  });
+
+  // node_modules/call-bind-apply-helpers/applyBind.js
+  var require_applyBind = __commonJS({
+    "node_modules/call-bind-apply-helpers/applyBind.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      var bind = require_function_bind();
+      var $apply = require_functionApply();
+      var actualApply = require_actualApply();
+      module.exports = function applyBind() {
+        return actualApply(bind, $apply, arguments);
       };
-      var applyBind = function applyBind2() {
-        return $reflectApply(bind, $apply, arguments);
+    }
+  });
+
+  // node_modules/call-bind/index.js
+  var require_call_bind = __commonJS({
+    "node_modules/call-bind/index.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      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 });
@@ -751,9 +1211,9 @@
         }
         return value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && $toString(value) !== "[object Array]" && $toString(value.callee) === "[object Function]";
       };
-      var supportsStandardArguments = function() {
+      var supportsStandardArguments = (function() {
         return isStandardArguments(arguments);
-      }();
+      })();
       isStandardArguments.isLegacyArguments = isLegacyArguments;
       module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
     }
@@ -972,7 +1432,10 @@
           }
         }
       };
-      var forEach = function forEach2(list, iterator, thisArg) {
+      function isArray(x) {
+        return toStr.call(x) === "[object Array]";
+      }
+      module.exports = function forEach(list, iterator, thisArg) {
         if (!isCallable(iterator)) {
           throw new TypeError("iterator must be a function");
         }
@@ -980,7 +1443,7 @@
         if (arguments.length >= 3) {
           receiver = thisArg;
         }
-        if (toStr.call(list) === "[object Array]") {
+        if (isArray(list)) {
           forEachArray(list, iterator, receiver);
         } else if (typeof list === "string") {
           forEachString(list, iterator, receiver);
@@ -988,28 +1451,36 @@
           forEachObject(list, iterator, receiver);
         }
       };
-      module.exports = forEach;
     }
   });
 
-  // node_modules/available-typed-arrays/index.js
-  var require_available_typed_arrays = __commonJS({
-    "node_modules/available-typed-arrays/index.js"(exports, module) {
+  // node_modules/possible-typed-array-names/index.js
+  var require_possible_typed_array_names = __commonJS({
+    "node_modules/possible-typed-array-names/index.js"(exports, module) {
       "use strict";
       init_polyfills();
-      var possibleNames = [
-        "BigInt64Array",
-        "BigUint64Array",
+      module.exports = [
         "Float32Array",
         "Float64Array",
+        "Int8Array",
         "Int16Array",
         "Int32Array",
-        "Int8Array",
+        "Uint8Array",
+        "Uint8ClampedArray",
         "Uint16Array",
         "Uint32Array",
-        "Uint8Array",
-        "Uint8ClampedArray"
+        "BigInt64Array",
+        "BigUint64Array"
       ];
+    }
+  });
+
+  // node_modules/available-typed-arrays/index.js
+  var require_available_typed_arrays = __commonJS({
+    "node_modules/available-typed-arrays/index.js"(exports, module) {
+      "use strict";
+      init_polyfills();
+      var possibleNames = require_possible_typed_array_names();
       var g = typeof globalThis === "undefined" ? globalThis : globalThis;
       module.exports = function availableTypedArrays() {
         var out = [];
@@ -1023,21 +1494,27 @@
     }
   });
 
-  // node_modules/gopd/index.js
-  var require_gopd = __commonJS({
-    "node_modules/gopd/index.js"(exports, module) {
+  // node_modules/call-bound/index.js
+  var require_call_bound = __commonJS({
+    "node_modules/call-bound/index.js"(exports, module) {
       "use strict";
       init_polyfills();
       var GetIntrinsic = require_get_intrinsic();
-      var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true);
-      if ($gOPD) {
-        try {
-          $gOPD([], "length");
-        } catch (e) {
-          $gOPD = null;
+      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]
+          );
         }
-      }
-      module.exports = $gOPD;
+        return intrinsic;
+      };
     }
   });
 
@@ -1049,14 +1526,14 @@
       var forEach = require_for_each();
       var availableTypedArrays = require_available_typed_arrays();
       var callBind = require_call_bind();
-      var callBound = require_callBound();
+      var callBound = require_call_bound();
       var gOPD = require_gopd();
+      var getProto = require_get_proto();
       var $toString = callBound("Object.prototype.toString");
       var hasToStringTag = require_shams2()();
       var g = typeof globalThis === "undefined" ? globalThis : globalThis;
       var typedArrays = availableTypedArrays();
       var $slice = callBound("String.prototype.slice");
-      var getPrototypeOf = Object.getPrototypeOf;
       var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array, value) {
         for (var i = 0; i < array.length; i += 1) {
           if (array[i] === value) {
@@ -1066,14 +1543,14 @@
         return -1;
       };
       var cache = { __proto__: null };
-      if (hasToStringTag && gOPD && getPrototypeOf) {
+      if (hasToStringTag && gOPD && getProto) {
         forEach(typedArrays, function(typedArray) {
           var arr = new g[typedArray]();
-          if (Symbol.toStringTag in arr) {
-            var proto = getPrototypeOf(arr);
+          if (Symbol.toStringTag in arr && getProto) {
+            var proto = getProto(arr);
             var descriptor = gOPD(proto, Symbol.toStringTag);
-            if (!descriptor) {
-              var superProto = getPrototypeOf(proto);
+            if (!descriptor && proto) {
+              var superProto = getProto(proto);
               descriptor = gOPD(superProto, Symbol.toStringTag);
             }
             cache["$" + typedArray] = callBind(descriptor.get);
@@ -1082,34 +1559,54 @@
       } else {
         forEach(typedArrays, function(typedArray) {
           var arr = new g[typedArray]();
-          cache["$" + typedArray] = callBind(arr.slice);
+          var fn = arr.slice || arr.set;
+          if (fn) {
+            cache[
+              /** @type {`$${import('.').TypedArrayName}`} */
+              "$" + typedArray
+            ] = /** @type {import('./types').BoundSlice | import('./types').BoundSet} */
+            // @ts-expect-error TODO FIXME
+            callBind(fn);
+          }
         });
       }
       var tryTypedArrays = function tryAllTypedArrays(value) {
         var found = false;
-        forEach(cache, function(getter, typedArray) {
-          if (!found) {
-            try {
-              if ("$" + getter(value) === typedArray) {
-                found = $slice(typedArray, 1);
+        forEach(
+          /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */
+          cache,
+          /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
+          function(getter, typedArray) {
+            if (!found) {
+              try {
+                if ("$" + getter(value) === typedArray) {
+                  found = /** @type {import('.').TypedArrayName} */
+                  $slice(typedArray, 1);
+                }
+              } catch (e) {
               }
-            } catch (e) {
             }
           }
-        });
+        );
         return found;
       };
       var trySlices = function tryAllSlices(value) {
         var found = false;
-        forEach(cache, function(getter, name) {
-          if (!found) {
-            try {
-              getter(value);
-              found = $slice(name, 1);
-            } catch (e) {
+        forEach(
+          /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */
+          cache,
+          /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
+          function(getter, name) {
+            if (!found) {
+              try {
+                getter(value);
+                found = /** @type {import('.').TypedArrayName} */
+                $slice(name, 1);
+              } catch (e) {
+              }
             }
           }
-        });
+        );
         return found;
       };
       module.exports = function whichTypedArray(value) {
@@ -1445,10 +1942,8 @@
         var args = arguments;
         var len = args.length;
         var str = String(f).replace(formatRegExp, function(x2) {
-          if (x2 === "%%")
-            return "%";
-          if (i >= len)
-            return x2;
+          if (x2 === "%%") return "%";
+          if (i >= len) return x2;
           switch (x2) {
             case "%s":
               return String(args[i++]);
@@ -1527,25 +2022,18 @@
           seen: [],
           stylize: stylizeNoColor
         };
-        if (arguments.length >= 3)
-          ctx.depth = arguments[2];
-        if (arguments.length >= 4)
-          ctx.colors = arguments[3];
+        if (arguments.length >= 3) ctx.depth = arguments[2];
+        if (arguments.length >= 4) ctx.colors = arguments[3];
         if (isBoolean(opts)) {
           ctx.showHidden = opts;
         } else if (opts) {
           exports._extend(ctx, opts);
         }
-        if (isUndefined(ctx.showHidden))
-          ctx.showHidden = false;
-        if (isUndefined(ctx.depth))
-          ctx.depth = 2;
-        if (isUndefined(ctx.colors))
-          ctx.colors = false;
-        if (isUndefined(ctx.customInspect))
-          ctx.customInspect = true;
-        if (ctx.colors)
-          ctx.stylize = stylizeWithColor;
+        if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+        if (isUndefined(ctx.depth)) ctx.depth = 2;
+        if (isUndefined(ctx.colors)) ctx.colors = false;
+        if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+        if (ctx.colors) ctx.stylize = stylizeWithColor;
         return formatValue(ctx, obj, ctx.depth);
       }
       exports.inspect = inspect;
@@ -1775,8 +2263,7 @@
         var numLinesEst = 0;
         var length = output.reduce(function(prev, cur) {
           numLinesEst++;
-          if (cur.indexOf("\n") >= 0)
-            numLinesEst++;
+          if (cur.indexOf("\n") >= 0) numLinesEst++;
           return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
         }, 0);
         if (length > 60) {
@@ -1880,8 +2367,7 @@
       };
       exports.inherits = require_inherits_browser();
       exports._extend = function(origin, add) {
-        if (!add || !isObject(add))
-          return origin;
+        if (!add || !isObject(add)) return origin;
         var keys = Object.keys(add);
         var i = keys.length;
         while (i--) {
@@ -1892,7 +2378,7 @@
       function hasOwnProperty(obj, prop) {
         return Object.prototype.hasOwnProperty.call(obj, prop);
       }
-      var kCustomPromisifiedSymbol = typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0;
+      var kCustomPromisifiedSymbol = typeof Symbol !== "undefined" ? /* @__PURE__ */ Symbol("util.promisify.custom") : void 0;
       exports.promisify = function promisify(original) {
         if (typeof original !== "function")
           throw new TypeError('The "original" argument must be of type Function');
@@ -1934,13 +2420,12 @@
           return promise;
         }
         Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
-        if (kCustomPromisifiedSymbol)
-          Object.defineProperty(fn, kCustomPromisifiedSymbol, {
-            value: fn,
-            enumerable: false,
-            writable: false,
-            configurable: true
-          });
+        if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+          value: fn,
+          enumerable: false,
+          writable: false,
+          configurable: true
+        });
         return Object.defineProperties(
           fn,
           getOwnPropertyDescriptors(original)
@@ -2007,8 +2492,7 @@
   document.addEventListener(
     "click",
     async (_event) => {
-      if (IS_DEV)
-        console.log("Empty Click Handler");
+      if (IS_DEV) console.log("Empty Click Handler");
     },
     true
   );