tty-table 5.0.0 → 6.0.0

package/dist/browser/tty-table.global.js

@@ -0,0 +1,4411 @@
+var process = typeof process !== 'undefined' ? process : { env: {} };
+"use strict";
+var TtyTable = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // stub:stub
+  var require_stub = __commonJS({
+    "stub:stub"(exports, module) {
+      "use strict";
+      module.exports = {};
+    }
+  });
+
+  // node_modules/ansi-regex/index.js
+  var require_ansi_regex = __commonJS({
+    "node_modules/ansi-regex/index.js"(exports, module) {
+      "use strict";
+      module.exports = ({ onlyFirst = false } = {}) => {
+        const pattern = [
+          "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+          "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
+        ].join("|");
+        return new RegExp(pattern, onlyFirst ? void 0 : "g");
+      };
+    }
+  });
+
+  // node_modules/strip-ansi/index.js
+  var require_strip_ansi = __commonJS({
+    "node_modules/strip-ansi/index.js"(exports, module) {
+      "use strict";
+      var ansiRegex = require_ansi_regex();
+      module.exports = (string) => typeof string === "string" ? string.replace(ansiRegex(), "") : string;
+    }
+  });
+
+  // node_modules/clone/clone.js
+  var require_clone = __commonJS({
+    "node_modules/clone/clone.js"(exports, module) {
+      "use strict";
+      var clone = (function() {
+        "use strict";
+        function clone2(parent, circular, depth, prototype) {
+          var filter;
+          if (typeof circular === "object") {
+            depth = circular.depth;
+            prototype = circular.prototype;
+            filter = circular.filter;
+            circular = circular.circular;
+          }
+          var allParents = [];
+          var allChildren = [];
+          var useBuffer = typeof Buffer != "undefined";
+          if (typeof circular == "undefined")
+            circular = true;
+          if (typeof depth == "undefined")
+            depth = Infinity;
+          function _clone(parent2, depth2) {
+            if (parent2 === null)
+              return null;
+            if (depth2 == 0)
+              return parent2;
+            var child;
+            var proto;
+            if (typeof parent2 != "object") {
+              return parent2;
+            }
+            if (clone2.__isArray(parent2)) {
+              child = [];
+            } else if (clone2.__isRegExp(parent2)) {
+              child = new RegExp(parent2.source, __getRegExpFlags(parent2));
+              if (parent2.lastIndex) child.lastIndex = parent2.lastIndex;
+            } else if (clone2.__isDate(parent2)) {
+              child = new Date(parent2.getTime());
+            } else if (useBuffer && Buffer.isBuffer(parent2)) {
+              if (Buffer.allocUnsafe) {
+                child = Buffer.allocUnsafe(parent2.length);
+              } else {
+                child = new Buffer(parent2.length);
+              }
+              parent2.copy(child);
+              return child;
+            } else {
+              if (typeof prototype == "undefined") {
+                proto = Object.getPrototypeOf(parent2);
+                child = Object.create(proto);
+              } else {
+                child = Object.create(prototype);
+                proto = prototype;
+              }
+            }
+            if (circular) {
+              var index = allParents.indexOf(parent2);
+              if (index != -1) {
+                return allChildren[index];
+              }
+              allParents.push(parent2);
+              allChildren.push(child);
+            }
+            for (var i in parent2) {
+              var attrs;
+              if (proto) {
+                attrs = Object.getOwnPropertyDescriptor(proto, i);
+              }
+              if (attrs && attrs.set == null) {
+                continue;
+              }
+              child[i] = _clone(parent2[i], depth2 - 1);
+            }
+            return child;
+          }
+          return _clone(parent, depth);
+        }
+        clone2.clonePrototype = function clonePrototype(parent) {
+          if (parent === null)
+            return null;
+          var c = function() {
+          };
+          c.prototype = parent;
+          return new c();
+        };
+        function __objToStr(o) {
+          return Object.prototype.toString.call(o);
+        }
+        ;
+        clone2.__objToStr = __objToStr;
+        function __isDate(o) {
+          return typeof o === "object" && __objToStr(o) === "[object Date]";
+        }
+        ;
+        clone2.__isDate = __isDate;
+        function __isArray(o) {
+          return typeof o === "object" && __objToStr(o) === "[object Array]";
+        }
+        ;
+        clone2.__isArray = __isArray;
+        function __isRegExp(o) {
+          return typeof o === "object" && __objToStr(o) === "[object RegExp]";
+        }
+        ;
+        clone2.__isRegExp = __isRegExp;
+        function __getRegExpFlags(re) {
+          var flags = "";
+          if (re.global) flags += "g";
+          if (re.ignoreCase) flags += "i";
+          if (re.multiline) flags += "m";
+          return flags;
+        }
+        ;
+        clone2.__getRegExpFlags = __getRegExpFlags;
+        return clone2;
+      })();
+      if (typeof module === "object" && module.exports) {
+        module.exports = clone;
+      }
+    }
+  });
+
+  // node_modules/defaults/index.js
+  var require_defaults = __commonJS({
+    "node_modules/defaults/index.js"(exports, module) {
+      "use strict";
+      var clone = require_clone();
+      module.exports = function(options, defaults2) {
+        options = options || {};
+        Object.keys(defaults2).forEach(function(key) {
+          if (typeof options[key] === "undefined") {
+            options[key] = clone(defaults2[key]);
+          }
+        });
+        return options;
+      };
+    }
+  });
+
+  // node_modules/wcwidth/combining.js
+  var require_combining = __commonJS({
+    "node_modules/wcwidth/combining.js"(exports, module) {
+      "use strict";
+      module.exports = [
+        [768, 879],
+        [1155, 1158],
+        [1160, 1161],
+        [1425, 1469],
+        [1471, 1471],
+        [1473, 1474],
+        [1476, 1477],
+        [1479, 1479],
+        [1536, 1539],
+        [1552, 1557],
+        [1611, 1630],
+        [1648, 1648],
+        [1750, 1764],
+        [1767, 1768],
+        [1770, 1773],
+        [1807, 1807],
+        [1809, 1809],
+        [1840, 1866],
+        [1958, 1968],
+        [2027, 2035],
+        [2305, 2306],
+        [2364, 2364],
+        [2369, 2376],
+        [2381, 2381],
+        [2385, 2388],
+        [2402, 2403],
+        [2433, 2433],
+        [2492, 2492],
+        [2497, 2500],
+        [2509, 2509],
+        [2530, 2531],
+        [2561, 2562],
+        [2620, 2620],
+        [2625, 2626],
+        [2631, 2632],
+        [2635, 2637],
+        [2672, 2673],
+        [2689, 2690],
+        [2748, 2748],
+        [2753, 2757],
+        [2759, 2760],
+        [2765, 2765],
+        [2786, 2787],
+        [2817, 2817],
+        [2876, 2876],
+        [2879, 2879],
+        [2881, 2883],
+        [2893, 2893],
+        [2902, 2902],
+        [2946, 2946],
+        [3008, 3008],
+        [3021, 3021],
+        [3134, 3136],
+        [3142, 3144],
+        [3146, 3149],
+        [3157, 3158],
+        [3260, 3260],
+        [3263, 3263],
+        [3270, 3270],
+        [3276, 3277],
+        [3298, 3299],
+        [3393, 3395],
+        [3405, 3405],
+        [3530, 3530],
+        [3538, 3540],
+        [3542, 3542],
+        [3633, 3633],
+        [3636, 3642],
+        [3655, 3662],
+        [3761, 3761],
+        [3764, 3769],
+        [3771, 3772],
+        [3784, 3789],
+        [3864, 3865],
+        [3893, 3893],
+        [3895, 3895],
+        [3897, 3897],
+        [3953, 3966],
+        [3968, 3972],
+        [3974, 3975],
+        [3984, 3991],
+        [3993, 4028],
+        [4038, 4038],
+        [4141, 4144],
+        [4146, 4146],
+        [4150, 4151],
+        [4153, 4153],
+        [4184, 4185],
+        [4448, 4607],
+        [4959, 4959],
+        [5906, 5908],
+        [5938, 5940],
+        [5970, 5971],
+        [6002, 6003],
+        [6068, 6069],
+        [6071, 6077],
+        [6086, 6086],
+        [6089, 6099],
+        [6109, 6109],
+        [6155, 6157],
+        [6313, 6313],
+        [6432, 6434],
+        [6439, 6440],
+        [6450, 6450],
+        [6457, 6459],
+        [6679, 6680],
+        [6912, 6915],
+        [6964, 6964],
+        [6966, 6970],
+        [6972, 6972],
+        [6978, 6978],
+        [7019, 7027],
+        [7616, 7626],
+        [7678, 7679],
+        [8203, 8207],
+        [8234, 8238],
+        [8288, 8291],
+        [8298, 8303],
+        [8400, 8431],
+        [12330, 12335],
+        [12441, 12442],
+        [43014, 43014],
+        [43019, 43019],
+        [43045, 43046],
+        [64286, 64286],
+        [65024, 65039],
+        [65056, 65059],
+        [65279, 65279],
+        [65529, 65531],
+        [68097, 68099],
+        [68101, 68102],
+        [68108, 68111],
+        [68152, 68154],
+        [68159, 68159],
+        [119143, 119145],
+        [119155, 119170],
+        [119173, 119179],
+        [119210, 119213],
+        [119362, 119364],
+        [917505, 917505],
+        [917536, 917631],
+        [917760, 917999]
+      ];
+    }
+  });
+
+  // node_modules/wcwidth/index.js
+  var require_wcwidth = __commonJS({
+    "node_modules/wcwidth/index.js"(exports, module) {
+      "use strict";
+      var defaults2 = require_defaults();
+      var combining = require_combining();
+      var DEFAULTS = {
+        nul: 0,
+        control: 0
+      };
+      module.exports = function wcwidth3(str) {
+        return wcswidth(str, DEFAULTS);
+      };
+      module.exports.config = function(opts) {
+        opts = defaults2(opts || {}, DEFAULTS);
+        return function wcwidth3(str) {
+          return wcswidth(str, opts);
+        };
+      };
+      function wcswidth(str, opts) {
+        if (typeof str !== "string") return wcwidth2(str, opts);
+        var s = 0;
+        for (var i = 0; i < str.length; i++) {
+          var n = wcwidth2(str.charCodeAt(i), opts);
+          if (n < 0) return -1;
+          s += n;
+        }
+        return s;
+      }
+      function wcwidth2(ucs, opts) {
+        if (ucs === 0) return opts.nul;
+        if (ucs < 32 || ucs >= 127 && ucs < 160) return opts.control;
+        if (bisearch(ucs)) return 0;
+        return 1 + (ucs >= 4352 && (ucs <= 4447 || // Hangul Jamo init. consonants
+        ucs == 9001 || ucs == 9002 || ucs >= 11904 && ucs <= 42191 && ucs != 12351 || // CJK ... Yi
+        ucs >= 44032 && ucs <= 55203 || // Hangul Syllables
+        ucs >= 63744 && ucs <= 64255 || // CJK Compatibility Ideographs
+        ucs >= 65040 && ucs <= 65049 || // Vertical forms
+        ucs >= 65072 && ucs <= 65135 || // CJK Compatibility Forms
+        ucs >= 65280 && ucs <= 65376 || // Fullwidth Forms
+        ucs >= 65504 && ucs <= 65510 || ucs >= 131072 && ucs <= 196605 || ucs >= 196608 && ucs <= 262141));
+      }
+      function bisearch(ucs) {
+        var min = 0;
+        var max = combining.length - 1;
+        var mid;
+        if (ucs < combining[0][0] || ucs > combining[max][1]) return false;
+        while (max >= min) {
+          mid = Math.floor((min + max) / 2);
+          if (ucs > combining[mid][1]) min = mid + 1;
+          else if (ucs < combining[mid][0]) max = mid - 1;
+          else return true;
+        }
+        return false;
+      }
+    }
+  });
+
+  // node_modules/breakword/dist/main.js
+  var require_main = __commonJS({
+    "node_modules/breakword/dist/main.js"(exports, module) {
+      "use strict";
+      function _toConsumableArray(arr) {
+        if (Array.isArray(arr)) {
+          for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        } else {
+          return Array.from(arr);
+        }
+      }
+      var wcwidth2 = require_wcwidth();
+      module.exports = function(input, breakAtLength) {
+        var str = input.toString();
+        var charArr = [].concat(_toConsumableArray(str));
+        var index = 0;
+        var indexOfLastFitChar = 0;
+        var fittableLength = 0;
+        while (charArr.length > 0) {
+          var char = charArr.shift();
+          var currentLength = fittableLength + wcwidth2(char);
+          if (currentLength <= breakAtLength) {
+            indexOfLastFitChar = index;
+            fittableLength = currentLength;
+            index++;
+          } else {
+            break;
+          }
+        }
+        return indexOfLastFitChar;
+      };
+    }
+  });
+
+  // node_modules/object-keys/isArguments.js
+  var require_isArguments = __commonJS({
+    "node_modules/object-keys/isArguments.js"(exports, module) {
+      "use strict";
+      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/object-keys/implementation.js
+  var require_implementation = __commonJS({
+    "node_modules/object-keys/implementation.js"(exports, module) {
+      "use strict";
+      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/object-keys/index.js
+  var require_object_keys = __commonJS({
+    "node_modules/object-keys/index.js"(exports, module) {
+      "use strict";
+      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/es-define-property/index.js
+  var require_es_define_property = __commonJS({
+    "node_modules/es-define-property/index.js"(exports, module) {
+      "use strict";
+      var $defineProperty = Object.defineProperty || false;
+      if ($defineProperty) {
+        try {
+          $defineProperty({}, "a", { value: 1 });
+        } catch (e) {
+          $defineProperty = false;
+        }
+      }
+      module.exports = $defineProperty;
+    }
+  });
+
+  // node_modules/es-errors/syntax.js
+  var require_syntax = __commonJS({
+    "node_modules/es-errors/syntax.js"(exports, module) {
+      "use strict";
+      module.exports = SyntaxError;
+    }
+  });
+
+  // node_modules/es-errors/type.js
+  var require_type = __commonJS({
+    "node_modules/es-errors/type.js"(exports, module) {
+      "use strict";
+      module.exports = TypeError;
+    }
+  });
+
+  // node_modules/gopd/gOPD.js
+  var require_gOPD = __commonJS({
+    "node_modules/gopd/gOPD.js"(exports, module) {
+      "use strict";
+      module.exports = Object.getOwnPropertyDescriptor;
+    }
+  });
+
+  // node_modules/gopd/index.js
+  var require_gopd = __commonJS({
+    "node_modules/gopd/index.js"(exports, module) {
+      "use strict";
+      var $gOPD = require_gOPD();
+      if ($gOPD) {
+        try {
+          $gOPD([], "length");
+        } catch (e) {
+          $gOPD = null;
+        }
+      }
+      module.exports = $gOPD;
+    }
+  });
+
+  // node_modules/define-data-property/index.js
+  var require_define_data_property = __commonJS({
+    "node_modules/define-data-property/index.js"(exports, module) {
+      "use strict";
+      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";
+      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/define-properties/index.js
+  var require_define_properties = __commonJS({
+    "node_modules/define-properties/index.js"(exports, module) {
+      "use strict";
+      var keys = require_object_keys();
+      var hasSymbols = typeof Symbol === "function" && typeof /* @__PURE__ */ Symbol("foo") === "symbol";
+      var toStr = Object.prototype.toString;
+      var concat = Array.prototype.concat;
+      var defineDataProperty = require_define_data_property();
+      var isFunction = function(fn) {
+        return typeof fn === "function" && toStr.call(fn) === "[object Function]";
+      };
+      var supportsDescriptors = require_has_property_descriptors()();
+      var defineProperty = function(object, name, value, predicate) {
+        if (name in object) {
+          if (predicate === true) {
+            if (object[name] === value) {
+              return;
+            }
+          } else if (!isFunction(predicate) || !predicate()) {
+            return;
+          }
+        }
+        if (supportsDescriptors) {
+          defineDataProperty(object, name, value, true);
+        } else {
+          defineDataProperty(object, name, value);
+        }
+      };
+      var defineProperties = function(object, map) {
+        var predicates = arguments.length > 2 ? arguments[2] : {};
+        var props = keys(map);
+        if (hasSymbols) {
+          props = concat.call(props, Object.getOwnPropertySymbols(map));
+        }
+        for (var i = 0; i < props.length; i += 1) {
+          defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
+        }
+      };
+      defineProperties.supportsDescriptors = !!supportsDescriptors;
+      module.exports = defineProperties;
+    }
+  });
+
+  // node_modules/es-object-atoms/index.js
+  var require_es_object_atoms = __commonJS({
+    "node_modules/es-object-atoms/index.js"(exports, module) {
+      "use strict";
+      module.exports = Object;
+    }
+  });
+
+  // node_modules/es-errors/index.js
+  var require_es_errors = __commonJS({
+    "node_modules/es-errors/index.js"(exports, module) {
+      "use strict";
+      module.exports = Error;
+    }
+  });
+
+  // node_modules/es-errors/eval.js
+  var require_eval = __commonJS({
+    "node_modules/es-errors/eval.js"(exports, module) {
+      "use strict";
+      module.exports = EvalError;
+    }
+  });
+
+  // node_modules/es-errors/range.js
+  var require_range = __commonJS({
+    "node_modules/es-errors/range.js"(exports, module) {
+      "use strict";
+      module.exports = RangeError;
+    }
+  });
+
+  // node_modules/es-errors/ref.js
+  var require_ref = __commonJS({
+    "node_modules/es-errors/ref.js"(exports, module) {
+      "use strict";
+      module.exports = ReferenceError;
+    }
+  });
+
+  // node_modules/es-errors/uri.js
+  var require_uri = __commonJS({
+    "node_modules/es-errors/uri.js"(exports, module) {
+      "use strict";
+      module.exports = URIError;
+    }
+  });
+
+  // node_modules/math-intrinsics/abs.js
+  var require_abs = __commonJS({
+    "node_modules/math-intrinsics/abs.js"(exports, module) {
+      "use strict";
+      module.exports = Math.abs;
+    }
+  });
+
+  // node_modules/math-intrinsics/floor.js
+  var require_floor = __commonJS({
+    "node_modules/math-intrinsics/floor.js"(exports, module) {
+      "use strict";
+      module.exports = Math.floor;
+    }
+  });
+
+  // node_modules/math-intrinsics/max.js
+  var require_max = __commonJS({
+    "node_modules/math-intrinsics/max.js"(exports, module) {
+      "use strict";
+      module.exports = Math.max;
+    }
+  });
+
+  // node_modules/math-intrinsics/min.js
+  var require_min = __commonJS({
+    "node_modules/math-intrinsics/min.js"(exports, module) {
+      "use strict";
+      module.exports = Math.min;
+    }
+  });
+
+  // node_modules/math-intrinsics/pow.js
+  var require_pow = __commonJS({
+    "node_modules/math-intrinsics/pow.js"(exports, module) {
+      "use strict";
+      module.exports = Math.pow;
+    }
+  });
+
+  // node_modules/math-intrinsics/round.js
+  var require_round = __commonJS({
+    "node_modules/math-intrinsics/round.js"(exports, module) {
+      "use strict";
+      module.exports = Math.round;
+    }
+  });
+
+  // node_modules/math-intrinsics/isNaN.js
+  var require_isNaN = __commonJS({
+    "node_modules/math-intrinsics/isNaN.js"(exports, module) {
+      "use strict";
+      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";
+      var $isNaN = require_isNaN();
+      module.exports = function sign(number) {
+        if ($isNaN(number) || number === 0) {
+          return number;
+        }
+        return number < 0 ? -1 : 1;
+      };
+    }
+  });
+
+  // node_modules/has-symbols/shams.js
+  var require_shams = __commonJS({
+    "node_modules/has-symbols/shams.js"(exports, module) {
+      "use strict";
+      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/has-symbols/index.js
+  var require_has_symbols = __commonJS({
+    "node_modules/has-symbols/index.js"(exports, module) {
+      "use strict";
+      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/get-proto/Reflect.getPrototypeOf.js
+  var require_Reflect_getPrototypeOf = __commonJS({
+    "node_modules/get-proto/Reflect.getPrototypeOf.js"(exports, module) {
+      "use strict";
+      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";
+      var $Object = require_es_object_atoms();
+      module.exports = $Object.getPrototypeOf || null;
+    }
+  });
+
+  // node_modules/function-bind/implementation.js
+  var require_implementation2 = __commonJS({
+    "node_modules/function-bind/implementation.js"(exports, module) {
+      "use strict";
+      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 || 0, 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/function-bind/index.js
+  var require_function_bind = __commonJS({
+    "node_modules/function-bind/index.js"(exports, module) {
+      "use strict";
+      var implementation = require_implementation2();
+      module.exports = Function.prototype.bind || implementation;
+    }
+  });
+
+  // node_modules/call-bind-apply-helpers/functionCall.js
+  var require_functionCall = __commonJS({
+    "node_modules/call-bind-apply-helpers/functionCall.js"(exports, module) {
+      "use strict";
+      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";
+      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";
+      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";
+      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/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";
+      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";
+      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";
+      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";
+      var call = Function.prototype.call;
+      var $hasOwn = Object.prototype.hasOwnProperty;
+      var bind = require_function_bind();
+      module.exports = bind.call(call, $hasOwn);
+    }
+  });
+
+  // node_modules/get-intrinsic/index.js
+  var require_get_intrinsic = __commonJS({
+    "node_modules/get-intrinsic/index.js"(exports, module) {
+      "use strict";
+      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/set-function-length/index.js
+  var require_set_function_length = __commonJS({
+    "node_modules/set-function-length/index.js"(exports, module) {
+      "use strict";
+      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/call-bind-apply-helpers/applyBind.js
+  var require_applyBind = __commonJS({
+    "node_modules/call-bind-apply-helpers/applyBind.js"(exports, module) {
+      "use strict";
+      var bind = require_function_bind();
+      var $apply = require_functionApply();
+      var actualApply = require_actualApply();
+      module.exports = function applyBind() {
+        return actualApply(bind, $apply, arguments);
+      };
+    }
+  });
+
+  // node_modules/call-bind/index.js
+  var require_call_bind = __commonJS({
+    "node_modules/call-bind/index.js"(exports, module) {
+      "use strict";
+      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 = 1 + originalFunction.length - (arguments.length - 1);
+        return setFunctionLength(
+          func,
+          adjustedLength > 0 ? adjustedLength : 0,
+          true
+        );
+      };
+      if ($defineProperty) {
+        $defineProperty(module.exports, "apply", { value: applyBind });
+      } else {
+        module.exports.apply = applyBind;
+      }
+    }
+  });
+
+  // node_modules/math-intrinsics/isFinite.js
+  var require_isFinite = __commonJS({
+    "node_modules/math-intrinsics/isFinite.js"(exports, module) {
+      "use strict";
+      var $isNaN = require_isNaN();
+      module.exports = function isFinite2(x) {
+        return (typeof x === "number" || typeof x === "bigint") && !$isNaN(x) && x !== Infinity && x !== -Infinity;
+      };
+    }
+  });
+
+  // node_modules/math-intrinsics/isInteger.js
+  var require_isInteger = __commonJS({
+    "node_modules/math-intrinsics/isInteger.js"(exports, module) {
+      "use strict";
+      var $abs = require_abs();
+      var $floor = require_floor();
+      var $isNaN = require_isNaN();
+      var $isFinite = require_isFinite();
+      module.exports = function isInteger(argument) {
+        if (typeof argument !== "number" || $isNaN(argument) || !$isFinite(argument)) {
+          return false;
+        }
+        var absValue = $abs(argument);
+        return $floor(absValue) === absValue;
+      };
+    }
+  });
+
+  // node_modules/es-object-atoms/isObject.js
+  var require_isObject = __commonJS({
+    "node_modules/es-object-atoms/isObject.js"(exports, module) {
+      "use strict";
+      module.exports = function isObject(x) {
+        return !!x && (typeof x === "function" || typeof x === "object");
+      };
+    }
+  });
+
+  // node_modules/math-intrinsics/constants/maxArrayLength.js
+  var require_maxArrayLength = __commonJS({
+    "node_modules/math-intrinsics/constants/maxArrayLength.js"(exports, module) {
+      "use strict";
+      module.exports = 4294967295;
+    }
+  });
+
+  // node_modules/set-proto/Reflect.setPrototypeOf.js
+  var require_Reflect_setPrototypeOf = __commonJS({
+    "node_modules/set-proto/Reflect.setPrototypeOf.js"(exports, module) {
+      "use strict";
+      module.exports = typeof Reflect !== "undefined" && Reflect.setPrototypeOf || null;
+    }
+  });
+
+  // node_modules/set-proto/Object.setPrototypeOf.js
+  var require_Object_setPrototypeOf = __commonJS({
+    "node_modules/set-proto/Object.setPrototypeOf.js"(exports, module) {
+      "use strict";
+      var $Object = require_es_object_atoms();
+      module.exports = $Object.setPrototypeOf || null;
+    }
+  });
+
+  // node_modules/dunder-proto/set.js
+  var require_set = __commonJS({
+    "node_modules/dunder-proto/set.js"(exports, module) {
+      "use strict";
+      var callBind = require_call_bind_apply_helpers();
+      var gOPD = require_gopd();
+      var $TypeError = require_type();
+      var obj = {};
+      try {
+        obj.__proto__ = null;
+      } catch (e) {
+        if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") {
+          throw e;
+        }
+      }
+      var hasProtoMutator = !("toString" in obj);
+      var desc = gOPD && gOPD(
+        Object.prototype,
+        /** @type {keyof typeof Object.prototype} */
+        "__proto__"
+      );
+      module.exports = hasProtoMutator && // eslint-disable-next-line no-extra-parens
+      (!!desc && typeof desc.set === "function" && /** @type {import('./set')} */
+      callBind([desc.set]) || /** @type {import('./set')} */
+      function setDunder(object, proto) {
+        if (object == null) {
+          throw new $TypeError("set Object.prototype.__proto__ called on null or undefined");
+        }
+        object.__proto__ = proto;
+        return proto;
+      });
+    }
+  });
+
+  // node_modules/set-proto/index.js
+  var require_set_proto = __commonJS({
+    "node_modules/set-proto/index.js"(exports, module) {
+      "use strict";
+      var reflectSetProto = require_Reflect_setPrototypeOf();
+      var originalSetProto = require_Object_setPrototypeOf();
+      var setDunderProto = require_set();
+      var $TypeError = require_type();
+      module.exports = reflectSetProto ? function setProto(O, proto) {
+        if (reflectSetProto(O, proto)) {
+          return O;
+        }
+        throw new $TypeError("Reflect.setPrototypeOf: failed to set [[Prototype]]");
+      } : originalSetProto || (setDunderProto ? function setProto(O, proto) {
+        setDunderProto(O, proto);
+        return O;
+      } : null);
+    }
+  });
+
+  // node_modules/es-abstract/2024/ArrayCreate.js
+  var require_ArrayCreate = __commonJS({
+    "node_modules/es-abstract/2024/ArrayCreate.js"(exports, module) {
+      "use strict";
+      var GetIntrinsic = require_get_intrinsic();
+      var $ArrayPrototype = GetIntrinsic("%Array.prototype%");
+      var $RangeError = require_range();
+      var $SyntaxError = require_syntax();
+      var $TypeError = require_type();
+      var isInteger = require_isInteger();
+      var MAX_ARRAY_LENGTH = require_maxArrayLength();
+      var $setProto = require_set_proto();
+      module.exports = function ArrayCreate(length) {
+        if (!isInteger(length) || length < 0) {
+          throw new $TypeError("Assertion failed: `length` must be an integer Number >= 0");
+        }
+        if (length > MAX_ARRAY_LENGTH) {
+          throw new $RangeError("length is greater than (2**32 - 1)");
+        }
+        var proto = arguments.length > 1 ? arguments[1] : $ArrayPrototype;
+        var A = [];
+        if (proto !== $ArrayPrototype) {
+          if (!$setProto) {
+            throw new $SyntaxError("ArrayCreate: a `proto` argument that is not `Array.prototype` is not supported in an environment that does not support setting the [[Prototype]]");
+          }
+          $setProto(A, proto);
+        }
+        if (length !== 0) {
+          A.length = length;
+        }
+        return A;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/helpers/isPropertyKey.js
+  var require_isPropertyKey = __commonJS({
+    "node_modules/es-abstract/helpers/isPropertyKey.js"(exports, module) {
+      "use strict";
+      module.exports = function isPropertyKey(argument) {
+        return typeof argument === "string" || typeof argument === "symbol";
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/Get.js
+  var require_Get = __commonJS({
+    "node_modules/es-abstract/2024/Get.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var inspect = require_stub();
+      var isPropertyKey = require_isPropertyKey();
+      var isObject = require_isObject();
+      module.exports = function Get(O, P) {
+        if (!isObject(O)) {
+          throw new $TypeError("Assertion failed: Type(O) is not Object");
+        }
+        if (!isPropertyKey(P)) {
+          throw new $TypeError("Assertion failed: P is not a Property Key, got " + inspect(P));
+        }
+        return O[P];
+      };
+    }
+  });
+
+  // node_modules/call-bound/index.js
+  var require_call_bound = __commonJS({
+    "node_modules/call-bound/index.js"(exports, module) {
+      "use strict";
+      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/es-abstract/helpers/IsArray.js
+  var require_IsArray = __commonJS({
+    "node_modules/es-abstract/helpers/IsArray.js"(exports, module) {
+      "use strict";
+      var GetIntrinsic = require_get_intrinsic();
+      var $Array = GetIntrinsic("%Array%");
+      var toStr = !$Array.isArray && require_call_bound()("Object.prototype.toString");
+      module.exports = $Array.isArray || function IsArray(argument) {
+        return toStr(argument) === "[object Array]";
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/IsArray.js
+  var require_IsArray2 = __commonJS({
+    "node_modules/es-abstract/2024/IsArray.js"(exports, module) {
+      "use strict";
+      module.exports = require_IsArray();
+    }
+  });
+
+  // node_modules/es-abstract/GetIntrinsic.js
+  var require_GetIntrinsic = __commonJS({
+    "node_modules/es-abstract/GetIntrinsic.js"(exports, module) {
+      "use strict";
+      module.exports = require_get_intrinsic();
+    }
+  });
+
+  // node_modules/es-abstract/helpers/records/property-descriptor.js
+  var require_property_descriptor = __commonJS({
+    "node_modules/es-abstract/helpers/records/property-descriptor.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var hasOwn = require_hasown();
+      var allowed = {
+        __proto__: null,
+        "[[Configurable]]": true,
+        "[[Enumerable]]": true,
+        "[[Get]]": true,
+        "[[Set]]": true,
+        "[[Value]]": true,
+        "[[Writable]]": true
+      };
+      module.exports = function isPropertyDescriptor(Desc) {
+        if (!Desc || typeof Desc !== "object") {
+          return false;
+        }
+        for (var key in Desc) {
+          if (hasOwn(Desc, key) && !allowed[key]) {
+            return false;
+          }
+        }
+        var isData = hasOwn(Desc, "[[Value]]") || hasOwn(Desc, "[[Writable]]");
+        var IsAccessor = hasOwn(Desc, "[[Get]]") || hasOwn(Desc, "[[Set]]");
+        if (isData && IsAccessor) {
+          throw new $TypeError("Property Descriptors may not be both accessor and data descriptors");
+        }
+        return true;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/helpers/DefineOwnProperty.js
+  var require_DefineOwnProperty = __commonJS({
+    "node_modules/es-abstract/helpers/DefineOwnProperty.js"(exports, module) {
+      "use strict";
+      var hasPropertyDescriptors = require_has_property_descriptors();
+      var $defineProperty = require_es_define_property();
+      var hasArrayLengthDefineBug = hasPropertyDescriptors.hasArrayLengthDefineBug();
+      var isArray = hasArrayLengthDefineBug && require_IsArray();
+      var callBound = require_call_bound();
+      var $isEnumerable = callBound("Object.prototype.propertyIsEnumerable");
+      module.exports = function DefineOwnProperty(IsDataDescriptor, SameValue, FromPropertyDescriptor, O, P, desc) {
+        if (!$defineProperty) {
+          if (!IsDataDescriptor(desc)) {
+            return false;
+          }
+          if (!desc["[[Configurable]]"] || !desc["[[Writable]]"]) {
+            return false;
+          }
+          if (P in O && $isEnumerable(O, P) !== !!desc["[[Enumerable]]"]) {
+            return false;
+          }
+          var V = desc["[[Value]]"];
+          O[P] = V;
+          return SameValue(O[P], V);
+        }
+        if (hasArrayLengthDefineBug && P === "length" && "[[Value]]" in desc && isArray(O) && O.length !== desc["[[Value]]"]) {
+          O.length = desc["[[Value]]"];
+          return O.length === desc["[[Value]]"];
+        }
+        $defineProperty(O, P, FromPropertyDescriptor(desc));
+        return true;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/helpers/fromPropertyDescriptor.js
+  var require_fromPropertyDescriptor = __commonJS({
+    "node_modules/es-abstract/helpers/fromPropertyDescriptor.js"(exports, module) {
+      "use strict";
+      module.exports = function fromPropertyDescriptor(Desc) {
+        if (typeof Desc === "undefined") {
+          return Desc;
+        }
+        var obj = {};
+        if ("[[Value]]" in Desc) {
+          obj.value = Desc["[[Value]]"];
+        }
+        if ("[[Writable]]" in Desc) {
+          obj.writable = !!Desc["[[Writable]]"];
+        }
+        if ("[[Get]]" in Desc) {
+          obj.get = Desc["[[Get]]"];
+        }
+        if ("[[Set]]" in Desc) {
+          obj.set = Desc["[[Set]]"];
+        }
+        if ("[[Enumerable]]" in Desc) {
+          obj.enumerable = !!Desc["[[Enumerable]]"];
+        }
+        if ("[[Configurable]]" in Desc) {
+          obj.configurable = !!Desc["[[Configurable]]"];
+        }
+        return obj;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/FromPropertyDescriptor.js
+  var require_FromPropertyDescriptor = __commonJS({
+    "node_modules/es-abstract/2024/FromPropertyDescriptor.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var isPropertyDescriptor = require_property_descriptor();
+      var fromPropertyDescriptor = require_fromPropertyDescriptor();
+      module.exports = function FromPropertyDescriptor(Desc) {
+        if (typeof Desc !== "undefined" && !isPropertyDescriptor(Desc)) {
+          throw new $TypeError("Assertion failed: `Desc` must be a Property Descriptor");
+        }
+        return fromPropertyDescriptor(Desc);
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/IsDataDescriptor.js
+  var require_IsDataDescriptor = __commonJS({
+    "node_modules/es-abstract/2024/IsDataDescriptor.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var hasOwn = require_hasown();
+      var isPropertyDescriptor = require_property_descriptor();
+      module.exports = function IsDataDescriptor(Desc) {
+        if (typeof Desc === "undefined") {
+          return false;
+        }
+        if (!isPropertyDescriptor(Desc)) {
+          throw new $TypeError("Assertion failed: `Desc` must be a Property Descriptor");
+        }
+        if (!hasOwn(Desc, "[[Value]]") && !hasOwn(Desc, "[[Writable]]")) {
+          return false;
+        }
+        return true;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/SameValue.js
+  var require_SameValue = __commonJS({
+    "node_modules/es-abstract/2024/SameValue.js"(exports, module) {
+      "use strict";
+      var $isNaN = require_isNaN();
+      module.exports = function SameValue(x, y) {
+        if (x === y) {
+          if (x === 0) {
+            return 1 / x === 1 / y;
+          }
+          return true;
+        }
+        return $isNaN(x) && $isNaN(y);
+      };
+    }
+  });
+
+  // node_modules/is-callable/index.js
+  var require_is_callable = __commonJS({
+    "node_modules/is-callable/index.js"(exports, module) {
+      "use strict";
+      var fnToStr = Function.prototype.toString;
+      var reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply;
+      var badArrayLike;
+      var isCallableMarker;
+      if (typeof reflectApply === "function" && typeof Object.defineProperty === "function") {
+        try {
+          badArrayLike = Object.defineProperty({}, "length", {
+            get: function() {
+              throw isCallableMarker;
+            }
+          });
+          isCallableMarker = {};
+          reflectApply(function() {
+            throw 42;
+          }, null, badArrayLike);
+        } catch (_) {
+          if (_ !== isCallableMarker) {
+            reflectApply = null;
+          }
+        }
+      } else {
+        reflectApply = null;
+      }
+      var constructorRegex = /^\s*class\b/;
+      var isES6ClassFn = function isES6ClassFunction(value) {
+        try {
+          var fnStr = fnToStr.call(value);
+          return constructorRegex.test(fnStr);
+        } catch (e) {
+          return false;
+        }
+      };
+      var tryFunctionObject = function tryFunctionToStr(value) {
+        try {
+          if (isES6ClassFn(value)) {
+            return false;
+          }
+          fnToStr.call(value);
+          return true;
+        } catch (e) {
+          return false;
+        }
+      };
+      var toStr = Object.prototype.toString;
+      var objectClass = "[object Object]";
+      var fnClass = "[object Function]";
+      var genClass = "[object GeneratorFunction]";
+      var ddaClass = "[object HTMLAllCollection]";
+      var ddaClass2 = "[object HTML document.all class]";
+      var ddaClass3 = "[object HTMLCollection]";
+      var hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag;
+      var isIE68 = !(0 in [,]);
+      var isDDA = function isDocumentDotAll() {
+        return false;
+      };
+      if (typeof document === "object") {
+        all = document.all;
+        if (toStr.call(all) === toStr.call(document.all)) {
+          isDDA = function isDocumentDotAll(value) {
+            if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) {
+              try {
+                var str = toStr.call(value);
+                return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null;
+              } catch (e) {
+              }
+            }
+            return false;
+          };
+        }
+      }
+      var all;
+      module.exports = reflectApply ? function isCallable(value) {
+        if (isDDA(value)) {
+          return true;
+        }
+        if (!value) {
+          return false;
+        }
+        if (typeof value !== "function" && typeof value !== "object") {
+          return false;
+        }
+        try {
+          reflectApply(value, null, badArrayLike);
+        } catch (e) {
+          if (e !== isCallableMarker) {
+            return false;
+          }
+        }
+        return !isES6ClassFn(value) && tryFunctionObject(value);
+      } : function isCallable(value) {
+        if (isDDA(value)) {
+          return true;
+        }
+        if (!value) {
+          return false;
+        }
+        if (typeof value !== "function" && typeof value !== "object") {
+          return false;
+        }
+        if (hasToStringTag) {
+          return tryFunctionObject(value);
+        }
+        if (isES6ClassFn(value)) {
+          return false;
+        }
+        var strClass = toStr.call(value);
+        if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) {
+          return false;
+        }
+        return tryFunctionObject(value);
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/IsCallable.js
+  var require_IsCallable = __commonJS({
+    "node_modules/es-abstract/2024/IsCallable.js"(exports, module) {
+      "use strict";
+      module.exports = require_is_callable();
+    }
+  });
+
+  // node_modules/es-abstract/2024/ToBoolean.js
+  var require_ToBoolean = __commonJS({
+    "node_modules/es-abstract/2024/ToBoolean.js"(exports, module) {
+      "use strict";
+      module.exports = function ToBoolean(value) {
+        return !!value;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/ToPropertyDescriptor.js
+  var require_ToPropertyDescriptor = __commonJS({
+    "node_modules/es-abstract/2024/ToPropertyDescriptor.js"(exports, module) {
+      "use strict";
+      var hasOwn = require_hasown();
+      var $TypeError = require_type();
+      var isObject = require_isObject();
+      var IsCallable = require_IsCallable();
+      var ToBoolean = require_ToBoolean();
+      module.exports = function ToPropertyDescriptor(Obj) {
+        if (!isObject(Obj)) {
+          throw new $TypeError("ToPropertyDescriptor requires an object");
+        }
+        var desc = {};
+        if (hasOwn(Obj, "enumerable")) {
+          desc["[[Enumerable]]"] = ToBoolean(Obj.enumerable);
+        }
+        if (hasOwn(Obj, "configurable")) {
+          desc["[[Configurable]]"] = ToBoolean(Obj.configurable);
+        }
+        if (hasOwn(Obj, "value")) {
+          desc["[[Value]]"] = Obj.value;
+        }
+        if (hasOwn(Obj, "writable")) {
+          desc["[[Writable]]"] = ToBoolean(Obj.writable);
+        }
+        if (hasOwn(Obj, "get")) {
+          var getter = Obj.get;
+          if (typeof getter !== "undefined" && !IsCallable(getter)) {
+            throw new $TypeError("getter must be a function");
+          }
+          desc["[[Get]]"] = getter;
+        }
+        if (hasOwn(Obj, "set")) {
+          var setter = Obj.set;
+          if (typeof setter !== "undefined" && !IsCallable(setter)) {
+            throw new $TypeError("setter must be a function");
+          }
+          desc["[[Set]]"] = setter;
+        }
+        if ((hasOwn(desc, "[[Get]]") || hasOwn(desc, "[[Set]]")) && (hasOwn(desc, "[[Value]]") || hasOwn(desc, "[[Writable]]"))) {
+          throw new $TypeError("Invalid property descriptor. Cannot both specify accessors and a value or writable attribute");
+        }
+        return desc;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/DefinePropertyOrThrow.js
+  var require_DefinePropertyOrThrow = __commonJS({
+    "node_modules/es-abstract/2024/DefinePropertyOrThrow.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var isObject = require_isObject();
+      var isPropertyDescriptor = require_property_descriptor();
+      var DefineOwnProperty = require_DefineOwnProperty();
+      var FromPropertyDescriptor = require_FromPropertyDescriptor();
+      var IsDataDescriptor = require_IsDataDescriptor();
+      var isPropertyKey = require_isPropertyKey();
+      var SameValue = require_SameValue();
+      var ToPropertyDescriptor = require_ToPropertyDescriptor();
+      module.exports = function DefinePropertyOrThrow(O, P, desc) {
+        if (!isObject(O)) {
+          throw new $TypeError("Assertion failed: Type(O) is not Object");
+        }
+        if (!isPropertyKey(P)) {
+          throw new $TypeError("Assertion failed: P is not a Property Key");
+        }
+        var Desc = isPropertyDescriptor(desc) ? desc : ToPropertyDescriptor(desc);
+        if (!isPropertyDescriptor(Desc)) {
+          throw new $TypeError("Assertion failed: Desc is not a valid Property Descriptor");
+        }
+        return DefineOwnProperty(
+          IsDataDescriptor,
+          SameValue,
+          FromPropertyDescriptor,
+          O,
+          P,
+          Desc
+        );
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/IsConstructor.js
+  var require_IsConstructor = __commonJS({
+    "node_modules/es-abstract/2024/IsConstructor.js"(exports, module) {
+      "use strict";
+      var GetIntrinsic = require_GetIntrinsic();
+      var $construct = GetIntrinsic("%Reflect.construct%", true);
+      var DefinePropertyOrThrow = require_DefinePropertyOrThrow();
+      try {
+        DefinePropertyOrThrow({}, "", { "[[Get]]": function() {
+        } });
+      } catch (e) {
+        DefinePropertyOrThrow = null;
+      }
+      if (DefinePropertyOrThrow && $construct) {
+        isConstructorMarker = {};
+        badArrayLike = {};
+        DefinePropertyOrThrow(badArrayLike, "length", {
+          "[[Get]]": function() {
+            throw isConstructorMarker;
+          },
+          "[[Enumerable]]": true
+        });
+        module.exports = function IsConstructor(argument) {
+          try {
+            $construct(argument, badArrayLike);
+          } catch (err) {
+            return err === isConstructorMarker;
+          }
+        };
+      } else {
+        module.exports = function IsConstructor(argument) {
+          return typeof argument === "function" && !!argument.prototype;
+        };
+      }
+      var isConstructorMarker;
+      var badArrayLike;
+    }
+  });
+
+  // node_modules/es-abstract/2024/ArraySpeciesCreate.js
+  var require_ArraySpeciesCreate = __commonJS({
+    "node_modules/es-abstract/2024/ArraySpeciesCreate.js"(exports, module) {
+      "use strict";
+      var GetIntrinsic = require_get_intrinsic();
+      var $species = GetIntrinsic("%Symbol.species%", true);
+      var $TypeError = require_type();
+      var isInteger = require_isInteger();
+      var isObject = require_isObject();
+      var ArrayCreate = require_ArrayCreate();
+      var Get = require_Get();
+      var IsArray = require_IsArray2();
+      var IsConstructor = require_IsConstructor();
+      module.exports = function ArraySpeciesCreate(originalArray, length) {
+        if (!isInteger(length) || length < 0) {
+          throw new $TypeError("Assertion failed: length must be an integer >= 0");
+        }
+        var isArray = IsArray(originalArray);
+        if (!isArray) {
+          return ArrayCreate(length);
+        }
+        var C = Get(originalArray, "constructor");
+        if ($species && isObject(C)) {
+          C = Get(C, $species);
+          if (C === null) {
+            C = void 0;
+          }
+        }
+        if (typeof C === "undefined") {
+          return ArrayCreate(length);
+        }
+        if (!IsConstructor(C)) {
+          throw new $TypeError("C must be a constructor");
+        }
+        return new C(length);
+      };
+    }
+  });
+
+  // node_modules/math-intrinsics/constants/maxSafeInteger.js
+  var require_maxSafeInteger = __commonJS({
+    "node_modules/math-intrinsics/constants/maxSafeInteger.js"(exports, module) {
+      "use strict";
+      module.exports = /** @type {import('./maxSafeInteger')} */
+      Number.MAX_SAFE_INTEGER || 9007199254740991;
+    }
+  });
+
+  // node_modules/es-abstract/2024/Call.js
+  var require_Call = __commonJS({
+    "node_modules/es-abstract/2024/Call.js"(exports, module) {
+      "use strict";
+      var GetIntrinsic = require_get_intrinsic();
+      var callBound = require_call_bound();
+      var $TypeError = require_type();
+      var IsArray = require_IsArray2();
+      var $apply = GetIntrinsic("%Reflect.apply%", true) || callBound("Function.prototype.apply");
+      module.exports = function Call(F, V) {
+        var argumentsList = arguments.length > 2 ? arguments[2] : [];
+        if (!IsArray(argumentsList)) {
+          throw new $TypeError("Assertion failed: optional `argumentsList`, if provided, must be a List");
+        }
+        return $apply(F, V, argumentsList);
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/IsAccessorDescriptor.js
+  var require_IsAccessorDescriptor = __commonJS({
+    "node_modules/es-abstract/2024/IsAccessorDescriptor.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var hasOwn = require_hasown();
+      var isPropertyDescriptor = require_property_descriptor();
+      module.exports = function IsAccessorDescriptor(Desc) {
+        if (typeof Desc === "undefined") {
+          return false;
+        }
+        if (!isPropertyDescriptor(Desc)) {
+          throw new $TypeError("Assertion failed: `Desc` must be a Property Descriptor");
+        }
+        if (!hasOwn(Desc, "[[Get]]") && !hasOwn(Desc, "[[Set]]")) {
+          return false;
+        }
+        return true;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/helpers/isPrimitive.js
+  var require_isPrimitive = __commonJS({
+    "node_modules/es-abstract/helpers/isPrimitive.js"(exports, module) {
+      "use strict";
+      module.exports = function isPrimitive(value) {
+        return value === null || typeof value !== "function" && typeof value !== "object";
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/IsExtensible.js
+  var require_IsExtensible = __commonJS({
+    "node_modules/es-abstract/2024/IsExtensible.js"(exports, module) {
+      "use strict";
+      var GetIntrinsic = require_get_intrinsic();
+      var $preventExtensions = GetIntrinsic("%Object.preventExtensions%", true);
+      var $isExtensible = GetIntrinsic("%Object.isExtensible%", true);
+      var isPrimitive = require_isPrimitive();
+      module.exports = $preventExtensions ? function IsExtensible(obj) {
+        return !isPrimitive(obj) && $isExtensible(obj);
+      } : function IsExtensible(obj) {
+        return !isPrimitive(obj);
+      };
+    }
+  });
+
+  // node_modules/es-abstract/helpers/isFullyPopulatedPropertyDescriptor.js
+  var require_isFullyPopulatedPropertyDescriptor = __commonJS({
+    "node_modules/es-abstract/helpers/isFullyPopulatedPropertyDescriptor.js"(exports, module) {
+      "use strict";
+      var isPropertyDescriptor = require_property_descriptor();
+      module.exports = function isFullyPopulatedPropertyDescriptor(ES, Desc) {
+        return isPropertyDescriptor(Desc) && "[[Enumerable]]" in Desc && "[[Configurable]]" in Desc && (ES.IsAccessorDescriptor(Desc) || ES.IsDataDescriptor(Desc));
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/IsGenericDescriptor.js
+  var require_IsGenericDescriptor = __commonJS({
+    "node_modules/es-abstract/2024/IsGenericDescriptor.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var IsAccessorDescriptor = require_IsAccessorDescriptor();
+      var IsDataDescriptor = require_IsDataDescriptor();
+      var isPropertyDescriptor = require_property_descriptor();
+      module.exports = function IsGenericDescriptor(Desc) {
+        if (typeof Desc === "undefined") {
+          return false;
+        }
+        if (!isPropertyDescriptor(Desc)) {
+          throw new $TypeError("Assertion failed: `Desc` must be a Property Descriptor");
+        }
+        if (!IsAccessorDescriptor(Desc) && !IsDataDescriptor(Desc)) {
+          return true;
+        }
+        return false;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/ValidateAndApplyPropertyDescriptor.js
+  var require_ValidateAndApplyPropertyDescriptor = __commonJS({
+    "node_modules/es-abstract/2024/ValidateAndApplyPropertyDescriptor.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var isObject = require_isObject();
+      var DefineOwnProperty = require_DefineOwnProperty();
+      var isFullyPopulatedPropertyDescriptor = require_isFullyPopulatedPropertyDescriptor();
+      var isPropertyDescriptor = require_property_descriptor();
+      var FromPropertyDescriptor = require_FromPropertyDescriptor();
+      var IsAccessorDescriptor = require_IsAccessorDescriptor();
+      var IsDataDescriptor = require_IsDataDescriptor();
+      var IsGenericDescriptor = require_IsGenericDescriptor();
+      var isPropertyKey = require_isPropertyKey();
+      var SameValue = require_SameValue();
+      module.exports = function ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current) {
+        if (typeof O !== "undefined" && !isObject(O)) {
+          throw new $TypeError("Assertion failed: O must be undefined or an Object");
+        }
+        if (!isPropertyKey(P)) {
+          throw new $TypeError("Assertion failed: P must be a Property Key");
+        }
+        if (typeof extensible !== "boolean") {
+          throw new $TypeError("Assertion failed: extensible must be a Boolean");
+        }
+        if (!isPropertyDescriptor(Desc)) {
+          throw new $TypeError("Assertion failed: Desc must be a Property Descriptor");
+        }
+        if (typeof current !== "undefined" && !isPropertyDescriptor(current)) {
+          throw new $TypeError("Assertion failed: current must be a Property Descriptor, or undefined");
+        }
+        if (typeof current === "undefined") {
+          if (!extensible) {
+            return false;
+          }
+          if (typeof O === "undefined") {
+            return true;
+          }
+          if (IsAccessorDescriptor(Desc)) {
+            return DefineOwnProperty(
+              IsDataDescriptor,
+              SameValue,
+              FromPropertyDescriptor,
+              O,
+              P,
+              Desc
+            );
+          }
+          return DefineOwnProperty(
+            IsDataDescriptor,
+            SameValue,
+            FromPropertyDescriptor,
+            O,
+            P,
+            {
+              "[[Configurable]]": !!Desc["[[Configurable]]"],
+              "[[Enumerable]]": !!Desc["[[Enumerable]]"],
+              "[[Value]]": Desc["[[Value]]"],
+              "[[Writable]]": !!Desc["[[Writable]]"]
+            }
+          );
+        }
+        if (!isFullyPopulatedPropertyDescriptor(
+          {
+            IsAccessorDescriptor,
+            IsDataDescriptor
+          },
+          current
+        )) {
+          throw new $TypeError("`current`, when present, must be a fully populated and valid Property Descriptor");
+        }
+        if (!current["[[Configurable]]"]) {
+          if ("[[Configurable]]" in Desc && Desc["[[Configurable]]"]) {
+            return false;
+          }
+          if ("[[Enumerable]]" in Desc && !SameValue(Desc["[[Enumerable]]"], current["[[Enumerable]]"])) {
+            return false;
+          }
+          if (!IsGenericDescriptor(Desc) && !SameValue(IsAccessorDescriptor(Desc), IsAccessorDescriptor(current))) {
+            return false;
+          }
+          if (IsAccessorDescriptor(current)) {
+            if ("[[Get]]" in Desc && !SameValue(Desc["[[Get]]"], current["[[Get]]"])) {
+              return false;
+            }
+            if ("[[Set]]" in Desc && !SameValue(Desc["[[Set]]"], current["[[Set]]"])) {
+              return false;
+            }
+          } else if (!current["[[Writable]]"]) {
+            if ("[[Writable]]" in Desc && Desc["[[Writable]]"]) {
+              return false;
+            }
+            if ("[[Value]]" in Desc && !SameValue(Desc["[[Value]]"], current["[[Value]]"])) {
+              return false;
+            }
+          }
+        }
+        if (typeof O !== "undefined") {
+          var configurable;
+          var enumerable;
+          if (IsDataDescriptor(current) && IsAccessorDescriptor(Desc)) {
+            configurable = ("[[Configurable]]" in Desc ? Desc : current)["[[Configurable]]"];
+            enumerable = ("[[Enumerable]]" in Desc ? Desc : current)["[[Enumerable]]"];
+            return DefineOwnProperty(
+              IsDataDescriptor,
+              SameValue,
+              FromPropertyDescriptor,
+              O,
+              P,
+              {
+                "[[Configurable]]": !!configurable,
+                "[[Enumerable]]": !!enumerable,
+                "[[Get]]": ("[[Get]]" in Desc ? Desc : current)["[[Get]]"],
+                "[[Set]]": ("[[Set]]" in Desc ? Desc : current)["[[Set]]"]
+              }
+            );
+          } else if (IsAccessorDescriptor(current) && IsDataDescriptor(Desc)) {
+            configurable = ("[[Configurable]]" in Desc ? Desc : current)["[[Configurable]]"];
+            enumerable = ("[[Enumerable]]" in Desc ? Desc : current)["[[Enumerable]]"];
+            return DefineOwnProperty(
+              IsDataDescriptor,
+              SameValue,
+              FromPropertyDescriptor,
+              O,
+              P,
+              {
+                "[[Configurable]]": !!configurable,
+                "[[Enumerable]]": !!enumerable,
+                "[[Value]]": ("[[Value]]" in Desc ? Desc : current)["[[Value]]"],
+                "[[Writable]]": !!("[[Writable]]" in Desc ? Desc : current)["[[Writable]]"]
+              }
+            );
+          }
+          return DefineOwnProperty(
+            IsDataDescriptor,
+            SameValue,
+            FromPropertyDescriptor,
+            O,
+            P,
+            Desc
+          );
+        }
+        return true;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/OrdinaryDefineOwnProperty.js
+  var require_OrdinaryDefineOwnProperty = __commonJS({
+    "node_modules/es-abstract/2024/OrdinaryDefineOwnProperty.js"(exports, module) {
+      "use strict";
+      var $gOPD = require_gopd();
+      var $SyntaxError = require_syntax();
+      var $TypeError = require_type();
+      var isObject = require_isObject();
+      var isPropertyDescriptor = require_property_descriptor();
+      var IsAccessorDescriptor = require_IsAccessorDescriptor();
+      var IsExtensible = require_IsExtensible();
+      var isPropertyKey = require_isPropertyKey();
+      var ToPropertyDescriptor = require_ToPropertyDescriptor();
+      var SameValue = require_SameValue();
+      var ValidateAndApplyPropertyDescriptor = require_ValidateAndApplyPropertyDescriptor();
+      module.exports = function OrdinaryDefineOwnProperty(O, P, Desc) {
+        if (!isObject(O)) {
+          throw new $TypeError("Assertion failed: O must be an Object");
+        }
+        if (!isPropertyKey(P)) {
+          throw new $TypeError("Assertion failed: P must be a Property Key");
+        }
+        if (!isPropertyDescriptor(Desc)) {
+          throw new $TypeError("Assertion failed: Desc must be a Property Descriptor");
+        }
+        if (!$gOPD) {
+          if (IsAccessorDescriptor(Desc)) {
+            throw new $SyntaxError("This environment does not support accessor property descriptors.");
+          }
+          var creatingNormalDataProperty = !(P in O) && Desc["[[Writable]]"] && Desc["[[Enumerable]]"] && Desc["[[Configurable]]"] && "[[Value]]" in Desc;
+          var settingExistingDataProperty = P in O && (!("[[Configurable]]" in Desc) || Desc["[[Configurable]]"]) && (!("[[Enumerable]]" in Desc) || Desc["[[Enumerable]]"]) && (!("[[Writable]]" in Desc) || Desc["[[Writable]]"]) && "[[Value]]" in Desc;
+          if (creatingNormalDataProperty || settingExistingDataProperty) {
+            O[P] = Desc["[[Value]]"];
+            return SameValue(O[P], Desc["[[Value]]"]);
+          }
+          throw new $SyntaxError("This environment does not support defining non-writable, non-enumerable, or non-configurable properties");
+        }
+        var desc = $gOPD(O, P);
+        var current = desc && ToPropertyDescriptor(desc);
+        var extensible = IsExtensible(O);
+        return ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current);
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/CreateDataProperty.js
+  var require_CreateDataProperty = __commonJS({
+    "node_modules/es-abstract/2024/CreateDataProperty.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var isObject = require_isObject();
+      var isPropertyKey = require_isPropertyKey();
+      var OrdinaryDefineOwnProperty = require_OrdinaryDefineOwnProperty();
+      module.exports = function CreateDataProperty(O, P, V) {
+        if (!isObject(O)) {
+          throw new $TypeError("Assertion failed: Type(O) is not Object");
+        }
+        if (!isPropertyKey(P)) {
+          throw new $TypeError("Assertion failed: P is not a Property Key");
+        }
+        var newDesc = {
+          "[[Configurable]]": true,
+          "[[Enumerable]]": true,
+          "[[Value]]": V,
+          "[[Writable]]": true
+        };
+        return OrdinaryDefineOwnProperty(O, P, newDesc);
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/CreateDataPropertyOrThrow.js
+  var require_CreateDataPropertyOrThrow = __commonJS({
+    "node_modules/es-abstract/2024/CreateDataPropertyOrThrow.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var isObject = require_isObject();
+      var CreateDataProperty = require_CreateDataProperty();
+      var isPropertyKey = require_isPropertyKey();
+      module.exports = function CreateDataPropertyOrThrow(O, P, V) {
+        if (!isObject(O)) {
+          throw new $TypeError("Assertion failed: Type(O) is not Object");
+        }
+        if (!isPropertyKey(P)) {
+          throw new $TypeError("Assertion failed: P is not a Property Key");
+        }
+        var success = CreateDataProperty(O, P, V);
+        if (!success) {
+          throw new $TypeError("unable to create data property");
+        }
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/HasProperty.js
+  var require_HasProperty = __commonJS({
+    "node_modules/es-abstract/2024/HasProperty.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var isObject = require_isObject();
+      var isPropertyKey = require_isPropertyKey();
+      module.exports = function HasProperty(O, P) {
+        if (!isObject(O)) {
+          throw new $TypeError("Assertion failed: `O` must be an Object");
+        }
+        if (!isPropertyKey(P)) {
+          throw new $TypeError("Assertion failed: `P` must be a Property Key");
+        }
+        return P in O;
+      };
+    }
+  });
+
+  // node_modules/has-tostringtag/shams.js
+  var require_shams2 = __commonJS({
+    "node_modules/has-tostringtag/shams.js"(exports, module) {
+      "use strict";
+      var hasSymbols = require_shams();
+      module.exports = function hasToStringTagShams() {
+        return hasSymbols() && !!Symbol.toStringTag;
+      };
+    }
+  });
+
+  // node_modules/is-date-object/index.js
+  var require_is_date_object = __commonJS({
+    "node_modules/is-date-object/index.js"(exports, module) {
+      "use strict";
+      var callBound = require_call_bound();
+      var getDay = callBound("Date.prototype.getDay");
+      var tryDateObject = function tryDateGetDayCall(value) {
+        try {
+          getDay(value);
+          return true;
+        } catch (e) {
+          return false;
+        }
+      };
+      var toStr = callBound("Object.prototype.toString");
+      var dateClass = "[object Date]";
+      var hasToStringTag = require_shams2()();
+      module.exports = function isDateObject(value) {
+        if (typeof value !== "object" || value === null) {
+          return false;
+        }
+        return hasToStringTag ? tryDateObject(value) : toStr(value) === dateClass;
+      };
+    }
+  });
+
+  // node_modules/is-regex/index.js
+  var require_is_regex = __commonJS({
+    "node_modules/is-regex/index.js"(exports, module) {
+      "use strict";
+      var callBound = require_call_bound();
+      var hasToStringTag = require_shams2()();
+      var hasOwn = require_hasown();
+      var gOPD = require_gopd();
+      var fn;
+      if (hasToStringTag) {
+        $exec = callBound("RegExp.prototype.exec");
+        isRegexMarker = {};
+        throwRegexMarker = function() {
+          throw isRegexMarker;
+        };
+        badStringifier = {
+          toString: throwRegexMarker,
+          valueOf: throwRegexMarker
+        };
+        if (typeof Symbol.toPrimitive === "symbol") {
+          badStringifier[Symbol.toPrimitive] = throwRegexMarker;
+        }
+        fn = function isRegex(value) {
+          if (!value || typeof value !== "object") {
+            return false;
+          }
+          var descriptor = (
+            /** @type {NonNullable<typeof gOPD>} */
+            gOPD(
+              /** @type {{ lastIndex?: unknown }} */
+              value,
+              "lastIndex"
+            )
+          );
+          var hasLastIndexDataProperty = descriptor && hasOwn(descriptor, "value");
+          if (!hasLastIndexDataProperty) {
+            return false;
+          }
+          try {
+            $exec(
+              value,
+              /** @type {string} */
+              /** @type {unknown} */
+              badStringifier
+            );
+          } catch (e) {
+            return e === isRegexMarker;
+          }
+        };
+      } else {
+        $toString = callBound("Object.prototype.toString");
+        regexClass = "[object RegExp]";
+        fn = function isRegex(value) {
+          if (!value || typeof value !== "object" && typeof value !== "function") {
+            return false;
+          }
+          return $toString(value) === regexClass;
+        };
+      }
+      var $exec;
+      var isRegexMarker;
+      var throwRegexMarker;
+      var badStringifier;
+      var $toString;
+      var regexClass;
+      module.exports = fn;
+    }
+  });
+
+  // node_modules/safe-regex-test/index.js
+  var require_safe_regex_test = __commonJS({
+    "node_modules/safe-regex-test/index.js"(exports, module) {
+      "use strict";
+      var callBound = require_call_bound();
+      var isRegex = require_is_regex();
+      var $exec = callBound("RegExp.prototype.exec");
+      var $TypeError = require_type();
+      module.exports = function regexTester(regex) {
+        if (!isRegex(regex)) {
+          throw new $TypeError("`regex` must be a RegExp");
+        }
+        return function test(s) {
+          return $exec(regex, s) !== null;
+        };
+      };
+    }
+  });
+
+  // node_modules/is-symbol/index.js
+  var require_is_symbol = __commonJS({
+    "node_modules/is-symbol/index.js"(exports, module) {
+      "use strict";
+      var callBound = require_call_bound();
+      var $toString = callBound("Object.prototype.toString");
+      var hasSymbols = require_has_symbols()();
+      var safeRegexTest = require_safe_regex_test();
+      if (hasSymbols) {
+        $symToStr = callBound("Symbol.prototype.toString");
+        isSymString = safeRegexTest(/^Symbol\(.*\)$/);
+        isSymbolObject = function isRealSymbolObject(value) {
+          if (typeof value.valueOf() !== "symbol") {
+            return false;
+          }
+          return isSymString($symToStr(value));
+        };
+        module.exports = function isSymbol(value) {
+          if (typeof value === "symbol") {
+            return true;
+          }
+          if (!value || typeof value !== "object" || $toString(value) !== "[object Symbol]") {
+            return false;
+          }
+          try {
+            return isSymbolObject(value);
+          } catch (e) {
+            return false;
+          }
+        };
+      } else {
+        module.exports = function isSymbol(value) {
+          return false;
+        };
+      }
+      var $symToStr;
+      var isSymString;
+      var isSymbolObject;
+    }
+  });
+
+  // node_modules/es-to-primitive/helpers/isPrimitive.js
+  var require_isPrimitive2 = __commonJS({
+    "node_modules/es-to-primitive/helpers/isPrimitive.js"(exports, module) {
+      "use strict";
+      module.exports = function isPrimitive(value) {
+        return value === null || typeof value !== "function" && typeof value !== "object";
+      };
+    }
+  });
+
+  // node_modules/es-abstract-get/isPropertyKey.js
+  var require_isPropertyKey2 = __commonJS({
+    "node_modules/es-abstract-get/isPropertyKey.js"(exports, module) {
+      "use strict";
+      module.exports = function isPropertyKey(argument) {
+        return typeof argument === "string" || typeof argument === "symbol";
+      };
+    }
+  });
+
+  // node_modules/es-abstract-get/GetV.js
+  var require_GetV = __commonJS({
+    "node_modules/es-abstract-get/GetV.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var inspect = require_stub();
+      var isPropertyKey = require_isPropertyKey2();
+      module.exports = function GetV(V, P) {
+        if (!isPropertyKey(P)) {
+          throw new $TypeError("Assertion failed: P is not a Property Key, got " + inspect(P));
+        }
+        return (
+          /** @type {Record<typeof P, unknown>} */
+          V[P]
+        );
+      };
+    }
+  });
+
+  // node_modules/es-abstract-get/GetMethod.js
+  var require_GetMethod = __commonJS({
+    "node_modules/es-abstract-get/GetMethod.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var isCallable = require_is_callable();
+      var inspect = require_stub();
+      var GetV = require_GetV();
+      var isPropertyKey = require_isPropertyKey2();
+      module.exports = function GetMethod(O, P) {
+        if (!isPropertyKey(P)) {
+          throw new $TypeError("Assertion failed: P is not a Property Key");
+        }
+        var func = GetV(O, P);
+        if (func == null) {
+          return void 0;
+        }
+        if (!isCallable(func)) {
+          throw new $TypeError(inspect(P) + " is not a function: " + inspect(func));
+        }
+        return func;
+      };
+    }
+  });
+
+  // node_modules/es-to-primitive/es2015.js
+  var require_es2015 = __commonJS({
+    "node_modules/es-to-primitive/es2015.js"(exports, module) {
+      "use strict";
+      var hasSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "symbol";
+      var isCallable = require_is_callable();
+      var isDate = require_is_date_object();
+      var isSymbol = require_is_symbol();
+      var $TypeError = require_type();
+      var isPrimitive = require_isPrimitive2();
+      function OrdinaryToPrimitive(O, hint) {
+        if (typeof O === "undefined" || O === null) {
+          throw new $TypeError("Cannot call method on " + O);
+        }
+        if (typeof hint !== "string" || hint !== "number" && hint !== "string") {
+          throw new $TypeError('hint must be "string" or "number"');
+        }
+        var methodNames = hint === "string" ? ["toString", "valueOf"] : ["valueOf", "toString"];
+        var method, result, i;
+        for (i = 0; i < methodNames.length; ++i) {
+          method = O[methodNames[i]];
+          if (isCallable(method)) {
+            result = method.call(O);
+            if (isPrimitive(result)) {
+              return (
+                /** @type {primitiveES6} */
+                result
+              );
+            }
+          }
+        }
+        throw new $TypeError("No default value");
+      }
+      var GetMethod = require_GetMethod();
+      module.exports = function ToPrimitive(input) {
+        if (isPrimitive(input)) {
+          return (
+            /** @type {primitiveES6} */
+            input
+          );
+        }
+        var hint = "default";
+        if (arguments.length > 1) {
+          if (arguments[1] === String) {
+            hint = "string";
+          } else if (arguments[1] === Number) {
+            hint = "number";
+          }
+        }
+        var exoticToPrim;
+        if (hasSymbols) {
+          if (Symbol.toPrimitive) {
+            exoticToPrim = GetMethod(
+              /** @type {{ [k in SymbolConstructor['toPrimitive']]?: Function }} */
+              input,
+              Symbol.toPrimitive
+            );
+          } else if (isSymbol(input)) {
+            exoticToPrim = Symbol.prototype.valueOf;
+          }
+        }
+        if (typeof exoticToPrim !== "undefined") {
+          var result = exoticToPrim.call(input, hint);
+          if (isPrimitive(result)) {
+            return (
+              /** @type {primitiveES6} */
+              result
+            );
+          }
+          throw new $TypeError("unable to convert exotic object to primitive");
+        }
+        if (hint === "default" && (isDate(input) || isSymbol(input))) {
+          hint = /** @type {const} */
+          "string";
+        }
+        return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/ToPrimitive.js
+  var require_ToPrimitive = __commonJS({
+    "node_modules/es-abstract/2024/ToPrimitive.js"(exports, module) {
+      "use strict";
+      var toPrimitive = require_es2015();
+      module.exports = function ToPrimitive(input) {
+        if (arguments.length > 1) {
+          return toPrimitive(input, arguments[1]);
+        }
+        return toPrimitive(input);
+      };
+    }
+  });
+
+  // node_modules/es-object-atoms/RequireObjectCoercible.js
+  var require_RequireObjectCoercible = __commonJS({
+    "node_modules/es-object-atoms/RequireObjectCoercible.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      module.exports = function RequireObjectCoercible(value) {
+        if (value == null) {
+          throw new $TypeError(arguments.length > 0 && arguments[1] || "Cannot call method on " + value);
+        }
+        return value;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2025/ToString.js
+  var require_ToString = __commonJS({
+    "node_modules/es-abstract/2025/ToString.js"(exports, module) {
+      "use strict";
+      var GetIntrinsic = require_get_intrinsic();
+      var $String = GetIntrinsic("%String%");
+      var $TypeError = require_type();
+      module.exports = function ToString(argument) {
+        if (typeof argument === "symbol") {
+          throw new $TypeError("Cannot convert a Symbol value to a string");
+        }
+        return $String(argument);
+      };
+    }
+  });
+
+  // node_modules/string.prototype.trim/implementation.js
+  var require_implementation3 = __commonJS({
+    "node_modules/string.prototype.trim/implementation.js"(exports, module) {
+      "use strict";
+      var RequireObjectCoercible = require_RequireObjectCoercible();
+      var ToString = require_ToString();
+      var callBound = require_call_bound();
+      var safeRegexTester = require_safe_regex_test();
+      var $replace = callBound("String.prototype.replace");
+      var $charAt = callBound("String.prototype.charAt");
+      var $slice = callBound("String.prototype.slice");
+      var mvsIsWS = /^\s$/.test("\u180E");
+      var leftWhitespace = mvsIsWS ? /^[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+/ : /^[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+/;
+      var isWhitespace = safeRegexTester(mvsIsWS ? /[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]$/ : /[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]$/);
+      module.exports = function trim() {
+        var S = $replace(ToString(RequireObjectCoercible(this)), leftWhitespace, "");
+        var end = S.length;
+        while (end > 0 && isWhitespace($charAt(S, end - 1))) {
+          end -= 1;
+        }
+        return $slice(S, 0, end);
+      };
+    }
+  });
+
+  // node_modules/string.prototype.trim/polyfill.js
+  var require_polyfill = __commonJS({
+    "node_modules/string.prototype.trim/polyfill.js"(exports, module) {
+      "use strict";
+      var implementation = require_implementation3();
+      var zeroWidthSpace = "\u200B";
+      var mongolianVowelSeparator = "\u180E";
+      module.exports = function getPolyfill() {
+        if (String.prototype.trim && zeroWidthSpace.trim() === zeroWidthSpace && mongolianVowelSeparator.trim() === mongolianVowelSeparator && ("_" + mongolianVowelSeparator).trim() === "_" + mongolianVowelSeparator && (mongolianVowelSeparator + "_").trim() === mongolianVowelSeparator + "_") {
+          return String.prototype.trim;
+        }
+        return implementation;
+      };
+    }
+  });
+
+  // node_modules/string.prototype.trim/shim.js
+  var require_shim = __commonJS({
+    "node_modules/string.prototype.trim/shim.js"(exports, module) {
+      "use strict";
+      var supportsDescriptors = require_has_property_descriptors()();
+      var defineDataProperty = require_define_data_property();
+      var getPolyfill = require_polyfill();
+      module.exports = function shimStringTrim() {
+        var polyfill = getPolyfill();
+        if (String.prototype.trim !== polyfill) {
+          if (supportsDescriptors) {
+            defineDataProperty(String.prototype, "trim", polyfill, true);
+          } else {
+            defineDataProperty(String.prototype, "trim", polyfill);
+          }
+        }
+        return polyfill;
+      };
+    }
+  });
+
+  // node_modules/string.prototype.trim/index.js
+  var require_string_prototype = __commonJS({
+    "node_modules/string.prototype.trim/index.js"(exports, module) {
+      "use strict";
+      var callBind = require_call_bind();
+      var define = require_define_properties();
+      var RequireObjectCoercible = require_RequireObjectCoercible();
+      var implementation = require_implementation3();
+      var getPolyfill = require_polyfill();
+      var shim = require_shim();
+      var bound = callBind(getPolyfill());
+      var boundMethod = function trim(receiver) {
+        RequireObjectCoercible(receiver);
+        return bound(receiver);
+      };
+      define(boundMethod, {
+        getPolyfill,
+        implementation,
+        shim
+      });
+      module.exports = boundMethod;
+    }
+  });
+
+  // node_modules/es-abstract/2024/StringToNumber.js
+  var require_StringToNumber = __commonJS({
+    "node_modules/es-abstract/2024/StringToNumber.js"(exports, module) {
+      "use strict";
+      var GetIntrinsic = require_get_intrinsic();
+      var $RegExp = GetIntrinsic("%RegExp%");
+      var $TypeError = require_type();
+      var $parseInteger = GetIntrinsic("%parseInt%");
+      var callBound = require_call_bound();
+      var regexTester = require_safe_regex_test();
+      var $strSlice = callBound("String.prototype.slice");
+      var isBinary = regexTester(/^0b[01]+$/i);
+      var isOctal = regexTester(/^0o[0-7]+$/i);
+      var isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i);
+      var nonWS = ["\x85", "\u200B", "\uFFFE"].join("");
+      var nonWSregex = new $RegExp("[" + nonWS + "]", "g");
+      var hasNonWS = regexTester(nonWSregex);
+      var $trim = require_string_prototype();
+      module.exports = function StringToNumber(argument) {
+        if (typeof argument !== "string") {
+          throw new $TypeError("Assertion failed: `argument` is not a String");
+        }
+        if (isBinary(argument)) {
+          return +$parseInteger($strSlice(argument, 2), 2);
+        }
+        if (isOctal(argument)) {
+          return +$parseInteger($strSlice(argument, 2), 8);
+        }
+        if (hasNonWS(argument) || isInvalidHexLiteral(argument)) {
+          return NaN;
+        }
+        var trimmed = $trim(argument);
+        if (trimmed !== argument) {
+          return StringToNumber(trimmed);
+        }
+        return +argument;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/ToNumber.js
+  var require_ToNumber = __commonJS({
+    "node_modules/es-abstract/2024/ToNumber.js"(exports, module) {
+      "use strict";
+      var GetIntrinsic = require_get_intrinsic();
+      var $TypeError = require_type();
+      var $Number = GetIntrinsic("%Number%");
+      var isPrimitive = require_isPrimitive();
+      var ToPrimitive = require_ToPrimitive();
+      var StringToNumber = require_StringToNumber();
+      module.exports = function ToNumber(argument) {
+        var value = isPrimitive(argument) ? argument : ToPrimitive(argument, $Number);
+        if (typeof value === "symbol") {
+          throw new $TypeError("Cannot convert a Symbol value to a number");
+        }
+        if (typeof value === "bigint") {
+          throw new $TypeError("Conversion from 'BigInt' to 'number' is not allowed.");
+        }
+        if (typeof value === "string") {
+          return StringToNumber(value);
+        }
+        return +value;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/floor.js
+  var require_floor2 = __commonJS({
+    "node_modules/es-abstract/2024/floor.js"(exports, module) {
+      "use strict";
+      var $floor = require_floor();
+      module.exports = function floor(x) {
+        if (typeof x === "bigint") {
+          return x;
+        }
+        return $floor(x);
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/truncate.js
+  var require_truncate = __commonJS({
+    "node_modules/es-abstract/2024/truncate.js"(exports, module) {
+      "use strict";
+      var floor = require_floor2();
+      var $TypeError = require_type();
+      module.exports = function truncate2(x) {
+        if (typeof x !== "number" && typeof x !== "bigint") {
+          throw new $TypeError("argument must be a Number or a BigInt");
+        }
+        var result = x < 0 ? -floor(-x) : floor(x);
+        return result === 0 ? 0 : result;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/ToIntegerOrInfinity.js
+  var require_ToIntegerOrInfinity = __commonJS({
+    "node_modules/es-abstract/2024/ToIntegerOrInfinity.js"(exports, module) {
+      "use strict";
+      var ToNumber = require_ToNumber();
+      var truncate2 = require_truncate();
+      var $isNaN = require_isNaN();
+      var $isFinite = require_isFinite();
+      module.exports = function ToIntegerOrInfinity(value) {
+        var number = ToNumber(value);
+        if ($isNaN(number) || number === 0) {
+          return 0;
+        }
+        if (!$isFinite(number)) {
+          return number;
+        }
+        return truncate2(number);
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/ToLength.js
+  var require_ToLength = __commonJS({
+    "node_modules/es-abstract/2024/ToLength.js"(exports, module) {
+      "use strict";
+      var MAX_SAFE_INTEGER = require_maxSafeInteger();
+      var ToIntegerOrInfinity = require_ToIntegerOrInfinity();
+      module.exports = function ToLength(argument) {
+        var len = ToIntegerOrInfinity(argument);
+        if (len <= 0) {
+          return 0;
+        }
+        if (len > MAX_SAFE_INTEGER) {
+          return MAX_SAFE_INTEGER;
+        }
+        return len;
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/LengthOfArrayLike.js
+  var require_LengthOfArrayLike = __commonJS({
+    "node_modules/es-abstract/2024/LengthOfArrayLike.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var isObject = require_isObject();
+      var Get = require_Get();
+      var ToLength = require_ToLength();
+      module.exports = function LengthOfArrayLike(obj) {
+        if (!isObject(obj)) {
+          throw new $TypeError("Assertion failed: `obj` must be an Object");
+        }
+        return ToLength(Get(obj, "length"));
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/ToString.js
+  var require_ToString2 = __commonJS({
+    "node_modules/es-abstract/2024/ToString.js"(exports, module) {
+      "use strict";
+      var GetIntrinsic = require_get_intrinsic();
+      var $String = GetIntrinsic("%String%");
+      var $TypeError = require_type();
+      module.exports = function ToString(argument) {
+        if (typeof argument === "symbol") {
+          throw new $TypeError("Cannot convert a Symbol value to a string");
+        }
+        return $String(argument);
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/FlattenIntoArray.js
+  var require_FlattenIntoArray = __commonJS({
+    "node_modules/es-abstract/2024/FlattenIntoArray.js"(exports, module) {
+      "use strict";
+      var $TypeError = require_type();
+      var MAX_SAFE_INTEGER = require_maxSafeInteger();
+      var Call = require_Call();
+      var CreateDataPropertyOrThrow = require_CreateDataPropertyOrThrow();
+      var Get = require_Get();
+      var HasProperty = require_HasProperty();
+      var IsArray = require_IsArray2();
+      var LengthOfArrayLike = require_LengthOfArrayLike();
+      var ToString = require_ToString2();
+      module.exports = function FlattenIntoArray(target, source, sourceLen, start, depth) {
+        var mapperFunction;
+        if (arguments.length > 5) {
+          mapperFunction = arguments[5];
+        }
+        var targetIndex = start;
+        var sourceIndex = 0;
+        while (sourceIndex < sourceLen) {
+          var P = ToString(sourceIndex);
+          var exists = HasProperty(source, P);
+          if (exists === true) {
+            var element = Get(source, P);
+            if (typeof mapperFunction !== "undefined") {
+              if (arguments.length <= 6) {
+                throw new $TypeError("Assertion failed: thisArg is required when mapperFunction is provided");
+              }
+              element = Call(mapperFunction, arguments[6], [element, sourceIndex, source]);
+            }
+            var shouldFlatten = false;
+            if (depth > 0) {
+              shouldFlatten = IsArray(element);
+            }
+            if (shouldFlatten) {
+              var elementLen = LengthOfArrayLike(element);
+              targetIndex = FlattenIntoArray(target, element, elementLen, targetIndex, depth - 1);
+            } else {
+              if (targetIndex >= MAX_SAFE_INTEGER) {
+                throw new $TypeError("index too large");
+              }
+              CreateDataPropertyOrThrow(target, ToString(targetIndex), element);
+              targetIndex += 1;
+            }
+          }
+          sourceIndex += 1;
+        }
+        return targetIndex;
+      };
+    }
+  });
+
+  // node_modules/es-object-atoms/ToObject.js
+  var require_ToObject = __commonJS({
+    "node_modules/es-object-atoms/ToObject.js"(exports, module) {
+      "use strict";
+      var $Object = require_es_object_atoms();
+      var RequireObjectCoercible = require_RequireObjectCoercible();
+      module.exports = function ToObject(value) {
+        RequireObjectCoercible(value);
+        return $Object(value);
+      };
+    }
+  });
+
+  // node_modules/es-abstract/2024/ToObject.js
+  var require_ToObject2 = __commonJS({
+    "node_modules/es-abstract/2024/ToObject.js"(exports, module) {
+      "use strict";
+      module.exports = require_ToObject();
+    }
+  });
+
+  // node_modules/array.prototype.flat/implementation.js
+  var require_implementation4 = __commonJS({
+    "node_modules/array.prototype.flat/implementation.js"(exports, module) {
+      "use strict";
+      var ArraySpeciesCreate = require_ArraySpeciesCreate();
+      var FlattenIntoArray = require_FlattenIntoArray();
+      var Get = require_Get();
+      var ToIntegerOrInfinity = require_ToIntegerOrInfinity();
+      var ToLength = require_ToLength();
+      var ToObject = require_ToObject2();
+      module.exports = function flat() {
+        var O = ToObject(this);
+        var sourceLen = ToLength(Get(O, "length"));
+        var depthNum = 1;
+        if (arguments.length > 0 && typeof arguments[0] !== "undefined") {
+          depthNum = ToIntegerOrInfinity(arguments[0]);
+        }
+        var A = ArraySpeciesCreate(O, 0);
+        FlattenIntoArray(A, O, sourceLen, 0, depthNum);
+        return A;
+      };
+    }
+  });
+
+  // node_modules/array.prototype.flat/polyfill.js
+  var require_polyfill2 = __commonJS({
+    "node_modules/array.prototype.flat/polyfill.js"(exports, module) {
+      "use strict";
+      var implementation = require_implementation4();
+      module.exports = function getPolyfill() {
+        return Array.prototype.flat || implementation;
+      };
+    }
+  });
+
+  // node_modules/es-shim-unscopables/index.js
+  var require_es_shim_unscopables = __commonJS({
+    "node_modules/es-shim-unscopables/index.js"(exports, module) {
+      "use strict";
+      var hasOwn = require_hasown();
+      var hasUnscopables = typeof Symbol === "function" && typeof Symbol.unscopables === "symbol";
+      var map = hasUnscopables && Array.prototype[Symbol.unscopables];
+      var $TypeError = TypeError;
+      module.exports = function shimUnscopables(method) {
+        if (typeof method !== "string" || !method) {
+          throw new $TypeError("method must be a non-empty string");
+        }
+        if (!hasOwn(Array.prototype, method)) {
+          throw new $TypeError("method must be on Array.prototype");
+        }
+        if (hasUnscopables && map) {
+          map[method] = true;
+        }
+      };
+    }
+  });
+
+  // node_modules/array.prototype.flat/shim.js
+  var require_shim2 = __commonJS({
+    "node_modules/array.prototype.flat/shim.js"(exports, module) {
+      "use strict";
+      var define = require_define_properties();
+      var shimUnscopables = require_es_shim_unscopables();
+      var getPolyfill = require_polyfill2();
+      module.exports = function shimFlat() {
+        var polyfill = getPolyfill();
+        define(
+          Array.prototype,
+          { flat: polyfill },
+          { flat: function() {
+            return Array.prototype.flat !== polyfill;
+          } }
+        );
+        shimUnscopables("flat");
+        return polyfill;
+      };
+    }
+  });
+
+  // node_modules/array.prototype.flat/index.js
+  var require_array_prototype = __commonJS({
+    "node_modules/array.prototype.flat/index.js"(exports, module) {
+      "use strict";
+      var define = require_define_properties();
+      var callBind = require_call_bind();
+      var implementation = require_implementation4();
+      var getPolyfill = require_polyfill2();
+      var polyfill = getPolyfill();
+      var shim = require_shim2();
+      var boundFlat = callBind(polyfill);
+      define(boundFlat, {
+        getPolyfill,
+        implementation,
+        shim
+      });
+      module.exports = boundFlat;
+    }
+  });
+
+  // node_modules/smartwrap/src/main.js
+  var require_main2 = __commonJS({
+    "node_modules/smartwrap/src/main.js"(exports, module) {
+      "use strict";
+      var breakword = require_main();
+      var stripansi = require_strip_ansi();
+      var wcwidth2 = require_wcwidth();
+      var flat = require_array_prototype();
+      if (!Array.prototype.flat) flat.shim();
+      var ANSIPattern = [
+        "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+        "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
+      ].join("|");
+      var ANSIRegex = new RegExp(ANSIPattern, "g");
+      var defaults2 = () => {
+        let obj = {};
+        obj.breakword = false;
+        obj.input = [];
+        obj.minWidth = 2;
+        obj.paddingLeft = 0;
+        obj.paddingRight = 0;
+        obj.errorChar = "\uFFFD";
+        obj.returnFormat = "string";
+        obj.skipPadding = false;
+        obj.splitAt = [" ", "	"];
+        obj.trim = true;
+        obj.width = 10;
+        return obj;
+      };
+      var calculateSpaceRemaining = function(lineLength, spacesUsed, config) {
+        return Math.max(lineLength - spacesUsed - config.paddingLeft - config.paddingRight, 0);
+      };
+      var validateInput = (text, options) => {
+        let config = Object.assign({}, defaults2(), options || {});
+        if (config.errorChar) {
+          config.errorChar = config.errorChar.split("")[0];
+          if (wcwidth2(config.errorChar) > 1)
+            throw new Error(`Error character cannot be a wide character (${config.errorChar})`);
+        }
+        config.paddingLeft = Math.abs(config.paddingLeft);
+        config.paddingRight = Math.abs(config.paddingRight);
+        let lineLength = config.width - config.paddingLeft - config.paddingRight;
+        if (lineLength < config.minWidth) {
+          config.skipPadding = true;
+          lineLength = config.minWidth;
+        }
+        if (config.trim) {
+          text = text.trim();
+        }
+        return { text, config, lineLength };
+      };
+      var wrap2 = (input, options) => {
+        let { text, config, lineLength } = validateInput(input, options);
+        let words = [];
+        if (!config.breakword) {
+          if (config.splitAt.indexOf("	") !== -1) {
+            words = text.split(/ |\t/i);
+          } else {
+            words = text.split(" ");
+          }
+        } else {
+          words = [text];
+        }
+        words = words.filter((val) => {
+          if (val.length > 0) {
+            return true;
+          }
+        });
+        let lines = [
+          []
+        ];
+        let spaceRemaining, splitIndex, word;
+        let currentLine = 0;
+        let spacesUsed = 0;
+        while (words.length > 0) {
+          spaceRemaining = calculateSpaceRemaining(lineLength, spacesUsed, config);
+          word = words.shift();
+          let wordLength = wcwidth2(word);
+          switch (true) {
+            // too long for an empty line and is a single character
+            case (lineLength < wordLength && [...word].length === 1):
+              words.unshift(config.errorChar);
+              break;
+            // too long for an empty line, must be broken between 2 lines
+            case lineLength < wordLength:
+              splitIndex = breakword(word, lineLength);
+              let splitWord = [...word];
+              words.unshift(splitWord.slice(0, splitIndex + 1).join(""));
+              words.splice(1, 0, splitWord.slice(splitIndex + 1).join(""));
+              break;
+            // not enough space remaining in line, must be wrapped to next line
+            case spaceRemaining < wordLength:
+              lines.push([]);
+              currentLine++;
+              spacesUsed = 0;
+            /* falls through */
+            // fits on current line
+            // eslint-disable-next-line
+            default:
+              lines[currentLine].push(word);
+              spacesUsed += wordLength + 1;
+          }
+        }
+        lines = lines.map((line) => {
+          line = line.join(" ");
+          if (!config.skipPadding) {
+            line = Array(config.paddingLeft + 1).join(" ") + line + Array(config.paddingRight + 1).join(" ");
+          }
+          return line;
+        });
+        return lines.join("\n");
+      };
+      var splitAnsiInput = (text) => {
+        let matches = [];
+        let textArr = [...text];
+        let textLength = textArr.length;
+        var result;
+        while ((result = ANSIRegex.exec(text)) !== null) {
+          matches.push({
+            start: result.index,
+            end: result.index + result[0].length,
+            match: result[0],
+            length: result[0].length
+          });
+        }
+        if (matches.length < 1) return [];
+        matches = matches.reduce((prev, curr) => {
+          let prevEnd = prev[prev.length - 1];
+          if (prevEnd.end < curr.start) {
+            prev.push({
+              start: prevEnd.end,
+              end: curr.start,
+              length: curr.start - prevEnd.end,
+              expand: true
+            }, curr);
+          } else {
+            prev.push(curr);
+          }
+          return prev;
+        }, [{ start: 0, end: 0 }]).splice(1);
+        let lastMatchEnd = matches[matches.length - 1].end;
+        if (lastMatchEnd < textLength) {
+          matches.push({
+            start: lastMatchEnd,
+            end: textLength,
+            expand: true
+          });
+        }
+        let savedArr = matches.map((match) => {
+          let value = text.substring(match.start, match.end);
+          return match.expand ? [...value] : [value];
+        }).flat(2);
+        return savedArr;
+      };
+      var restoreANSI = (savedArr, processedArr) => {
+        return processedArr.map((char) => {
+          let result;
+          if (char === "\n") {
+            result = [char];
+          } else {
+            let splicePoint = savedArr.findIndex((element) => element === char) + 1;
+            result = savedArr.splice(0, splicePoint);
+          }
+          const ANSIClosePattern = "^\\x1b\\[([0-9]+)*m";
+          const ANSICloseRegex = new RegExp(ANSIClosePattern);
+          const closeCodes = ["0", "21", "22", "23", "24", "25", "27", "28", "29", "39", "49", "54", "55"];
+          let match;
+          while (savedArr.length && (match = savedArr[0].match(ANSICloseRegex))) {
+            if (!closeCodes.includes(match[1])) break;
+            result.push(savedArr.shift());
+          }
+          return result.join("");
+        }).concat(savedArr);
+      };
+      module.exports = (input, options) => {
+        const processedLines = input.toString().split("\n").map((string) => {
+          const savedANSI = splitAnsiInput(string);
+          string = stripansi(string);
+          string = wrap2(string, options);
+          let charArr = [...string];
+          charArr = savedANSI.length > 0 ? restoreANSI(savedANSI, charArr) : charArr;
+          let outArr = charArr.join("").split("\n");
+          return outArr;
+        });
+        return processedLines.flat(2).join("\n");
+      };
+    }
+  });
+
+  // src/browser.ts
+  var browser_exports = {};
+  __export(browser_exports, {
+    default: () => src_default
+  });
+
+  // src/defaults.ts
+  var defaults = {
+    borderCharacters: {
+      invisible: [
+        { v: " ", l: " ", j: " ", h: " ", r: " " },
+        { v: " ", l: " ", j: " ", h: " ", r: " " },
+        { v: " ", l: " ", j: " ", h: " ", r: " " }
+      ],
+      solid: [
+        { v: "\u2502", l: "\u250C", j: "\u252C", h: "\u2500", r: "\u2510" },
+        { v: "\u2502", l: "\u251C", j: "\u253C", h: "\u2500", r: "\u2524" },
+        { v: "\u2502", l: "\u2514", j: "\u2534", h: "\u2500", r: "\u2518" }
+      ],
+      dashed: [
+        { v: "|", l: "+", j: "+", h: "-", r: "+" },
+        { v: "|", l: "+", j: "+", h: "-", r: "+" },
+        { v: "|", l: "+", j: "+", h: "-", r: "+" }
+      ],
+      none: [
+        { v: "", l: "", j: "", h: "", r: "" },
+        { v: "", l: "", j: "", h: "", r: "" },
+        { v: "", l: "", j: "", h: "", r: "" }
+      ]
+    },
+    align: "center",
+    borderColor: null,
+    borderStyle: "solid",
+    color: false,
+    COLUMNS: 80,
+    // if !process.stdout.columns assume redirecting to write stream 80 columns is VT200 standard
+    compact: false,
+    defaultErrorValue: "\uFFFD",
+    defaultValue: "",
+    errorOnNull: false,
+    FIXED_WIDTH: false,
+    footerAlign: "center",
+    footerColor: false,
+    formatter: null,
+    headerAlign: "center",
+    headerColor: "yellow",
+    isNull: false,
+    // undocumented cell setting
+    marginLeft: 2,
+    marginTop: 1,
+    paddingBottom: 0,
+    paddingLeft: 1,
+    paddingRight: 1,
+    paddingTop: 0,
+    showHeader: null,
+    // undocumented
+    truncate: false,
+    width: "100%",
+    GUTTER: 1,
+    // undocumented
+    columnSettings: [],
+    // save so cell options can be merged into column options
+    table: {
+      body: "",
+      columnInnerWidths: [],
+      columnWidths: [],
+      columns: [],
+      footer: "",
+      header: "",
+      // post-rendered strings.
+      height: 0,
+      typeLocked: false
+      // once a table type is selected can't switch
+    }
+  };
+  defaults.borderCharacters["0"] = defaults.borderCharacters.none;
+  defaults.borderCharacters["1"] = defaults.borderCharacters.solid;
+  defaults.borderCharacters["2"] = defaults.borderCharacters.dashed;
+  var defaults_default = defaults;
+
+  // src/style.ts
+  var import_chalk = __toESM(require_stub());
+
+  // node_modules/kleur/index.mjs
+  var FORCE_COLOR;
+  var NODE_DISABLE_COLORS;
+  var NO_COLOR;
+  var TERM;
+  var isTTY = true;
+  if (typeof process !== "undefined") {
+    ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
+    isTTY = process.stdout && process.stdout.isTTY;
+  }
+  var $ = {
+    enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY),
+    // modifiers
+    reset: init(0, 0),
+    bold: init(1, 22),
+    dim: init(2, 22),
+    italic: init(3, 23),
+    underline: init(4, 24),
+    inverse: init(7, 27),
+    hidden: init(8, 28),
+    strikethrough: init(9, 29),
+    // colors
+    black: init(30, 39),
+    red: init(31, 39),
+    green: init(32, 39),
+    yellow: init(33, 39),
+    blue: init(34, 39),
+    magenta: init(35, 39),
+    cyan: init(36, 39),
+    white: init(37, 39),
+    gray: init(90, 39),
+    grey: init(90, 39),
+    // background colors
+    bgBlack: init(40, 49),
+    bgRed: init(41, 49),
+    bgGreen: init(42, 49),
+    bgYellow: init(43, 49),
+    bgBlue: init(44, 49),
+    bgMagenta: init(45, 49),
+    bgCyan: init(46, 49),
+    bgWhite: init(47, 49)
+  };
+  function run(arr, str) {
+    let i = 0, tmp, beg = "", end = "";
+    for (; i < arr.length; i++) {
+      tmp = arr[i];
+      beg += tmp.open;
+      end += tmp.close;
+      if (!!~str.indexOf(tmp.close)) {
+        str = str.replace(tmp.rgx, tmp.close + tmp.open);
+      }
+    }
+    return beg + str + end;
+  }
+  function chain(has, keys) {
+    let ctx = { has, keys };
+    ctx.reset = $.reset.bind(ctx);
+    ctx.bold = $.bold.bind(ctx);
+    ctx.dim = $.dim.bind(ctx);
+    ctx.italic = $.italic.bind(ctx);
+    ctx.underline = $.underline.bind(ctx);
+    ctx.inverse = $.inverse.bind(ctx);
+    ctx.hidden = $.hidden.bind(ctx);
+    ctx.strikethrough = $.strikethrough.bind(ctx);
+    ctx.black = $.black.bind(ctx);
+    ctx.red = $.red.bind(ctx);
+    ctx.green = $.green.bind(ctx);
+    ctx.yellow = $.yellow.bind(ctx);
+    ctx.blue = $.blue.bind(ctx);
+    ctx.magenta = $.magenta.bind(ctx);
+    ctx.cyan = $.cyan.bind(ctx);
+    ctx.white = $.white.bind(ctx);
+    ctx.gray = $.gray.bind(ctx);
+    ctx.grey = $.grey.bind(ctx);
+    ctx.bgBlack = $.bgBlack.bind(ctx);
+    ctx.bgRed = $.bgRed.bind(ctx);
+    ctx.bgGreen = $.bgGreen.bind(ctx);
+    ctx.bgYellow = $.bgYellow.bind(ctx);
+    ctx.bgBlue = $.bgBlue.bind(ctx);
+    ctx.bgMagenta = $.bgMagenta.bind(ctx);
+    ctx.bgCyan = $.bgCyan.bind(ctx);
+    ctx.bgWhite = $.bgWhite.bind(ctx);
+    return ctx;
+  }
+  function init(open, close) {
+    let blk = {
+      open: `\x1B[${open}m`,
+      close: `\x1B[${close}m`,
+      rgx: new RegExp(`\\x1b\\[${close}m`, "g")
+    };
+    return function(txt) {
+      if (this !== void 0 && this.has !== void 0) {
+        !!~this.has.indexOf(open) || (this.has.push(open), this.keys.push(blk));
+        return txt === void 0 ? this : $.enabled ? run(this.keys, txt + "") : txt + "";
+      }
+      return txt === void 0 ? chain([open], [blk]) : $.enabled ? run([blk], txt + "") : txt + "";
+    };
+  }
+  var kleur_default = $;
+
+  // src/style.ts
+  var import_strip_ansi = __toESM(require_strip_ansi());
+  var colorLib = process && process.stdout ? import_chalk.default : kleur_default;
+  var style = (str, ...colors) => {
+    const out = colors.reduce(function(input, color) {
+      return colorLib[color](input);
+    }, str);
+    return out;
+  };
+  var styleEachChar = (str, ...colors) => {
+    const chars = [...(0, import_strip_ansi.default)(str)];
+    const out = chars.reduce((prev, current) => {
+      const coded = colors.reduce((input, color) => {
+        return colorLib[color](input);
+      }, current);
+      return prev + coded;
+    }, "");
+    return out;
+  };
+  var resetStyle = function(str) {
+    this.configure({ reset: true });
+    return (0, import_strip_ansi.default)(str);
+  };
+  var colorizeCell = (str, cellOptions, rowType) => {
+    let color = false;
+    switch (true) {
+      case rowType === "body":
+        color = cellOptions.color || color;
+        break;
+      case rowType === "header":
+        color = cellOptions.headerColor || color;
+        break;
+      default:
+        color = cellOptions.footerColor || color;
+    }
+    if (color) {
+      str = style(str, color);
+    }
+    return str;
+  };
+  var isColorEnabled = () => {
+    return process && process.stdout ? colorLib.level > 0 : colorLib.enabled;
+  };
+
+  // src/format.ts
+  var import_strip_ansi2 = __toESM(require_strip_ansi());
+  var import_smartwrap = __toESM(require_main2());
+  var import_wcwidth = __toESM(require_wcwidth());
+  var addPadding = (config, width) => {
+    return width + config.paddingLeft + config.paddingRight;
+  };
+  var getMaxLength = (columnOptions, rows, columnIndex) => {
+    let iterable;
+    if (columnOptions && (columnOptions.value || columnOptions.alias)) {
+      let val = columnOptions.alias || columnOptions.value;
+      val = val.toString();
+      const headerRow = Array(rows[0].length);
+      headerRow[columnIndex] = val;
+      iterable = rows.slice();
+      iterable.push(headerRow);
+    } else {
+      iterable = rows;
+    }
+    const widest = iterable.reduce((prev, row) => {
+      if (row[columnIndex]) {
+        const value = row[columnIndex].value ? row[columnIndex].value : row[columnIndex];
+        const width = Math.max(
+          ...(0, import_strip_ansi2.default)(value.toString()).split(/[\n\r]/).map((s) => (0, import_wcwidth.default)(s))
+        );
+        return width > prev ? width : prev;
+      }
+      return prev;
+    }, 0);
+    return widest;
+  };
+  var getAvailableWidth = (config) => {
+    if (process && (process.stdout && process.stdout.columns || process.env && process.env.COLUMNS)) {
+      let viewport = process.stdout && process.stdout.columns ? process.stdout.columns : process.env.COLUMNS;
+      viewport = viewport - config.marginLeft;
+      if (config.width !== "auto" && /^\d+%$/.test(config.width)) {
+        return Math.min(1, config.width.slice(0, -1) * 0.01) * viewport;
+      }
+      if (config.width !== "auto" && /^\d+$/.test(config.width)) {
+        config.FIXED_WIDTH = true;
+        return config.width;
+      }
+      return viewport;
+    }
+    if (typeof globalThis.window !== "undefined") return globalThis.window.innerWidth;
+    return config.COLUMNS - config.marginLeft;
+  };
+  var getStringLength = (str) => {
+    return (0, import_wcwidth.default)((0, import_strip_ansi2.default)(str));
+  };
+  var wrapCellText = (config, cellValue, columnIndex, cellOptions, rowType) => {
+    const startAnsiRegexp = /^(\x1b\[[0-9;]*m)+/;
+    const endAnsiRegexp = /(\x1b\[[0-9;]*m)+$/;
+    let str = cellValue.toString();
+    const startMatches = str.match(startAnsiRegexp) || [""];
+    str = str.replace(startAnsiRegexp, "");
+    const endMatches = str.match(endAnsiRegexp) || [""];
+    str = str.replace(endAnsiRegexp, "");
+    let alignTgt;
+    switch (rowType) {
+      case "header":
+        alignTgt = "headerAlign";
+        break;
+      case "body":
+        alignTgt = "align";
+        break;
+      default:
+        alignTgt = "footerAlign";
+    }
+    if (cellOptions[alignTgt] === "center") {
+      cellOptions.paddingLeft = cellOptions.paddingRight = Math.max(
+        cellOptions.paddingRight,
+        cellOptions.paddingLeft,
+        0
+      );
+    }
+    const columnWidth = config.table.columnWidths[columnIndex];
+    const innerWidth = columnWidth - cellOptions.paddingLeft - cellOptions.paddingRight - config.GUTTER;
+    if (typeof config.truncate === "string") {
+      str = truncate(str, cellOptions, innerWidth);
+    } else {
+      str = wrap(str, cellOptions, innerWidth);
+    }
+    const cell = str.split("\n").map((line) => {
+      line = line.trim();
+      const lineLength = getStringLength(line);
+      if (lineLength < columnWidth) {
+        let emptySpace = columnWidth - lineLength;
+        switch (true) {
+          case cellOptions[alignTgt] === "center":
+            emptySpace--;
+            const padBoth = Math.floor(emptySpace / 2);
+            const padRemainder = emptySpace % 2;
+            line = Array(padBoth + 1).join(" ") + line + Array(padBoth + 1 + padRemainder).join(" ");
+            break;
+          case cellOptions[alignTgt] === "right":
+            line = Array(emptySpace - cellOptions.paddingRight).join(" ") + line + Array(cellOptions.paddingRight + 1).join(" ");
+            break;
+          default:
+            line = Array(cellOptions.paddingLeft + 1).join(" ") + line + Array(emptySpace - cellOptions.paddingLeft).join(" ");
+        }
+      }
+      return startMatches[0] + line + endMatches[0];
+    });
+    return { cell, innerWidth };
+  };
+  var truncate = (str, cellOptions, maxWidth) => {
+    const stringWidth = (0, import_wcwidth.default)(str);
+    if (maxWidth < stringWidth) {
+      str = (0, import_smartwrap.default)(str, {
+        width: maxWidth - cellOptions.truncate.length,
+        breakword: true
+      }).split("\n")[0];
+      str = str + cellOptions.truncate;
+    }
+    return str;
+  };
+  var wrap = (str, cellOptions, innerWidth) => {
+    const outstring = (0, import_smartwrap.default)(str, {
+      errorChar: cellOptions.defaultErrorValue,
+      minWidth: 1,
+      trim: true,
+      width: innerWidth
+    });
+    return outstring;
+  };
+  var getColumnWidths = (config, rows) => {
+    const availableWidth = getAvailableWidth(config);
+    const iterable = config.table.header[0] && config.table.header[0].length > 0 ? config.table.header[0] : rows[0];
+    let widths = iterable.map((column, columnIndex) => {
+      let result;
+      switch (true) {
+        // column width is a percentage of table width specified in column header
+        case (typeof column === "object" && /^\d+%$/.test(column.width)):
+          result = column.width.slice(0, -1) * 0.01 * availableWidth;
+          result = addPadding(config, result);
+          break;
+        // column width is specified in column header
+        case (typeof column === "object" && /^\d+$/.test(column.width)):
+          result = column.width;
+          break;
+        // 'auto' sets column width to its longest value in the initial data set
+        default: {
+          const columnOptions = config.table.header[0][columnIndex] ? config.table.header[0][columnIndex] : {};
+          const measurableRows = rows.length ? rows : config.table.header[0];
+          result = getMaxLength(columnOptions, measurableRows, columnIndex);
+          result = addPadding(config, result);
+        }
+      }
+      result = result + config.GUTTER;
+      return result;
+    });
+    const totalWidth = widths.reduce((prev, current) => prev + current);
+    if (totalWidth > availableWidth || config.FIXED_WIDTH) {
+      const proportion = (availableWidth / totalWidth).toFixed(2) - 0.01;
+      const relativeWidths = widths.map((value) => Math.max(2, Math.floor(proportion * value)));
+      if (config.FIXED_WIDTH) return relativeWidths;
+      if (proportion > 0) {
+        const totalRelativeWidths = relativeWidths.reduce((prev, current) => prev + current);
+        widths = totalRelativeWidths < totalWidth ? relativeWidths : widths;
+      }
+    } else {
+      widths = widths.map(Math.floor);
+    }
+    return widths;
+  };
+
+  // src/render.ts
+  var import_strip_ansi3 = __toESM(require_strip_ansi());
+  var stringifyData = (config, inputData) => {
+    const sections = {
+      header: [],
+      body: [],
+      footer: []
+    };
+    const marginLeft = Array(config.marginLeft + 1).join(" ");
+    const borderStyle = config.borderCharacters[config.borderStyle];
+    const borders = [];
+    const constructorType = getConstructorGeometry(inputData[0] || [], config);
+    const rows = coerceConstructorGeometry(config, inputData, constructorType);
+    if (!globalThis.columnWidths) {
+      globalThis.columnWidths = {};
+    }
+    if (globalThis.columnWidths[config.tableId]) {
+      config.table.columnWidths = globalThis.columnWidths[config.tableId];
+    } else {
+      const formattedRows = rows.map((row, rowIndex) => {
+        return row.map((cell, cellIndex) => {
+          return buildCell(config, cell, cellIndex, "body", rowIndex, rows, inputData, true);
+        });
+      });
+      globalThis.columnWidths[config.tableId] = config.table.columnWidths = getColumnWidths(config, formattedRows);
+    }
+    switch (true) {
+      case (config.showHeader !== null && !config.showHeader):
+        sections.header = [];
+        break;
+      case config.showHeader === true:
+      // explicitly true, show
+      case !!config.table.header[0].find((obj) => obj.value || obj.alias):
+        sections.header = config.table.header.map((row) => {
+          return buildRow(config, row, "header", null, rows, inputData);
+        });
+        break;
+      default:
+        sections.header = [];
+    }
+    sections.body = rows.map((row, rowIndex) => {
+      return buildRow(config, row, "body", rowIndex, rows, inputData);
+    });
+    sections.footer = config.table.footer instanceof Array && config.table.footer.length > 0 ? [config.table.footer] : [];
+    sections.footer = sections.footer.map((row) => {
+      return buildRow(config, row, "footer", null, rows, inputData);
+    });
+    for (let a = 0; a < 3; a++) {
+      borders[a] = borderStyle[a].l;
+      config.table.columnWidths.forEach((columnWidth, index, arr) => {
+        borders[a] += Array(Math.max(columnWidth, 2)).join(borderStyle[a].h);
+        borders[a] += index + 1 < arr.length ? borderStyle[a].j : "";
+      });
+      borders[a] += borderStyle[a].r;
+      borders[a] = a < 2 ? `${marginLeft + borders[a]}
+` : marginLeft + borders[a];
+    }
+    let output = borders[0];
+    Object.keys(sections).forEach((p, i) => {
+      while (sections[p].length) {
+        const row = sections[p].shift();
+        row.forEach((line) => {
+          output = `${output + marginLeft + borderStyle[1].v + line.join(borderStyle[1].v) + borderStyle[1].v}
+`;
+        });
+        switch (true) {
+          // skip if end of body and no footer
+          case (sections[p].length === 0 && i === 1 && sections.footer.length === 0):
+            break;
+          // skip if end of footer
+          case (sections[p].length === 0 && i === 2):
+            break;
+          // skip if compact
+          case (config.compact && p === "body" && !row.empty):
+            break;
+          // skip if border style is "none"
+          case (config.borderStyle === "none" && config.compact):
+            break;
+          default:
+            output += borders[1];
+        }
+      }
+    });
+    output += borders[2];
+    const finalOutput = Array(config.marginTop + 1).join("\n") + output;
+    config.height = finalOutput.split(/\r\n|\r|\n/).length;
+    return finalOutput;
+  };
+  var buildRow = (config, row, rowType, rowIndex, rowData, inputData) => {
+    let minRowHeight = 0;
+    if (row.length === 0 && config.compact) {
+      row.empty = true;
+      return row;
+    }
+    const lengthDifference = config.table.columnWidths.length - row.length;
+    if (lengthDifference > 0) {
+      row = row.concat(Array.apply(null, new Array(lengthDifference)).map(() => null));
+    } else if (lengthDifference < 0) {
+      row.length = config.table.columnWidths.length;
+    }
+    row = row.map((elem, elemIndex) => {
+      const cell = buildCell(config, elem, elemIndex, rowType, rowIndex, rowData, inputData);
+      minRowHeight = minRowHeight < cell.length ? cell.length : minRowHeight;
+      return cell;
+    });
+    minRowHeight = rowType === "header" ? minRowHeight : minRowHeight + (config.paddingBottom + config.paddingTop);
+    const linedRow = Array.apply(null, { length: minRowHeight }).map(Function.call, () => []);
+    row.forEach(function(cell, a) {
+      const whitespace = Array(config.table.columnWidths[a]).join(" ");
+      if (rowType === "body") {
+        for (let i = 0; i < config.paddingTop; i++) {
+          cell.unshift(whitespace);
+        }
+        for (let i = 0; i < config.paddingBottom; i++) {
+          cell.push(whitespace);
+        }
+      }
+      for (let i = 0; i < minRowHeight; i++) {
+        linedRow[i].push(typeof cell[i] !== "undefined" ? cell[i] : whitespace);
+      }
+    });
+    return linedRow;
+  };
+  var buildCell = (config, elem, columnIndex, rowType, rowIndex, rowData, inputData, dryRun = false) => {
+    let cellValue = null;
+    const cellOptions = Object.assign(
+      { reset: false },
+      config,
+      rowType !== "header" ? config.columnSettings[columnIndex] : {},
+      typeof elem === "object" ? elem : {}
+    );
+    if (rowType === "header") {
+      config.table.columns.push(cellOptions);
+      cellValue = cellOptions.alias || cellOptions.value || "";
+    } else {
+      switch (true) {
+        case (typeof elem === "undefined" || elem === null):
+          cellValue = config.errorOnNull ? config.defaultErrorValue : config.defaultValue;
+          if (!isColorEnabled()) {
+            cellValue = (0, import_strip_ansi3.default)(cellValue);
+          }
+          cellOptions.isNull = true;
+          break;
+        case (typeof elem === "object" && elem !== null && typeof elem.value !== "undefined"):
+          cellValue = elem.value;
+          break;
+        case typeof elem === "function":
+          cellValue = elem.bind({
+            configure: function(object) {
+              return Object.assign(cellOptions, object);
+            },
+            style,
+            resetStyle
+          })(
+            cellValue,
+            columnIndex,
+            rowIndex,
+            rowData,
+            inputData
+          );
+          break;
+        default:
+          cellValue = elem;
+      }
+      if (rowType === "body" && typeof cellOptions.formatter === "function") {
+        cellValue = cellOptions.formatter.bind({
+          configure: function(object) {
+            return Object.assign(cellOptions, object);
+          },
+          style,
+          resetStyle
+        })(
+          cellValue,
+          columnIndex,
+          rowIndex,
+          rowData,
+          inputData
+        );
+      }
+      if (dryRun) {
+        return cellValue;
+      }
+    }
+    if (!cellOptions.reset) {
+      cellValue = colorizeCell(cellValue, cellOptions, rowType);
+    }
+    const { cell, innerWidth } = wrapCellText(cellOptions, cellValue, columnIndex, cellOptions, rowType);
+    if (rowType === "header") {
+      config.table.columnInnerWidths.push(innerWidth);
+    }
+    return cell;
+  };
+  var getConstructorGeometry = (row, config) => {
+    let type;
+    if (typeof row === "object" && !(row instanceof Array)) {
+      const keys = Object.keys(row);
+      if (config.adapter === "automattic") {
+        const key = keys[0];
+        if (row[key] instanceof Array) {
+          type = "automattic-cross";
+        } else {
+          type = "automattic-vertical";
+        }
+      } else {
+        type = "o-horizontal";
+      }
+    } else {
+      type = "a-horizontal";
+    }
+    return type;
+  };
+  var coerceConstructorGeometry = (config, rows, constructorType) => {
+    let output = [];
+    switch (constructorType) {
+      case "automattic-cross":
+        config.columnSettings[0] = config.columnSettings[0] || {};
+        config.columnSettings[0].color = config.headerColor;
+        output = rows.map((obj) => {
+          const arr = [];
+          const key = Object.keys(obj)[0];
+          arr.push(key);
+          return arr.concat(obj[key]);
+        });
+        break;
+      case "automattic-vertical":
+        config.columnSettings[0] = config.columnSettings[0] || {};
+        config.columnSettings[0].color = config.headerColor;
+        output = rows.map(function(value) {
+          const key = Object.keys(value)[0];
+          return [key, value[key]];
+        });
+        break;
+      case "o-horizontal":
+        if (config.table.header[0].length && config.table.header[0].every((obj) => obj.value)) {
+          output = rows.map((row) => config.table.header[0].map((obj) => row[obj.value]));
+        } else {
+          output = rows.map((obj) => Object.values(obj));
+        }
+        break;
+      case "a-horizontal":
+        output = rows;
+        break;
+      default:
+    }
+    return output;
+  };
+
+  // src/factory.ts
+  var counter = 0;
+  var Factory = function(paramsArr) {
+    const _configKey = Symbol.config;
+    let header = [];
+    const body = [];
+    let footer = [];
+    let options = {};
+    switch (true) {
+      // header, rows, footer, and options
+      case paramsArr.length === 4:
+        header = paramsArr[0];
+        body.push(...paramsArr[1]);
+        footer = paramsArr[2];
+        options = paramsArr[3];
+        break;
+      // header, rows, footer
+      case (paramsArr.length === 3 && paramsArr[2] instanceof Array):
+        header = paramsArr[0];
+        body.push(...paramsArr[1]);
+        footer = paramsArr[2];
+        break;
+      // header, rows, options
+      case (paramsArr.length === 3 && typeof paramsArr[2] === "object"):
+        header = paramsArr[0];
+        body.push(...paramsArr[1]);
+        options = paramsArr[2];
+        break;
+      // header, rows            (rows, footer is not an option)
+      case (paramsArr.length === 2 && paramsArr[1] instanceof Array):
+        header = paramsArr[0];
+        body.push(...paramsArr[1]);
+        break;
+      // rows, options
+      case (paramsArr.length === 2 && typeof paramsArr[1] === "object"):
+        body.push(...paramsArr[0]);
+        options = paramsArr[1];
+        break;
+      // rows
+      case (paramsArr.length === 1 && paramsArr[0] instanceof Array):
+        body.push(...paramsArr[0]);
+        break;
+      // adapter called: i.e. `require('tty-table')('automattic-cli-table')`
+      case (paramsArr.length === 1 && typeof paramsArr[0] === "string"): {
+        const adapters = {
+          "automattic-cli-table": () => require_stub(),
+          "default-adapter": () => require_stub(),
+          "terminal-adapter": () => require_stub()
+        };
+        const load = adapters[paramsArr[0]];
+        if (!load) throw new Error(`Unknown adapter: "${paramsArr[0]}". Available adapters: ${Object.keys(adapters).join(", ")}`);
+        return load();
+      }
+      /* istanbul ignore next */
+      default:
+        console.log("Error: Bad params. \nSee docs at github.com/tecfu/tty-table");
+        process.exit();
+    }
+    const cloneddefaults = JSON.parse(JSON.stringify(defaults_default));
+    const config = Object.assign({}, cloneddefaults, options);
+    config.align = config.alignment || config.align;
+    config.headerAlign = config.headerAlignment || config.headerAlign;
+    if (config.truncate === true) config.truncate = "";
+    if (config.borderColor) {
+      config.borderCharacters[config.borderStyle] = config.borderCharacters[config.borderStyle].map(function(obj) {
+        Object.keys(obj).forEach(function(key) {
+          obj[key] = style(obj[key], config.borderColor);
+        });
+        return obj;
+      });
+    }
+    config.columnSettings = header.slice(0);
+    config.table.header = header;
+    config.table.header = [config.table.header];
+    config.table.footer = footer;
+    if (config.terminalAdapter !== true) {
+      counter++;
+    }
+    config.tableId = counter;
+    const tableObject = Object.create(body);
+    tableObject[_configKey] = config;
+    tableObject.render = function() {
+      const output = stringifyData(this[_configKey], this.slice(0));
+      tableObject.height = this[_configKey].height;
+      return output;
+    };
+    return tableObject;
+  };
+  var Table = function(...params) {
+    return Factory(params);
+  };
+  Table.resetStyle = resetStyle;
+  Table.style = styleEachChar;
+  var factory_default = Table;
+
+  // src/index.ts
+  var src_default = factory_default;
+  return __toCommonJS(browser_exports);
+})();
+//# sourceMappingURL=tty-table.global.js.map