DMleadgen
46d973904b
Next.js website for Rocky Mountain Vending company featuring: - Product catalog with Stripe integration - Service areas and parts pages - Admin dashboard with Clerk authentication - SEO optimized pages with JSON-LD structured data Co-authored-by: Cursor <cursoragent@cursor.com>
3991 lines
143 KiB
Text
3991 lines
143 KiB
Text
// @ts-nocheck
|
|
/* eslint-disable */
|
|
|
|
// Copyright 2025 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
// Exclude the parts of extras.ts that have painful dependencies. Include these cuz they don't and are needed.
|
|
export * as ScriptDuplication from './ScriptDuplication.js';
|
|
export * as StackTraceForEvent from './StackTraceForEvent.js';
|
|
export * as ThirdParties from './ThirdParties.js';
|
|
export * as TraceFilter from './TraceFilter.js';
|
|
export * as TraceTree from './TraceTree.js';
|
|
|
|
|
|
// The rest of this file is a polyfill :)
|
|
// Remove once Lighthouse drops Node 18 support.
|
|
|
|
// npx esbuild tmp.js --bundle
|
|
//
|
|
// where tmp.js is:
|
|
//
|
|
// import 'es-iterator-helpers/Iterator.prototype.find/auto';
|
|
// import 'es-iterator-helpers/Iterator.prototype.flatMap/auto';
|
|
// import 'es-iterator-helpers/Iterator.prototype.map/auto';
|
|
// import 'es-iterator-helpers/Iterator.prototype.reduce/auto';
|
|
// import 'es-iterator-helpers/Iterator.prototype.toArray/auto';
|
|
|
|
"use strict";
|
|
(() => {
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
|
|
// 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 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 = 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 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/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/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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// (disabled):node_modules/object-inspect/util.inspect
|
|
var require_util = __commonJS({
|
|
"(disabled):node_modules/object-inspect/util.inspect"() {
|
|
}
|
|
});
|
|
|
|
// node_modules/object-inspect/index.js
|
|
var require_object_inspect = __commonJS({
|
|
"node_modules/object-inspect/index.js"(exports, module) {
|
|
var hasMap = typeof Map === "function" && Map.prototype;
|
|
var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null;
|
|
var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null;
|
|
var mapForEach = hasMap && Map.prototype.forEach;
|
|
var hasSet = typeof Set === "function" && Set.prototype;
|
|
var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null;
|
|
var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function" ? setSizeDescriptor.get : null;
|
|
var setForEach = hasSet && Set.prototype.forEach;
|
|
var hasWeakMap = typeof WeakMap === "function" && WeakMap.prototype;
|
|
var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
|
|
var hasWeakSet = typeof WeakSet === "function" && WeakSet.prototype;
|
|
var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
|
|
var hasWeakRef = typeof WeakRef === "function" && WeakRef.prototype;
|
|
var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
|
|
var booleanValueOf = Boolean.prototype.valueOf;
|
|
var objectToString = Object.prototype.toString;
|
|
var functionToString = Function.prototype.toString;
|
|
var $match = String.prototype.match;
|
|
var $slice = String.prototype.slice;
|
|
var $replace = String.prototype.replace;
|
|
var $toUpperCase = String.prototype.toUpperCase;
|
|
var $toLowerCase = String.prototype.toLowerCase;
|
|
var $test = RegExp.prototype.test;
|
|
var $concat = Array.prototype.concat;
|
|
var $join = Array.prototype.join;
|
|
var $arrSlice = Array.prototype.slice;
|
|
var $floor = Math.floor;
|
|
var bigIntValueOf = typeof BigInt === "function" ? BigInt.prototype.valueOf : null;
|
|
var gOPS = Object.getOwnPropertySymbols;
|
|
var symToString = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol.prototype.toString : null;
|
|
var hasShammedSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "object";
|
|
var toStringTag = typeof Symbol === "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol") ? Symbol.toStringTag : null;
|
|
var isEnumerable = Object.prototype.propertyIsEnumerable;
|
|
var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {
|
|
return O.__proto__;
|
|
} : null);
|
|
function addNumericSeparator(num, str) {
|
|
if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) {
|
|
return str;
|
|
}
|
|
var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
|
|
if (typeof num === "number") {
|
|
var int = num < 0 ? -$floor(-num) : $floor(num);
|
|
if (int !== num) {
|
|
var intStr = String(int);
|
|
var dec = $slice.call(str, intStr.length + 1);
|
|
return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, "");
|
|
}
|
|
}
|
|
return $replace.call(str, sepRegex, "$&_");
|
|
}
|
|
var utilInspect = require_util();
|
|
var inspectCustom = utilInspect.custom;
|
|
var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
|
|
var quotes = {
|
|
__proto__: null,
|
|
"double": '"',
|
|
single: "'"
|
|
};
|
|
var quoteREs = {
|
|
__proto__: null,
|
|
"double": /(["\\])/g,
|
|
single: /(['\\])/g
|
|
};
|
|
module.exports = function inspect_(obj, options, depth, seen) {
|
|
var opts = options || {};
|
|
if (has(opts, "quoteStyle") && !has(quotes, opts.quoteStyle)) {
|
|
throw new TypeError('option "quoteStyle" must be "single" or "double"');
|
|
}
|
|
if (has(opts, "maxStringLength") && (typeof opts.maxStringLength === "number" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) {
|
|
throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
|
|
}
|
|
var customInspect = has(opts, "customInspect") ? opts.customInspect : true;
|
|
if (typeof customInspect !== "boolean" && customInspect !== "symbol") {
|
|
throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");
|
|
}
|
|
if (has(opts, "indent") && opts.indent !== null && opts.indent !== " " && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) {
|
|
throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
|
|
}
|
|
if (has(opts, "numericSeparator") && typeof opts.numericSeparator !== "boolean") {
|
|
throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
|
|
}
|
|
var numericSeparator = opts.numericSeparator;
|
|
if (typeof obj === "undefined") {
|
|
return "undefined";
|
|
}
|
|
if (obj === null) {
|
|
return "null";
|
|
}
|
|
if (typeof obj === "boolean") {
|
|
return obj ? "true" : "false";
|
|
}
|
|
if (typeof obj === "string") {
|
|
return inspectString(obj, opts);
|
|
}
|
|
if (typeof obj === "number") {
|
|
if (obj === 0) {
|
|
return Infinity / obj > 0 ? "0" : "-0";
|
|
}
|
|
var str = String(obj);
|
|
return numericSeparator ? addNumericSeparator(obj, str) : str;
|
|
}
|
|
if (typeof obj === "bigint") {
|
|
var bigIntStr = String(obj) + "n";
|
|
return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
|
|
}
|
|
var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth;
|
|
if (typeof depth === "undefined") {
|
|
depth = 0;
|
|
}
|
|
if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") {
|
|
return isArray(obj) ? "[Array]" : "[Object]";
|
|
}
|
|
var indent = getIndent(opts, depth);
|
|
if (typeof seen === "undefined") {
|
|
seen = [];
|
|
} else if (indexOf(seen, obj) >= 0) {
|
|
return "[Circular]";
|
|
}
|
|
function inspect(value, from, noIndent) {
|
|
if (from) {
|
|
seen = $arrSlice.call(seen);
|
|
seen.push(from);
|
|
}
|
|
if (noIndent) {
|
|
var newOpts = {
|
|
depth: opts.depth
|
|
};
|
|
if (has(opts, "quoteStyle")) {
|
|
newOpts.quoteStyle = opts.quoteStyle;
|
|
}
|
|
return inspect_(value, newOpts, depth + 1, seen);
|
|
}
|
|
return inspect_(value, opts, depth + 1, seen);
|
|
}
|
|
if (typeof obj === "function" && !isRegExp(obj)) {
|
|
var name = nameOf(obj);
|
|
var keys = arrObjKeys(obj, inspect);
|
|
return "[Function" + (name ? ": " + name : " (anonymous)") + "]" + (keys.length > 0 ? " { " + $join.call(keys, ", ") + " }" : "");
|
|
}
|
|
if (isSymbol(obj)) {
|
|
var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj);
|
|
return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString;
|
|
}
|
|
if (isElement(obj)) {
|
|
var s = "<" + $toLowerCase.call(String(obj.nodeName));
|
|
var attrs = obj.attributes || [];
|
|
for (var i = 0; i < attrs.length; i++) {
|
|
s += " " + attrs[i].name + "=" + wrapQuotes(quote(attrs[i].value), "double", opts);
|
|
}
|
|
s += ">";
|
|
if (obj.childNodes && obj.childNodes.length) {
|
|
s += "...";
|
|
}
|
|
s += "</" + $toLowerCase.call(String(obj.nodeName)) + ">";
|
|
return s;
|
|
}
|
|
if (isArray(obj)) {
|
|
if (obj.length === 0) {
|
|
return "[]";
|
|
}
|
|
var xs = arrObjKeys(obj, inspect);
|
|
if (indent && !singleLineValues(xs)) {
|
|
return "[" + indentedJoin(xs, indent) + "]";
|
|
}
|
|
return "[ " + $join.call(xs, ", ") + " ]";
|
|
}
|
|
if (isError(obj)) {
|
|
var parts = arrObjKeys(obj, inspect);
|
|
if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) {
|
|
return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect(obj.cause), parts), ", ") + " }";
|
|
}
|
|
if (parts.length === 0) {
|
|
return "[" + String(obj) + "]";
|
|
}
|
|
return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }";
|
|
}
|
|
if (typeof obj === "object" && customInspect) {
|
|
if (inspectSymbol && typeof obj[inspectSymbol] === "function" && utilInspect) {
|
|
return utilInspect(obj, { depth: maxDepth - depth });
|
|
} else if (customInspect !== "symbol" && typeof obj.inspect === "function") {
|
|
return obj.inspect();
|
|
}
|
|
}
|
|
if (isMap(obj)) {
|
|
var mapParts = [];
|
|
if (mapForEach) {
|
|
mapForEach.call(obj, function(value, key) {
|
|
mapParts.push(inspect(key, obj, true) + " => " + inspect(value, obj));
|
|
});
|
|
}
|
|
return collectionOf("Map", mapSize.call(obj), mapParts, indent);
|
|
}
|
|
if (isSet(obj)) {
|
|
var setParts = [];
|
|
if (setForEach) {
|
|
setForEach.call(obj, function(value) {
|
|
setParts.push(inspect(value, obj));
|
|
});
|
|
}
|
|
return collectionOf("Set", setSize.call(obj), setParts, indent);
|
|
}
|
|
if (isWeakMap(obj)) {
|
|
return weakCollectionOf("WeakMap");
|
|
}
|
|
if (isWeakSet(obj)) {
|
|
return weakCollectionOf("WeakSet");
|
|
}
|
|
if (isWeakRef(obj)) {
|
|
return weakCollectionOf("WeakRef");
|
|
}
|
|
if (isNumber(obj)) {
|
|
return markBoxed(inspect(Number(obj)));
|
|
}
|
|
if (isBigInt(obj)) {
|
|
return markBoxed(inspect(bigIntValueOf.call(obj)));
|
|
}
|
|
if (isBoolean(obj)) {
|
|
return markBoxed(booleanValueOf.call(obj));
|
|
}
|
|
if (isString(obj)) {
|
|
return markBoxed(inspect(String(obj)));
|
|
}
|
|
if (typeof window !== "undefined" && obj === window) {
|
|
return "{ [object Window] }";
|
|
}
|
|
if (typeof globalThis !== "undefined" && obj === globalThis || typeof global !== "undefined" && obj === global) {
|
|
return "{ [object globalThis] }";
|
|
}
|
|
if (!isDate(obj) && !isRegExp(obj)) {
|
|
var ys = arrObjKeys(obj, inspect);
|
|
var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
|
|
var protoTag = obj instanceof Object ? "" : "null prototype";
|
|
var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
|
|
var constructorTag = isPlainObject || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
|
|
var tag = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
|
|
if (ys.length === 0) {
|
|
return tag + "{}";
|
|
}
|
|
if (indent) {
|
|
return tag + "{" + indentedJoin(ys, indent) + "}";
|
|
}
|
|
return tag + "{ " + $join.call(ys, ", ") + " }";
|
|
}
|
|
return String(obj);
|
|
};
|
|
function wrapQuotes(s, defaultStyle, opts) {
|
|
var style = opts.quoteStyle || defaultStyle;
|
|
var quoteChar = quotes[style];
|
|
return quoteChar + s + quoteChar;
|
|
}
|
|
function quote(s) {
|
|
return $replace.call(String(s), /"/g, """);
|
|
}
|
|
function canTrustToString(obj) {
|
|
return !toStringTag || !(typeof obj === "object" && (toStringTag in obj || typeof obj[toStringTag] !== "undefined"));
|
|
}
|
|
function isArray(obj) {
|
|
return toStr(obj) === "[object Array]" && canTrustToString(obj);
|
|
}
|
|
function isDate(obj) {
|
|
return toStr(obj) === "[object Date]" && canTrustToString(obj);
|
|
}
|
|
function isRegExp(obj) {
|
|
return toStr(obj) === "[object RegExp]" && canTrustToString(obj);
|
|
}
|
|
function isError(obj) {
|
|
return toStr(obj) === "[object Error]" && canTrustToString(obj);
|
|
}
|
|
function isString(obj) {
|
|
return toStr(obj) === "[object String]" && canTrustToString(obj);
|
|
}
|
|
function isNumber(obj) {
|
|
return toStr(obj) === "[object Number]" && canTrustToString(obj);
|
|
}
|
|
function isBoolean(obj) {
|
|
return toStr(obj) === "[object Boolean]" && canTrustToString(obj);
|
|
}
|
|
function isSymbol(obj) {
|
|
if (hasShammedSymbols) {
|
|
return obj && typeof obj === "object" && obj instanceof Symbol;
|
|
}
|
|
if (typeof obj === "symbol") {
|
|
return true;
|
|
}
|
|
if (!obj || typeof obj !== "object" || !symToString) {
|
|
return false;
|
|
}
|
|
try {
|
|
symToString.call(obj);
|
|
return true;
|
|
} catch (e) {
|
|
}
|
|
return false;
|
|
}
|
|
function isBigInt(obj) {
|
|
if (!obj || typeof obj !== "object" || !bigIntValueOf) {
|
|
return false;
|
|
}
|
|
try {
|
|
bigIntValueOf.call(obj);
|
|
return true;
|
|
} catch (e) {
|
|
}
|
|
return false;
|
|
}
|
|
var hasOwn = Object.prototype.hasOwnProperty || function(key) {
|
|
return key in this;
|
|
};
|
|
function has(obj, key) {
|
|
return hasOwn.call(obj, key);
|
|
}
|
|
function toStr(obj) {
|
|
return objectToString.call(obj);
|
|
}
|
|
function nameOf(f) {
|
|
if (f.name) {
|
|
return f.name;
|
|
}
|
|
var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
|
|
if (m) {
|
|
return m[1];
|
|
}
|
|
return null;
|
|
}
|
|
function indexOf(xs, x) {
|
|
if (xs.indexOf) {
|
|
return xs.indexOf(x);
|
|
}
|
|
for (var i = 0, l = xs.length; i < l; i++) {
|
|
if (xs[i] === x) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function isMap(x) {
|
|
if (!mapSize || !x || typeof x !== "object") {
|
|
return false;
|
|
}
|
|
try {
|
|
mapSize.call(x);
|
|
try {
|
|
setSize.call(x);
|
|
} catch (s) {
|
|
return true;
|
|
}
|
|
return x instanceof Map;
|
|
} catch (e) {
|
|
}
|
|
return false;
|
|
}
|
|
function isWeakMap(x) {
|
|
if (!weakMapHas || !x || typeof x !== "object") {
|
|
return false;
|
|
}
|
|
try {
|
|
weakMapHas.call(x, weakMapHas);
|
|
try {
|
|
weakSetHas.call(x, weakSetHas);
|
|
} catch (s) {
|
|
return true;
|
|
}
|
|
return x instanceof WeakMap;
|
|
} catch (e) {
|
|
}
|
|
return false;
|
|
}
|
|
function isWeakRef(x) {
|
|
if (!weakRefDeref || !x || typeof x !== "object") {
|
|
return false;
|
|
}
|
|
try {
|
|
weakRefDeref.call(x);
|
|
return true;
|
|
} catch (e) {
|
|
}
|
|
return false;
|
|
}
|
|
function isSet(x) {
|
|
if (!setSize || !x || typeof x !== "object") {
|
|
return false;
|
|
}
|
|
try {
|
|
setSize.call(x);
|
|
try {
|
|
mapSize.call(x);
|
|
} catch (m) {
|
|
return true;
|
|
}
|
|
return x instanceof Set;
|
|
} catch (e) {
|
|
}
|
|
return false;
|
|
}
|
|
function isWeakSet(x) {
|
|
if (!weakSetHas || !x || typeof x !== "object") {
|
|
return false;
|
|
}
|
|
try {
|
|
weakSetHas.call(x, weakSetHas);
|
|
try {
|
|
weakMapHas.call(x, weakMapHas);
|
|
} catch (s) {
|
|
return true;
|
|
}
|
|
return x instanceof WeakSet;
|
|
} catch (e) {
|
|
}
|
|
return false;
|
|
}
|
|
function isElement(x) {
|
|
if (!x || typeof x !== "object") {
|
|
return false;
|
|
}
|
|
if (typeof HTMLElement !== "undefined" && x instanceof HTMLElement) {
|
|
return true;
|
|
}
|
|
return typeof x.nodeName === "string" && typeof x.getAttribute === "function";
|
|
}
|
|
function inspectString(str, opts) {
|
|
if (str.length > opts.maxStringLength) {
|
|
var remaining = str.length - opts.maxStringLength;
|
|
var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : "");
|
|
return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;
|
|
}
|
|
var quoteRE = quoteREs[opts.quoteStyle || "single"];
|
|
quoteRE.lastIndex = 0;
|
|
var s = $replace.call($replace.call(str, quoteRE, "\\$1"), /[\x00-\x1f]/g, lowbyte);
|
|
return wrapQuotes(s, "single", opts);
|
|
}
|
|
function lowbyte(c) {
|
|
var n = c.charCodeAt(0);
|
|
var x = {
|
|
8: "b",
|
|
9: "t",
|
|
10: "n",
|
|
12: "f",
|
|
13: "r"
|
|
}[n];
|
|
if (x) {
|
|
return "\\" + x;
|
|
}
|
|
return "\\x" + (n < 16 ? "0" : "") + $toUpperCase.call(n.toString(16));
|
|
}
|
|
function markBoxed(str) {
|
|
return "Object(" + str + ")";
|
|
}
|
|
function weakCollectionOf(type) {
|
|
return type + " { ? }";
|
|
}
|
|
function collectionOf(type, size, entries, indent) {
|
|
var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", ");
|
|
return type + " (" + size + ") {" + joinedEntries + "}";
|
|
}
|
|
function singleLineValues(xs) {
|
|
for (var i = 0; i < xs.length; i++) {
|
|
if (indexOf(xs[i], "\n") >= 0) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function getIndent(opts, depth) {
|
|
var baseIndent;
|
|
if (opts.indent === " ") {
|
|
baseIndent = " ";
|
|
} else if (typeof opts.indent === "number" && opts.indent > 0) {
|
|
baseIndent = $join.call(Array(opts.indent + 1), " ");
|
|
} else {
|
|
return null;
|
|
}
|
|
return {
|
|
base: baseIndent,
|
|
prev: $join.call(Array(depth + 1), baseIndent)
|
|
};
|
|
}
|
|
function indentedJoin(xs, indent) {
|
|
if (xs.length === 0) {
|
|
return "";
|
|
}
|
|
var lineJoiner = "\n" + indent.prev + indent.base;
|
|
return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent.prev;
|
|
}
|
|
function arrObjKeys(obj, inspect) {
|
|
var isArr = isArray(obj);
|
|
var xs = [];
|
|
if (isArr) {
|
|
xs.length = obj.length;
|
|
for (var i = 0; i < obj.length; i++) {
|
|
xs[i] = has(obj, i) ? inspect(obj[i], obj) : "";
|
|
}
|
|
}
|
|
var syms = typeof gOPS === "function" ? gOPS(obj) : [];
|
|
var symMap;
|
|
if (hasShammedSymbols) {
|
|
symMap = {};
|
|
for (var k = 0; k < syms.length; k++) {
|
|
symMap["$" + syms[k]] = syms[k];
|
|
}
|
|
}
|
|
for (var key in obj) {
|
|
if (!has(obj, key)) {
|
|
continue;
|
|
}
|
|
if (isArr && String(Number(key)) === key && key < obj.length) {
|
|
continue;
|
|
}
|
|
if (hasShammedSymbols && symMap["$" + key] instanceof Symbol) {
|
|
continue;
|
|
} else if ($test.call(/[^\w$]/, key)) {
|
|
xs.push(inspect(key, obj) + ": " + inspect(obj[key], obj));
|
|
} else {
|
|
xs.push(key + ": " + inspect(obj[key], obj));
|
|
}
|
|
}
|
|
if (typeof gOPS === "function") {
|
|
for (var j = 0; j < syms.length; j++) {
|
|
if (isEnumerable.call(obj, syms[j])) {
|
|
xs.push("[" + inspect(syms[j]) + "]: " + inspect(obj[syms[j]], obj));
|
|
}
|
|
}
|
|
}
|
|
return xs;
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/helpers/isObject.js
|
|
var require_isObject = __commonJS({
|
|
"node_modules/es-abstract/helpers/isObject.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function isObject(x) {
|
|
return !!x && (typeof x === "function" || typeof x === "object");
|
|
};
|
|
}
|
|
});
|
|
|
|
// 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_object_inspect();
|
|
var isObject = require_isObject();
|
|
var isPropertyKey = require_isPropertyKey();
|
|
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/es-abstract/5/Type.js
|
|
var require_Type = __commonJS({
|
|
"node_modules/es-abstract/5/Type.js"(exports, module) {
|
|
"use strict";
|
|
var isObject = require_isObject();
|
|
module.exports = function Type(x) {
|
|
if (x === null) {
|
|
return "Null";
|
|
}
|
|
if (typeof x === "undefined") {
|
|
return "Undefined";
|
|
}
|
|
if (isObject(x)) {
|
|
return "Object";
|
|
}
|
|
if (typeof x === "number") {
|
|
return "Number";
|
|
}
|
|
if (typeof x === "boolean") {
|
|
return "Boolean";
|
|
}
|
|
if (typeof x === "string") {
|
|
return "String";
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/Type.js
|
|
var require_Type2 = __commonJS({
|
|
"node_modules/es-abstract/2024/Type.js"(exports, module) {
|
|
"use strict";
|
|
var ES5Type = require_Type();
|
|
module.exports = function Type(x) {
|
|
if (typeof x === "symbol") {
|
|
return "Symbol";
|
|
}
|
|
if (typeof x === "bigint") {
|
|
return "BigInt";
|
|
}
|
|
return ES5Type(x);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/aos/GetIteratorDirect.js
|
|
var require_GetIteratorDirect = __commonJS({
|
|
"node_modules/es-iterator-helpers/aos/GetIteratorDirect.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var Get = require_Get();
|
|
var Type = require_Type2();
|
|
module.exports = function GetIteratorDirect(obj) {
|
|
if (Type(obj) !== "Object") {
|
|
throw new $TypeError("Assertion failed: `obj` must be an Object");
|
|
}
|
|
var nextMethod = Get(obj, "next");
|
|
var iteratorRecord = { "[[Iterator]]": obj, "[[NextMethod]]": nextMethod, "[[Done]]": false };
|
|
return iteratorRecord;
|
|
};
|
|
}
|
|
});
|
|
|
|
// 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/side-channel-list/index.js
|
|
var require_side_channel_list = __commonJS({
|
|
"node_modules/side-channel-list/index.js"(exports, module) {
|
|
"use strict";
|
|
var inspect = require_object_inspect();
|
|
var $TypeError = require_type();
|
|
var listGetNode = function(list, key, isDelete) {
|
|
var prev = list;
|
|
var curr;
|
|
for (; (curr = prev.next) != null; prev = curr) {
|
|
if (curr.key === key) {
|
|
prev.next = curr.next;
|
|
if (!isDelete) {
|
|
curr.next = /** @type {NonNullable<typeof list.next>} */
|
|
list.next;
|
|
list.next = curr;
|
|
}
|
|
return curr;
|
|
}
|
|
}
|
|
};
|
|
var listGet = function(objects, key) {
|
|
if (!objects) {
|
|
return void 0;
|
|
}
|
|
var node = listGetNode(objects, key);
|
|
return node && node.value;
|
|
};
|
|
var listSet = function(objects, key, value) {
|
|
var node = listGetNode(objects, key);
|
|
if (node) {
|
|
node.value = value;
|
|
} else {
|
|
objects.next = /** @type {import('./list.d.ts').ListNode<typeof value, typeof key>} */
|
|
{
|
|
// eslint-disable-line no-param-reassign, no-extra-parens
|
|
key,
|
|
next: objects.next,
|
|
value
|
|
};
|
|
}
|
|
};
|
|
var listHas = function(objects, key) {
|
|
if (!objects) {
|
|
return false;
|
|
}
|
|
return !!listGetNode(objects, key);
|
|
};
|
|
var listDelete = function(objects, key) {
|
|
if (objects) {
|
|
return listGetNode(objects, key, true);
|
|
}
|
|
};
|
|
module.exports = function getSideChannelList() {
|
|
var $o;
|
|
var channel = {
|
|
assert: function(key) {
|
|
if (!channel.has(key)) {
|
|
throw new $TypeError("Side channel does not contain " + inspect(key));
|
|
}
|
|
},
|
|
"delete": function(key) {
|
|
var root = $o && $o.next;
|
|
var deletedNode = listDelete($o, key);
|
|
if (deletedNode && root && root === deletedNode) {
|
|
$o = void 0;
|
|
}
|
|
return !!deletedNode;
|
|
},
|
|
get: function(key) {
|
|
return listGet($o, key);
|
|
},
|
|
has: function(key) {
|
|
return listHas($o, key);
|
|
},
|
|
set: function(key, value) {
|
|
if (!$o) {
|
|
$o = {
|
|
next: void 0
|
|
};
|
|
}
|
|
listSet(
|
|
/** @type {NonNullable<typeof $o>} */
|
|
$o,
|
|
key,
|
|
value
|
|
);
|
|
}
|
|
};
|
|
return channel;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/side-channel-map/index.js
|
|
var require_side_channel_map = __commonJS({
|
|
"node_modules/side-channel-map/index.js"(exports, module) {
|
|
"use strict";
|
|
var GetIntrinsic = require_get_intrinsic();
|
|
var callBound = require_call_bound();
|
|
var inspect = require_object_inspect();
|
|
var $TypeError = require_type();
|
|
var $Map = GetIntrinsic("%Map%", true);
|
|
var $mapGet = callBound("Map.prototype.get", true);
|
|
var $mapSet = callBound("Map.prototype.set", true);
|
|
var $mapHas = callBound("Map.prototype.has", true);
|
|
var $mapDelete = callBound("Map.prototype.delete", true);
|
|
var $mapSize = callBound("Map.prototype.size", true);
|
|
module.exports = !!$Map && /** @type {Exclude<import('.'), false>} */
|
|
function getSideChannelMap() {
|
|
var $m;
|
|
var channel = {
|
|
assert: function(key) {
|
|
if (!channel.has(key)) {
|
|
throw new $TypeError("Side channel does not contain " + inspect(key));
|
|
}
|
|
},
|
|
"delete": function(key) {
|
|
if ($m) {
|
|
var result = $mapDelete($m, key);
|
|
if ($mapSize($m) === 0) {
|
|
$m = void 0;
|
|
}
|
|
return result;
|
|
}
|
|
return false;
|
|
},
|
|
get: function(key) {
|
|
if ($m) {
|
|
return $mapGet($m, key);
|
|
}
|
|
},
|
|
has: function(key) {
|
|
if ($m) {
|
|
return $mapHas($m, key);
|
|
}
|
|
return false;
|
|
},
|
|
set: function(key, value) {
|
|
if (!$m) {
|
|
$m = new $Map();
|
|
}
|
|
$mapSet($m, key, value);
|
|
}
|
|
};
|
|
return channel;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/side-channel-weakmap/index.js
|
|
var require_side_channel_weakmap = __commonJS({
|
|
"node_modules/side-channel-weakmap/index.js"(exports, module) {
|
|
"use strict";
|
|
var GetIntrinsic = require_get_intrinsic();
|
|
var callBound = require_call_bound();
|
|
var inspect = require_object_inspect();
|
|
var getSideChannelMap = require_side_channel_map();
|
|
var $TypeError = require_type();
|
|
var $WeakMap = GetIntrinsic("%WeakMap%", true);
|
|
var $weakMapGet = callBound("WeakMap.prototype.get", true);
|
|
var $weakMapSet = callBound("WeakMap.prototype.set", true);
|
|
var $weakMapHas = callBound("WeakMap.prototype.has", true);
|
|
var $weakMapDelete = callBound("WeakMap.prototype.delete", true);
|
|
module.exports = $WeakMap ? (
|
|
/** @type {Exclude<import('.'), false>} */
|
|
function getSideChannelWeakMap() {
|
|
var $wm;
|
|
var $m;
|
|
var channel = {
|
|
assert: function(key) {
|
|
if (!channel.has(key)) {
|
|
throw new $TypeError("Side channel does not contain " + inspect(key));
|
|
}
|
|
},
|
|
"delete": function(key) {
|
|
if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
|
|
if ($wm) {
|
|
return $weakMapDelete($wm, key);
|
|
}
|
|
} else if (getSideChannelMap) {
|
|
if ($m) {
|
|
return $m["delete"](key);
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
get: function(key) {
|
|
if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
|
|
if ($wm) {
|
|
return $weakMapGet($wm, key);
|
|
}
|
|
}
|
|
return $m && $m.get(key);
|
|
},
|
|
has: function(key) {
|
|
if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
|
|
if ($wm) {
|
|
return $weakMapHas($wm, key);
|
|
}
|
|
}
|
|
return !!$m && $m.has(key);
|
|
},
|
|
set: function(key, value) {
|
|
if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
|
|
if (!$wm) {
|
|
$wm = new $WeakMap();
|
|
}
|
|
$weakMapSet($wm, key, value);
|
|
} else if (getSideChannelMap) {
|
|
if (!$m) {
|
|
$m = getSideChannelMap();
|
|
}
|
|
$m.set(key, value);
|
|
}
|
|
}
|
|
};
|
|
return channel;
|
|
}
|
|
) : getSideChannelMap;
|
|
}
|
|
});
|
|
|
|
// node_modules/side-channel/index.js
|
|
var require_side_channel = __commonJS({
|
|
"node_modules/side-channel/index.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var inspect = require_object_inspect();
|
|
var getSideChannelList = require_side_channel_list();
|
|
var getSideChannelMap = require_side_channel_map();
|
|
var getSideChannelWeakMap = require_side_channel_weakmap();
|
|
var makeChannel = getSideChannelWeakMap || getSideChannelMap || getSideChannelList;
|
|
module.exports = function getSideChannel() {
|
|
var $channelData;
|
|
var channel = {
|
|
assert: function(key) {
|
|
if (!channel.has(key)) {
|
|
throw new $TypeError("Side channel does not contain " + inspect(key));
|
|
}
|
|
},
|
|
"delete": function(key) {
|
|
return !!$channelData && $channelData["delete"](key);
|
|
},
|
|
get: function(key) {
|
|
return $channelData && $channelData.get(key);
|
|
},
|
|
has: function(key) {
|
|
return !!$channelData && $channelData.has(key);
|
|
},
|
|
set: function(key, value) {
|
|
if (!$channelData) {
|
|
$channelData = makeChannel();
|
|
}
|
|
$channelData.set(key, value);
|
|
}
|
|
};
|
|
return channel;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/internal-slot/index.js
|
|
var require_internal_slot = __commonJS({
|
|
"node_modules/internal-slot/index.js"(exports, module) {
|
|
"use strict";
|
|
var hasOwn = require_hasown();
|
|
var channel = require_side_channel()();
|
|
var $TypeError = require_type();
|
|
var SLOT = {
|
|
assert: function(O, slot) {
|
|
if (!O || typeof O !== "object" && typeof O !== "function") {
|
|
throw new $TypeError("`O` is not an object");
|
|
}
|
|
if (typeof slot !== "string") {
|
|
throw new $TypeError("`slot` must be a string");
|
|
}
|
|
channel.assert(O);
|
|
if (!SLOT.has(O, slot)) {
|
|
throw new $TypeError("`" + slot + "` is not present on `O`");
|
|
}
|
|
},
|
|
get: function(O, slot) {
|
|
if (!O || typeof O !== "object" && typeof O !== "function") {
|
|
throw new $TypeError("`O` is not an object");
|
|
}
|
|
if (typeof slot !== "string") {
|
|
throw new $TypeError("`slot` must be a string");
|
|
}
|
|
var slots = channel.get(O);
|
|
return slots && slots[
|
|
/** @type {SaltedInternalSlot} */
|
|
"$" + slot
|
|
];
|
|
},
|
|
has: function(O, slot) {
|
|
if (!O || typeof O !== "object" && typeof O !== "function") {
|
|
throw new $TypeError("`O` is not an object");
|
|
}
|
|
if (typeof slot !== "string") {
|
|
throw new $TypeError("`slot` must be a string");
|
|
}
|
|
var slots = channel.get(O);
|
|
return !!slots && hasOwn(
|
|
slots,
|
|
/** @type {SaltedInternalSlot} */
|
|
"$" + slot
|
|
);
|
|
},
|
|
set: function(O, slot, V) {
|
|
if (!O || typeof O !== "object" && typeof O !== "function") {
|
|
throw new $TypeError("`O` is not an object");
|
|
}
|
|
if (typeof slot !== "string") {
|
|
throw new $TypeError("`slot` must be a string");
|
|
}
|
|
var slots = channel.get(O);
|
|
if (!slots) {
|
|
slots = {};
|
|
channel.set(O, slots);
|
|
}
|
|
slots[
|
|
/** @type {SaltedInternalSlot} */
|
|
"$" + slot
|
|
] = V;
|
|
}
|
|
};
|
|
if (Object.freeze) {
|
|
Object.freeze(SLOT);
|
|
}
|
|
module.exports = SLOT;
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/CompletionRecord.js
|
|
var require_CompletionRecord = __commonJS({
|
|
"node_modules/es-abstract/2024/CompletionRecord.js"(exports, module) {
|
|
"use strict";
|
|
var $SyntaxError = require_syntax();
|
|
var SLOT = require_internal_slot();
|
|
var CompletionRecord = function CompletionRecord2(type, value) {
|
|
if (!(this instanceof CompletionRecord2)) {
|
|
return new CompletionRecord2(type, value);
|
|
}
|
|
if (type !== "normal" && type !== "break" && type !== "continue" && type !== "return" && type !== "throw") {
|
|
throw new $SyntaxError('Assertion failed: `type` must be one of "normal", "break", "continue", "return", or "throw"');
|
|
}
|
|
SLOT.set(this, "[[Type]]", type);
|
|
SLOT.set(this, "[[Value]]", value);
|
|
};
|
|
CompletionRecord.prototype.type = function Type() {
|
|
return SLOT.get(this, "[[Type]]");
|
|
};
|
|
CompletionRecord.prototype.value = function Value() {
|
|
return SLOT.get(this, "[[Value]]");
|
|
};
|
|
CompletionRecord.prototype["?"] = function ReturnIfAbrupt() {
|
|
var type = SLOT.get(this, "[[Type]]");
|
|
var value = SLOT.get(this, "[[Value]]");
|
|
if (type === "throw") {
|
|
throw value;
|
|
}
|
|
return value;
|
|
};
|
|
CompletionRecord.prototype["!"] = function assert() {
|
|
var type = SLOT.get(this, "[[Type]]");
|
|
if (type !== "normal") {
|
|
throw new $SyntaxError('Assertion failed: Completion Record is not of type "normal"');
|
|
}
|
|
return SLOT.get(this, "[[Value]]");
|
|
};
|
|
module.exports = CompletionRecord;
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/GetV.js
|
|
var require_GetV = __commonJS({
|
|
"node_modules/es-abstract/2024/GetV.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var inspect = require_object_inspect();
|
|
var isPropertyKey = require_isPropertyKey();
|
|
module.exports = function GetV(V, P) {
|
|
if (!isPropertyKey(P)) {
|
|
throw new $TypeError("Assertion failed: P is not a Property Key, got " + inspect(P));
|
|
}
|
|
return V[P];
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/GetMethod.js
|
|
var require_GetMethod = __commonJS({
|
|
"node_modules/es-abstract/2024/GetMethod.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var GetV = require_GetV();
|
|
var IsCallable = require_IsCallable();
|
|
var isPropertyKey = require_isPropertyKey();
|
|
var inspect = require_object_inspect();
|
|
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-abstract/helpers/records/iterator-record.js
|
|
var require_iterator_record = __commonJS({
|
|
"node_modules/es-abstract/helpers/records/iterator-record.js"(exports, module) {
|
|
"use strict";
|
|
var hasOwn = require_hasown();
|
|
module.exports = function isIteratorRecord(value) {
|
|
return !!value && typeof value === "object" && hasOwn(value, "[[Iterator]]") && hasOwn(value, "[[NextMethod]]") && hasOwn(value, "[[Done]]") && typeof value["[[Done]]"] === "boolean";
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/IteratorClose.js
|
|
var require_IteratorClose = __commonJS({
|
|
"node_modules/es-abstract/2024/IteratorClose.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var Call = require_Call();
|
|
var CompletionRecord = require_CompletionRecord();
|
|
var GetMethod = require_GetMethod();
|
|
var IsCallable = require_IsCallable();
|
|
var isObject = require_isObject();
|
|
var isIteratorRecord = require_iterator_record();
|
|
module.exports = function IteratorClose(iteratorRecord, completion) {
|
|
if (!isIteratorRecord(iteratorRecord)) {
|
|
throw new $TypeError("Assertion failed: `iteratorRecord` must be an Iterator Record");
|
|
}
|
|
if (!isObject(iteratorRecord["[[Iterator]]"])) {
|
|
throw new $TypeError("Assertion failed: iteratorRecord.[[Iterator]] must be an Object");
|
|
}
|
|
if (!IsCallable(completion) && !(completion instanceof CompletionRecord)) {
|
|
throw new $TypeError("Assertion failed: completion is not a thunk representing a Completion Record, nor a Completion Record instance");
|
|
}
|
|
var completionThunk = completion instanceof CompletionRecord ? function() {
|
|
return completion["?"]();
|
|
} : completion;
|
|
var iterator = iteratorRecord["[[Iterator]]"];
|
|
var iteratorReturn;
|
|
try {
|
|
iteratorReturn = GetMethod(iterator, "return");
|
|
} catch (e) {
|
|
completionThunk();
|
|
completionThunk = null;
|
|
throw e;
|
|
}
|
|
if (typeof iteratorReturn === "undefined") {
|
|
return completionThunk();
|
|
}
|
|
var innerResult;
|
|
try {
|
|
innerResult = Call(iteratorReturn, iterator, []);
|
|
} catch (e) {
|
|
completionThunk();
|
|
completionThunk = null;
|
|
throw e;
|
|
}
|
|
var completionRecord = completionThunk();
|
|
completionThunk = null;
|
|
if (!isObject(innerResult)) {
|
|
throw new $TypeError("iterator .return must return an object");
|
|
}
|
|
return completionRecord;
|
|
};
|
|
}
|
|
});
|
|
|
|
// 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/IteratorComplete.js
|
|
var require_IteratorComplete = __commonJS({
|
|
"node_modules/es-abstract/2024/IteratorComplete.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var Get = require_Get();
|
|
var ToBoolean = require_ToBoolean();
|
|
var isObject = require_isObject();
|
|
module.exports = function IteratorComplete(iterResult) {
|
|
if (!isObject(iterResult)) {
|
|
throw new $TypeError("Assertion failed: Type(iterResult) is not Object");
|
|
}
|
|
return ToBoolean(Get(iterResult, "done"));
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/IteratorNext.js
|
|
var require_IteratorNext = __commonJS({
|
|
"node_modules/es-abstract/2024/IteratorNext.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var Call = require_Call();
|
|
var isObject = require_isObject();
|
|
var isIteratorRecord = require_iterator_record();
|
|
module.exports = function IteratorNext(iteratorRecord) {
|
|
if (!isIteratorRecord(iteratorRecord)) {
|
|
throw new $TypeError("Assertion failed: `iteratorRecord` must be an Iterator Record");
|
|
}
|
|
var result;
|
|
if (arguments.length < 2) {
|
|
result = Call(iteratorRecord["[[NextMethod]]"], iteratorRecord["[[Iterator]]"]);
|
|
} else {
|
|
result = Call(iteratorRecord["[[NextMethod]]"], iteratorRecord["[[Iterator]]"], [arguments[1]]);
|
|
}
|
|
if (!isObject(result)) {
|
|
throw new $TypeError("iterator next must return an object");
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/IteratorStepValue.js
|
|
var require_IteratorStepValue = __commonJS({
|
|
"node_modules/es-abstract/2024/IteratorStepValue.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var Get = require_Get();
|
|
var IteratorComplete = require_IteratorComplete();
|
|
var IteratorNext = require_IteratorNext();
|
|
var isIteratorRecord = require_iterator_record();
|
|
module.exports = function IteratorStepValue(iteratorRecord) {
|
|
if (!isIteratorRecord(iteratorRecord)) {
|
|
throw new $TypeError("Assertion failed: `iteratorRecord` must be an Iterator Record");
|
|
}
|
|
var result;
|
|
try {
|
|
result = IteratorNext(iteratorRecord);
|
|
} catch (e) {
|
|
iteratorRecord["[[Done]]"] = true;
|
|
throw e;
|
|
}
|
|
var done;
|
|
try {
|
|
done = IteratorComplete(result);
|
|
} catch (e) {
|
|
iteratorRecord["[[Done]]"] = true;
|
|
throw e;
|
|
}
|
|
if (done) {
|
|
iteratorRecord["[[Done]]"] = true;
|
|
return "DONE";
|
|
}
|
|
var value;
|
|
try {
|
|
value = Get(result, "value");
|
|
} catch (e) {
|
|
iteratorRecord["[[Done]]"] = true;
|
|
throw e;
|
|
}
|
|
return value;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/NormalCompletion.js
|
|
var require_NormalCompletion = __commonJS({
|
|
"node_modules/es-abstract/2024/NormalCompletion.js"(exports, module) {
|
|
"use strict";
|
|
var CompletionRecord = require_CompletionRecord();
|
|
module.exports = function NormalCompletion(value) {
|
|
return new CompletionRecord("normal", value);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/ThrowCompletion.js
|
|
var require_ThrowCompletion = __commonJS({
|
|
"node_modules/es-abstract/2024/ThrowCompletion.js"(exports, module) {
|
|
"use strict";
|
|
var CompletionRecord = require_CompletionRecord();
|
|
module.exports = function ThrowCompletion(argument) {
|
|
return new CompletionRecord("throw", argument);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.find/implementation.js
|
|
var require_implementation3 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.find/implementation.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var Call = require_Call();
|
|
var GetIteratorDirect = require_GetIteratorDirect();
|
|
var IsCallable = require_IsCallable();
|
|
var IteratorClose = require_IteratorClose();
|
|
var IteratorStepValue = require_IteratorStepValue();
|
|
var NormalCompletion = require_NormalCompletion();
|
|
var ThrowCompletion = require_ThrowCompletion();
|
|
var ToBoolean = require_ToBoolean();
|
|
var Type = require_Type2();
|
|
module.exports = function find(predicate) {
|
|
if (this instanceof find) {
|
|
throw new $TypeError("`find` is not a constructor");
|
|
}
|
|
var O = this;
|
|
if (Type(O) !== "Object") {
|
|
throw new $TypeError("`this` value must be an Object");
|
|
}
|
|
if (!IsCallable(predicate)) {
|
|
throw new $TypeError("`predicate` must be a function");
|
|
}
|
|
var iterated = GetIteratorDirect(O);
|
|
var counter = 0;
|
|
while (true) {
|
|
var value = IteratorStepValue(iterated);
|
|
if (iterated["[[Done]]"]) {
|
|
return void 0;
|
|
}
|
|
var result;
|
|
try {
|
|
result = Call(predicate, void 0, [value, counter]);
|
|
} catch (e) {
|
|
IteratorClose(
|
|
iterated,
|
|
ThrowCompletion(e)
|
|
);
|
|
} finally {
|
|
counter += 1;
|
|
}
|
|
if (ToBoolean(result)) {
|
|
return IteratorClose(
|
|
iterated,
|
|
NormalCompletion(value)
|
|
);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.find/polyfill.js
|
|
var require_polyfill = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.find/polyfill.js"(exports, module) {
|
|
"use strict";
|
|
var implementation = require_implementation3();
|
|
module.exports = function getPolyfill() {
|
|
return typeof Iterator === "function" && typeof Iterator.prototype.find === "function" ? Iterator.prototype.find : implementation;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/functions-have-names/index.js
|
|
var require_functions_have_names = __commonJS({
|
|
"node_modules/functions-have-names/index.js"(exports, module) {
|
|
"use strict";
|
|
var functionsHaveNames = function functionsHaveNames2() {
|
|
return typeof function f() {
|
|
}.name === "string";
|
|
};
|
|
var gOPD = Object.getOwnPropertyDescriptor;
|
|
if (gOPD) {
|
|
try {
|
|
gOPD([], "length");
|
|
} catch (e) {
|
|
gOPD = null;
|
|
}
|
|
}
|
|
functionsHaveNames.functionsHaveConfigurableNames = function functionsHaveConfigurableNames() {
|
|
if (!functionsHaveNames() || !gOPD) {
|
|
return false;
|
|
}
|
|
var desc = gOPD(function() {
|
|
}, "name");
|
|
return !!desc && !!desc.configurable;
|
|
};
|
|
var $bind = Function.prototype.bind;
|
|
functionsHaveNames.boundFunctionsHaveNames = function boundFunctionsHaveNames() {
|
|
return functionsHaveNames() && typeof $bind === "function" && function f() {
|
|
}.bind().name !== "";
|
|
};
|
|
module.exports = functionsHaveNames;
|
|
}
|
|
});
|
|
|
|
// node_modules/set-function-name/index.js
|
|
var require_set_function_name = __commonJS({
|
|
"node_modules/set-function-name/index.js"(exports, module) {
|
|
"use strict";
|
|
var define = require_define_data_property();
|
|
var hasDescriptors = require_has_property_descriptors()();
|
|
var functionsHaveConfigurableNames = require_functions_have_names().functionsHaveConfigurableNames();
|
|
var $TypeError = require_type();
|
|
module.exports = function setFunctionName(fn, name) {
|
|
if (typeof fn !== "function") {
|
|
throw new $TypeError("`fn` is not a function");
|
|
}
|
|
var loose = arguments.length > 2 && !!arguments[2];
|
|
if (!loose || functionsHaveConfigurableNames) {
|
|
if (hasDescriptors) {
|
|
define(
|
|
/** @type {Parameters<define>[0]} */
|
|
fn,
|
|
"name",
|
|
name,
|
|
true,
|
|
true
|
|
);
|
|
} else {
|
|
define(
|
|
/** @type {Parameters<define>[0]} */
|
|
fn,
|
|
"name",
|
|
name
|
|
);
|
|
}
|
|
}
|
|
return fn;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/iterator.prototype/index.js
|
|
var require_iterator = __commonJS({
|
|
"node_modules/iterator.prototype/index.js"(exports, module) {
|
|
"use strict";
|
|
var GetIntrinsic = require_get_intrinsic();
|
|
var gPO = require_get_proto();
|
|
var hasSymbols = require_has_symbols();
|
|
var setFunctionName = require_set_function_name();
|
|
var defineDataProperty = require_define_data_property();
|
|
var $Object = require_es_object_atoms();
|
|
var arrayIterProto = GetIntrinsic("%ArrayIteratorPrototype%", true);
|
|
var iterProto = arrayIterProto && gPO(arrayIterProto);
|
|
var result = iterProto !== $Object.prototype && iterProto || {};
|
|
if (hasSymbols()) {
|
|
if (!(Symbol.iterator in result)) {
|
|
iter = setFunctionName(function SymbolIterator() {
|
|
return this;
|
|
}, "[Symbol.iterator]", true);
|
|
defineDataProperty(result, Symbol.iterator, iter, true);
|
|
}
|
|
}
|
|
var iter;
|
|
module.exports = result;
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype/implementation.js
|
|
var require_implementation4 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype/implementation.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = require_iterator();
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.find/shim.js
|
|
var require_shim = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.find/shim.js"(exports, module) {
|
|
"use strict";
|
|
var define = require_define_properties();
|
|
var getPolyfill = require_polyfill();
|
|
var $IteratorPrototype = require_implementation4();
|
|
module.exports = function shimIteratorPrototypeFind() {
|
|
var polyfill = getPolyfill();
|
|
define(
|
|
$IteratorPrototype,
|
|
{ find: polyfill },
|
|
{ find: function() {
|
|
return $IteratorPrototype.find !== polyfill;
|
|
} }
|
|
);
|
|
return polyfill;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/CreateIterResultObject.js
|
|
var require_CreateIterResultObject = __commonJS({
|
|
"node_modules/es-abstract/2024/CreateIterResultObject.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
module.exports = function CreateIterResultObject(value, done) {
|
|
if (typeof done !== "boolean") {
|
|
throw new $TypeError("Assertion failed: Type(done) is not Boolean");
|
|
}
|
|
return {
|
|
value,
|
|
done
|
|
};
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/aos/GeneratorStart.js
|
|
var require_GeneratorStart = __commonJS({
|
|
"node_modules/es-iterator-helpers/aos/GeneratorStart.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var CreateIterResultObject = require_CreateIterResultObject();
|
|
var IsCallable = require_IsCallable();
|
|
var Type = require_Type2();
|
|
var SLOT = require_internal_slot();
|
|
module.exports = function GeneratorStart(generator, closure) {
|
|
SLOT.assert(generator, "[[GeneratorState]]");
|
|
SLOT.assert(generator, "[[GeneratorContext]]");
|
|
SLOT.assert(generator, "[[GeneratorBrand]]");
|
|
SLOT.assert(generator, "[[Sentinel]]");
|
|
SLOT.assert(generator, "[[CloseIfAbrupt]]");
|
|
if (!IsCallable(closure) || closure.length !== 0) {
|
|
throw new $TypeError("`closure` must be a function that takes no arguments");
|
|
}
|
|
var sentinel = SLOT.get(closure, "[[Sentinel]]");
|
|
if (Type(sentinel) !== "Object") {
|
|
throw new $TypeError("`closure.[[Sentinel]]` must be an object");
|
|
}
|
|
SLOT.set(generator, "[[GeneratorContext]]", function() {
|
|
try {
|
|
var result = closure();
|
|
if (result === sentinel) {
|
|
SLOT.set(generator, "[[GeneratorState]]", "completed");
|
|
SLOT.set(generator, "[[GeneratorContext]]", null);
|
|
return CreateIterResultObject(void 0, true);
|
|
}
|
|
SLOT.set(generator, "[[GeneratorState]]", "suspendedYield");
|
|
return CreateIterResultObject(result, false);
|
|
} catch (e) {
|
|
SLOT.set(generator, "[[GeneratorState]]", "completed");
|
|
SLOT.set(generator, "[[GeneratorContext]]", null);
|
|
throw e;
|
|
}
|
|
});
|
|
SLOT.set(generator, "[[GeneratorState]]", "suspendedStart");
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/helpers/forEach.js
|
|
var require_forEach = __commonJS({
|
|
"node_modules/es-abstract/helpers/forEach.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function forEach(array, callback) {
|
|
for (var i = 0; i < array.length; i += 1) {
|
|
callback(array[i], i, array);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/has-proto/index.js
|
|
var require_has_proto = __commonJS({
|
|
"node_modules/has-proto/index.js"(exports, module) {
|
|
"use strict";
|
|
var test = {
|
|
__proto__: null,
|
|
foo: {}
|
|
};
|
|
var result = { __proto__: test }.foo === test.foo && !(test instanceof Object);
|
|
module.exports = function hasProto() {
|
|
return result;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/OrdinaryObjectCreate.js
|
|
var require_OrdinaryObjectCreate = __commonJS({
|
|
"node_modules/es-abstract/2024/OrdinaryObjectCreate.js"(exports, module) {
|
|
"use strict";
|
|
var GetIntrinsic = require_get_intrinsic();
|
|
var $ObjectCreate = GetIntrinsic("%Object.create%", true);
|
|
var $TypeError = require_type();
|
|
var $SyntaxError = require_syntax();
|
|
var IsArray = require_IsArray2();
|
|
var forEach = require_forEach();
|
|
var isObject = require_isObject();
|
|
var SLOT = require_internal_slot();
|
|
var hasProto = require_has_proto()();
|
|
module.exports = function OrdinaryObjectCreate(proto) {
|
|
if (proto !== null && !isObject(proto)) {
|
|
throw new $TypeError("Assertion failed: `proto` must be null or an object");
|
|
}
|
|
var additionalInternalSlotsList = arguments.length < 2 ? [] : arguments[1];
|
|
if (!IsArray(additionalInternalSlotsList)) {
|
|
throw new $TypeError("Assertion failed: `additionalInternalSlotsList` must be an Array");
|
|
}
|
|
var O;
|
|
if ($ObjectCreate) {
|
|
O = $ObjectCreate(proto);
|
|
} else if (hasProto) {
|
|
O = { __proto__: proto };
|
|
} else {
|
|
if (proto === null) {
|
|
throw new $SyntaxError("native Object.create support is required to create null objects");
|
|
}
|
|
var T = function T2() {
|
|
};
|
|
T.prototype = proto;
|
|
O = new T();
|
|
}
|
|
if (additionalInternalSlotsList.length > 0) {
|
|
forEach(additionalInternalSlotsList, function(slot) {
|
|
SLOT.set(O, slot, void 0);
|
|
});
|
|
}
|
|
return O;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/helpers/every.js
|
|
var require_every = __commonJS({
|
|
"node_modules/es-abstract/helpers/every.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function every(array, predicate) {
|
|
for (var i = 0; i < array.length; i += 1) {
|
|
if (!predicate(array[i], i, array)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
}
|
|
});
|
|
|
|
// 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 = originalFunction.length - (arguments.length - 1);
|
|
return setFunctionLength(
|
|
func,
|
|
1 + (adjustedLength > 0 ? adjustedLength : 0),
|
|
true
|
|
);
|
|
};
|
|
if ($defineProperty) {
|
|
$defineProperty(module.exports, "apply", { value: applyBind });
|
|
} else {
|
|
module.exports.apply = applyBind;
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/isarray/index.js
|
|
var require_isarray = __commonJS({
|
|
"node_modules/isarray/index.js"(exports, module) {
|
|
var toString = {}.toString;
|
|
module.exports = Array.isArray || function(arr) {
|
|
return toString.call(arr) == "[object Array]";
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/safe-array-concat/index.js
|
|
var require_safe_array_concat = __commonJS({
|
|
"node_modules/safe-array-concat/index.js"(exports, module) {
|
|
"use strict";
|
|
var GetIntrinsic = require_get_intrinsic();
|
|
var $concat = GetIntrinsic("%Array.prototype.concat%");
|
|
var callBind = require_call_bind();
|
|
var callBound = require_call_bound();
|
|
var $slice = callBound("Array.prototype.slice");
|
|
var hasSymbols = require_shams()();
|
|
var isConcatSpreadable = hasSymbols && Symbol.isConcatSpreadable;
|
|
var empty = [];
|
|
var $concatApply = isConcatSpreadable ? callBind.apply($concat, empty) : null;
|
|
var isArray = isConcatSpreadable ? (
|
|
/** @type {(value: unknown) => value is unknown[]} */
|
|
require_isarray()
|
|
) : null;
|
|
module.exports = isConcatSpreadable ? function safeArrayConcat(item) {
|
|
for (var i = 0; i < arguments.length; i += 1) {
|
|
var arg = arguments[i];
|
|
if (arg && typeof arg === "object" && typeof arg[isConcatSpreadable] === "boolean") {
|
|
if (!empty[isConcatSpreadable]) {
|
|
empty[isConcatSpreadable] = true;
|
|
}
|
|
var arr = isArray(arg) ? $slice(arg) : [arg];
|
|
arr[isConcatSpreadable] = true;
|
|
arguments[i] = arr;
|
|
}
|
|
}
|
|
return $concatApply(arguments);
|
|
} : callBind($concat, empty);
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/aos/CreateIteratorFromClosure.js
|
|
var require_CreateIteratorFromClosure = __commonJS({
|
|
"node_modules/es-iterator-helpers/aos/CreateIteratorFromClosure.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var GeneratorStart = require_GeneratorStart();
|
|
var IsArray = require_IsArray2();
|
|
var IsCallable = require_IsCallable();
|
|
var OrdinaryObjectCreate = require_OrdinaryObjectCreate();
|
|
var every = require_every();
|
|
var SLOT = require_internal_slot();
|
|
var safeConcat = require_safe_array_concat();
|
|
var isString = function isString2(slot) {
|
|
return typeof slot === "string";
|
|
};
|
|
module.exports = function CreateIteratorFromClosure(closure, generatorBrand, proto) {
|
|
if (!IsCallable(closure)) {
|
|
throw new $TypeError("`closure` must be a function");
|
|
}
|
|
if (typeof generatorBrand !== "string") {
|
|
throw new $TypeError("`generatorBrand` must be a string");
|
|
}
|
|
var extraSlots = arguments.length > 3 ? arguments[3] : [];
|
|
if (arguments.length > 3) {
|
|
if (!IsArray(extraSlots) || !every(extraSlots, isString)) {
|
|
throw new $TypeError("`extraSlots` must be a List of String internal slot names");
|
|
}
|
|
}
|
|
var internalSlotsList = safeConcat(extraSlots, ["[[GeneratorContext]]", "[[GeneratorBrand]]", "[[GeneratorState]]"]);
|
|
var generator = OrdinaryObjectCreate(proto, internalSlotsList);
|
|
SLOT.set(generator, "[[GeneratorBrand]]", generatorBrand);
|
|
SLOT.assert(closure, "[[Sentinel]]");
|
|
SLOT.set(generator, "[[Sentinel]]", SLOT.get(closure, "[[Sentinel]]"));
|
|
SLOT.assert(closure, "[[CloseIfAbrupt]]");
|
|
SLOT.set(generator, "[[CloseIfAbrupt]]", SLOT.get(closure, "[[CloseIfAbrupt]]"));
|
|
GeneratorStart(generator, closure);
|
|
return generator;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/helpers/isLeadingSurrogate.js
|
|
var require_isLeadingSurrogate = __commonJS({
|
|
"node_modules/es-abstract/helpers/isLeadingSurrogate.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function isLeadingSurrogate(charCode) {
|
|
return typeof charCode === "number" && charCode >= 55296 && charCode <= 56319;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/helpers/isTrailingSurrogate.js
|
|
var require_isTrailingSurrogate = __commonJS({
|
|
"node_modules/es-abstract/helpers/isTrailingSurrogate.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function isTrailingSurrogate(charCode) {
|
|
return typeof charCode === "number" && charCode >= 56320 && charCode <= 57343;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/UTF16SurrogatePairToCodePoint.js
|
|
var require_UTF16SurrogatePairToCodePoint = __commonJS({
|
|
"node_modules/es-abstract/2024/UTF16SurrogatePairToCodePoint.js"(exports, module) {
|
|
"use strict";
|
|
var GetIntrinsic = require_get_intrinsic();
|
|
var $TypeError = require_type();
|
|
var $fromCharCode = GetIntrinsic("%String.fromCharCode%");
|
|
var isLeadingSurrogate = require_isLeadingSurrogate();
|
|
var isTrailingSurrogate = require_isTrailingSurrogate();
|
|
module.exports = function UTF16SurrogatePairToCodePoint(lead, trail) {
|
|
if (!isLeadingSurrogate(lead) || !isTrailingSurrogate(trail)) {
|
|
throw new $TypeError("Assertion failed: `lead` must be a leading surrogate char code, and `trail` must be a trailing surrogate char code");
|
|
}
|
|
return $fromCharCode(lead) + $fromCharCode(trail);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/2024/CodePointAt.js
|
|
var require_CodePointAt = __commonJS({
|
|
"node_modules/es-abstract/2024/CodePointAt.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var callBound = require_call_bound();
|
|
var isLeadingSurrogate = require_isLeadingSurrogate();
|
|
var isTrailingSurrogate = require_isTrailingSurrogate();
|
|
var UTF16SurrogatePairToCodePoint = require_UTF16SurrogatePairToCodePoint();
|
|
var $charAt = callBound("String.prototype.charAt");
|
|
var $charCodeAt = callBound("String.prototype.charCodeAt");
|
|
module.exports = function CodePointAt(string, position) {
|
|
if (typeof string !== "string") {
|
|
throw new $TypeError("Assertion failed: `string` must be a String");
|
|
}
|
|
var size = string.length;
|
|
if (position < 0 || position >= size) {
|
|
throw new $TypeError("Assertion failed: `position` must be >= 0, and < the length of `string`");
|
|
}
|
|
var first = $charCodeAt(string, position);
|
|
var cp = $charAt(string, position);
|
|
var firstIsLeading = isLeadingSurrogate(first);
|
|
var firstIsTrailing = isTrailingSurrogate(first);
|
|
if (!firstIsLeading && !firstIsTrailing) {
|
|
return {
|
|
"[[CodePoint]]": cp,
|
|
"[[CodeUnitCount]]": 1,
|
|
"[[IsUnpairedSurrogate]]": false
|
|
};
|
|
}
|
|
if (firstIsTrailing || position + 1 === size) {
|
|
return {
|
|
"[[CodePoint]]": cp,
|
|
"[[CodeUnitCount]]": 1,
|
|
"[[IsUnpairedSurrogate]]": true
|
|
};
|
|
}
|
|
var second = $charCodeAt(string, position + 1);
|
|
if (!isTrailingSurrogate(second)) {
|
|
return {
|
|
"[[CodePoint]]": cp,
|
|
"[[CodeUnitCount]]": 1,
|
|
"[[IsUnpairedSurrogate]]": true
|
|
};
|
|
}
|
|
return {
|
|
"[[CodePoint]]": UTF16SurrogatePairToCodePoint(first, second),
|
|
"[[CodeUnitCount]]": 2,
|
|
"[[IsUnpairedSurrogate]]": false
|
|
};
|
|
};
|
|
}
|
|
});
|
|
|
|
// 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/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/AdvanceStringIndex.js
|
|
var require_AdvanceStringIndex = __commonJS({
|
|
"node_modules/es-abstract/2024/AdvanceStringIndex.js"(exports, module) {
|
|
"use strict";
|
|
var CodePointAt = require_CodePointAt();
|
|
var $TypeError = require_type();
|
|
var isInteger = require_isInteger();
|
|
var MAX_SAFE_INTEGER = require_maxSafeInteger();
|
|
module.exports = function AdvanceStringIndex(S, index, unicode) {
|
|
if (typeof S !== "string") {
|
|
throw new $TypeError("Assertion failed: `S` must be a String");
|
|
}
|
|
if (!isInteger(index) || index < 0 || index > MAX_SAFE_INTEGER) {
|
|
throw new $TypeError("Assertion failed: `length` must be an integer >= 0 and <= 2**53");
|
|
}
|
|
if (typeof unicode !== "boolean") {
|
|
throw new $TypeError("Assertion failed: `unicode` must be a Boolean");
|
|
}
|
|
if (!unicode) {
|
|
return index + 1;
|
|
}
|
|
var length = S.length;
|
|
if (index + 1 >= length) {
|
|
return index + 1;
|
|
}
|
|
var cp = CodePointAt(S, index);
|
|
return index + cp["[[CodeUnitCount]]"];
|
|
};
|
|
}
|
|
});
|
|
|
|
// 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-string/index.js
|
|
var require_is_string = __commonJS({
|
|
"node_modules/is-string/index.js"(exports, module) {
|
|
"use strict";
|
|
var callBound = require_call_bound();
|
|
var $strValueOf = callBound("String.prototype.valueOf");
|
|
var tryStringObject = function tryStringObject2(value) {
|
|
try {
|
|
$strValueOf(value);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
var $toString = callBound("Object.prototype.toString");
|
|
var strClass = "[object String]";
|
|
var hasToStringTag = require_shams2()();
|
|
module.exports = function isString(value) {
|
|
if (typeof value === "string") {
|
|
return true;
|
|
}
|
|
if (!value || typeof value !== "object") {
|
|
return false;
|
|
}
|
|
return hasToStringTag ? tryStringObject(value) : $toString(value) === strClass;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-abstract/helpers/getIteratorMethod.js
|
|
var require_getIteratorMethod = __commonJS({
|
|
"node_modules/es-abstract/helpers/getIteratorMethod.js"(exports, module) {
|
|
"use strict";
|
|
var hasSymbols = require_has_symbols()();
|
|
var GetIntrinsic = require_get_intrinsic();
|
|
var callBound = require_call_bound();
|
|
var isString = require_is_string();
|
|
var $iterator = GetIntrinsic("%Symbol.iterator%", true);
|
|
var $stringSlice = callBound("String.prototype.slice");
|
|
var $String = GetIntrinsic("%String%");
|
|
module.exports = function getIteratorMethod(ES, iterable) {
|
|
var usingIterator;
|
|
if (hasSymbols) {
|
|
usingIterator = ES.GetMethod(iterable, $iterator);
|
|
} else if (ES.IsArray(iterable)) {
|
|
usingIterator = function() {
|
|
var i = -1;
|
|
var arr = this;
|
|
return {
|
|
next: function() {
|
|
i += 1;
|
|
return {
|
|
done: i >= arr.length,
|
|
value: arr[i]
|
|
};
|
|
}
|
|
};
|
|
};
|
|
} else if (isString(iterable)) {
|
|
usingIterator = function() {
|
|
var i = 0;
|
|
return {
|
|
next: function() {
|
|
var nextIndex = ES.AdvanceStringIndex($String(iterable), i, true);
|
|
var value = $stringSlice(iterable, i, nextIndex);
|
|
i = nextIndex;
|
|
return {
|
|
done: nextIndex > iterable.length,
|
|
value
|
|
};
|
|
}
|
|
};
|
|
};
|
|
}
|
|
return usingIterator;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/aos/GetIteratorFlattenable.js
|
|
var require_GetIteratorFlattenable = __commonJS({
|
|
"node_modules/es-iterator-helpers/aos/GetIteratorFlattenable.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var AdvanceStringIndex = require_AdvanceStringIndex();
|
|
var Call = require_Call();
|
|
var GetIteratorDirect = require_GetIteratorDirect();
|
|
var GetMethod = require_GetMethod();
|
|
var IsArray = require_IsArray2();
|
|
var Type = require_Type2();
|
|
var getIteratorMethod = require_getIteratorMethod();
|
|
module.exports = function GetIteratorFlattenable(obj, stringHandling) {
|
|
if (stringHandling !== "REJECT-STRINGS" && stringHandling !== "ITERATE-STRINGS") {
|
|
throw new $TypeError('Assertion failed: `stringHandling` must be "REJECT-STRINGS" or "ITERATE-STRINGS"');
|
|
}
|
|
if (Type(obj) !== "Object") {
|
|
if (stringHandling === "REJECT-STRINGS" || typeof obj !== "string") {
|
|
throw new $TypeError("obj must be an Object");
|
|
}
|
|
}
|
|
var method = void 0;
|
|
method = getIteratorMethod(
|
|
{
|
|
AdvanceStringIndex,
|
|
GetMethod,
|
|
IsArray
|
|
},
|
|
obj
|
|
);
|
|
var iterator;
|
|
if (typeof method === "undefined") {
|
|
iterator = obj;
|
|
} else {
|
|
iterator = Call(method, obj);
|
|
}
|
|
if (Type(iterator) !== "Object") {
|
|
throw new $TypeError("iterator must be an Object");
|
|
}
|
|
return GetIteratorDirect(iterator);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-set-tostringtag/index.js
|
|
var require_es_set_tostringtag = __commonJS({
|
|
"node_modules/es-set-tostringtag/index.js"(exports, module) {
|
|
"use strict";
|
|
var GetIntrinsic = require_get_intrinsic();
|
|
var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
|
|
var hasToStringTag = require_shams2()();
|
|
var hasOwn = require_hasown();
|
|
var $TypeError = require_type();
|
|
var toStringTag = hasToStringTag ? Symbol.toStringTag : null;
|
|
module.exports = function setToStringTag(object, value) {
|
|
var overrideIfSet = arguments.length > 2 && !!arguments[2] && arguments[2].force;
|
|
var nonConfigurable = arguments.length > 2 && !!arguments[2] && arguments[2].nonConfigurable;
|
|
if (typeof overrideIfSet !== "undefined" && typeof overrideIfSet !== "boolean" || typeof nonConfigurable !== "undefined" && typeof nonConfigurable !== "boolean") {
|
|
throw new $TypeError("if provided, the `overrideIfSet` and `nonConfigurable` options must be booleans");
|
|
}
|
|
if (toStringTag && (overrideIfSet || !hasOwn(object, toStringTag))) {
|
|
if ($defineProperty) {
|
|
$defineProperty(object, toStringTag, {
|
|
configurable: !nonConfigurable,
|
|
enumerable: false,
|
|
value,
|
|
writable: false
|
|
});
|
|
} else {
|
|
object[toStringTag] = value;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/aos/GeneratorValidate.js
|
|
var require_GeneratorValidate = __commonJS({
|
|
"node_modules/es-iterator-helpers/aos/GeneratorValidate.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var SLOT = require_internal_slot();
|
|
module.exports = function GeneratorValidate(generator, generatorBrand) {
|
|
SLOT.assert(generator, "[[GeneratorState]]");
|
|
SLOT.assert(generator, "[[GeneratorBrand]]");
|
|
var brand = SLOT.get(generator, "[[GeneratorBrand]]");
|
|
if (brand !== generatorBrand) {
|
|
throw new $TypeError("Assertion failed: generator brand is unexpected: " + brand);
|
|
}
|
|
SLOT.assert(generator, "[[GeneratorContext]]");
|
|
var state = SLOT.get(generator, "[[GeneratorState]]");
|
|
if (state === "executing") {
|
|
throw new $TypeError("generator is executing");
|
|
}
|
|
return state;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/aos/GeneratorResume.js
|
|
var require_GeneratorResume = __commonJS({
|
|
"node_modules/es-iterator-helpers/aos/GeneratorResume.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var CreateIterResultObject = require_CreateIterResultObject();
|
|
var GeneratorValidate = require_GeneratorValidate();
|
|
var SLOT = require_internal_slot();
|
|
module.exports = function GeneratorResume(generator, value, generatorBrand) {
|
|
var state = GeneratorValidate(generator, generatorBrand);
|
|
if (state === "completed") {
|
|
return CreateIterResultObject(void 0, true);
|
|
}
|
|
if (state !== "suspendedStart" && state !== "suspendedYield") {
|
|
throw new $TypeError("Assertion failed: generator state is unexpected: " + state);
|
|
}
|
|
var genContext = SLOT.get(generator, "[[GeneratorContext]]");
|
|
SLOT.set(generator, "[[GeneratorState]]", "executing");
|
|
var result = genContext(value);
|
|
return result;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/aos/GeneratorResumeAbrupt.js
|
|
var require_GeneratorResumeAbrupt = __commonJS({
|
|
"node_modules/es-iterator-helpers/aos/GeneratorResumeAbrupt.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var CompletionRecord = require_CompletionRecord();
|
|
var CreateIterResultObject = require_CreateIterResultObject();
|
|
var GeneratorValidate = require_GeneratorValidate();
|
|
var NormalCompletion = require_NormalCompletion();
|
|
var SLOT = require_internal_slot();
|
|
module.exports = function GeneratorResumeAbrupt(generator, abruptCompletion, generatorBrand) {
|
|
if (!(abruptCompletion instanceof CompletionRecord)) {
|
|
throw new $TypeError("Assertion failed: abruptCompletion must be a Completion Record");
|
|
}
|
|
var state = GeneratorValidate(generator, generatorBrand);
|
|
if (state === "suspendedStart") {
|
|
SLOT.set(generator, "[[GeneratorState]]", "completed");
|
|
SLOT.set(generator, "[[GeneratorContext]]", null);
|
|
state = "completed";
|
|
}
|
|
var value = abruptCompletion.value();
|
|
if (state === "completed") {
|
|
return CreateIterResultObject(value, true);
|
|
}
|
|
if (state !== "suspendedYield") {
|
|
throw new $TypeError("Assertion failed: generator state is unexpected: " + state);
|
|
}
|
|
if (abruptCompletion.type() === "return") {
|
|
return CreateIterResultObject(SLOT.get(generator, "[[CloseIfAbrupt]]")(NormalCompletion(abruptCompletion.value())), true);
|
|
}
|
|
var genContext = SLOT.get(generator, "[[GeneratorContext]]");
|
|
SLOT.set(generator, "[[GeneratorState]]", "executing");
|
|
var result = genContext(value);
|
|
return result;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/aos/IteratorCloseAll.js
|
|
var require_IteratorCloseAll = __commonJS({
|
|
"node_modules/es-iterator-helpers/aos/IteratorCloseAll.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var CompletionRecord = require_CompletionRecord();
|
|
var IteratorClose = require_IteratorClose();
|
|
var ThrowCompletion = require_ThrowCompletion();
|
|
var IsArray = require_IsArray();
|
|
var every = require_every();
|
|
var isIteratorRecord = require_iterator_record();
|
|
module.exports = function IteratorCloseAll(iters, completion) {
|
|
if (!IsArray(iters) || !every(iters, isIteratorRecord)) {
|
|
throw new $TypeError("Assertion failed: `iters` must be a List of IteratorRecords");
|
|
}
|
|
if (!(completion instanceof CompletionRecord)) {
|
|
throw new $TypeError("Assertion failed: `completion` must be a Completion Record");
|
|
}
|
|
for (var i = iters.length - 1; i >= 0; i -= 1) {
|
|
try {
|
|
IteratorClose(iters[i], completion);
|
|
} catch (e) {
|
|
completion = ThrowCompletion(e);
|
|
}
|
|
}
|
|
return completion["?"]();
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/aos/ReturnCompletion.js
|
|
var require_ReturnCompletion = __commonJS({
|
|
"node_modules/es-iterator-helpers/aos/ReturnCompletion.js"(exports, module) {
|
|
"use strict";
|
|
var CompletionRecord = require_CompletionRecord();
|
|
module.exports = function ReturnCompletion(value) {
|
|
return new CompletionRecord("return", value);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/IteratorHelperPrototype/index.js
|
|
var require_IteratorHelperPrototype = __commonJS({
|
|
"node_modules/es-iterator-helpers/IteratorHelperPrototype/index.js"(exports, module) {
|
|
"use strict";
|
|
var setToStringTag = require_es_set_tostringtag();
|
|
var hasProto = require_has_proto()();
|
|
var iterProto = require_implementation4();
|
|
var SLOT = require_internal_slot();
|
|
var CreateIterResultObject = require_CreateIterResultObject();
|
|
var GeneratorResume = require_GeneratorResume();
|
|
var GeneratorResumeAbrupt = require_GeneratorResumeAbrupt();
|
|
var IteratorCloseAll = require_IteratorCloseAll();
|
|
var ReturnCompletion = require_ReturnCompletion();
|
|
var implementation;
|
|
var o = {
|
|
// in an object, for name inference
|
|
"return": function() {
|
|
var O = this;
|
|
SLOT.assert(O, "[[UnderlyingIterators]]");
|
|
SLOT.assert(O, "[[GeneratorState]]");
|
|
if (SLOT.get(O, "[[GeneratorState]]") === "suspendedStart") {
|
|
SLOT.set(O, "[[GeneratorState]]", "completed");
|
|
IteratorCloseAll(SLOT.get(O, "[[UnderlyingIterators]]"), ReturnCompletion(void 0));
|
|
return CreateIterResultObject(void 0, true);
|
|
}
|
|
var C = ReturnCompletion(void 0);
|
|
return GeneratorResumeAbrupt(O, C, "Iterator Helper");
|
|
}
|
|
};
|
|
if (hasProto) {
|
|
implementation = {
|
|
__proto__: iterProto,
|
|
next: function next() {
|
|
return GeneratorResume(this, void 0, "Iterator Helper");
|
|
},
|
|
"return": o["return"]
|
|
};
|
|
setToStringTag(implementation, "Iterator Helper");
|
|
} else {
|
|
IteratorHelper = function IteratorHelper2() {
|
|
};
|
|
IteratorHelper.prototype = iterProto;
|
|
implementation = new IteratorHelper();
|
|
delete implementation.constructor;
|
|
implementation.next = function next() {
|
|
return GeneratorResume(this, void 0, "Iterator Helper");
|
|
};
|
|
implementation["return"] = o["return"];
|
|
}
|
|
var IteratorHelper;
|
|
module.exports = implementation;
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.flatMap/implementation.js
|
|
var require_implementation5 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.flatMap/implementation.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var Call = require_Call();
|
|
var CompletionRecord = require_CompletionRecord();
|
|
var CreateIteratorFromClosure = require_CreateIteratorFromClosure();
|
|
var GetIteratorDirect = require_GetIteratorDirect();
|
|
var GetIteratorFlattenable = require_GetIteratorFlattenable();
|
|
var IsCallable = require_IsCallable();
|
|
var IteratorClose = require_IteratorClose();
|
|
var IteratorStepValue = require_IteratorStepValue();
|
|
var ThrowCompletion = require_ThrowCompletion();
|
|
var Type = require_Type2();
|
|
var iterHelperProto = require_IteratorHelperPrototype();
|
|
var SLOT = require_internal_slot();
|
|
module.exports = function flatMap(mapper) {
|
|
if (this instanceof flatMap) {
|
|
throw new $TypeError("`flatMap` is not a constructor");
|
|
}
|
|
var O = this;
|
|
if (Type(O) !== "Object") {
|
|
throw new $TypeError("`this` value must be an Object");
|
|
}
|
|
if (!IsCallable(mapper)) {
|
|
throw new $TypeError("`mapper` must be a function");
|
|
}
|
|
var iterated = GetIteratorDirect(O);
|
|
var sentinel = { sentinel: true };
|
|
var innerIterator = sentinel;
|
|
var closeIfAbrupt = function(abruptCompletion) {
|
|
if (!(abruptCompletion instanceof CompletionRecord)) {
|
|
throw new $TypeError("`abruptCompletion` must be a Completion Record");
|
|
}
|
|
try {
|
|
if (innerIterator !== sentinel) {
|
|
IteratorClose(
|
|
innerIterator,
|
|
abruptCompletion
|
|
);
|
|
}
|
|
} finally {
|
|
innerIterator = sentinel;
|
|
IteratorClose(
|
|
iterated,
|
|
abruptCompletion
|
|
);
|
|
}
|
|
};
|
|
var counter = 0;
|
|
var innerAlive = false;
|
|
var closure = function() {
|
|
if (innerIterator === sentinel) {
|
|
var value = IteratorStepValue(iterated);
|
|
if (iterated["[[Done]]"]) {
|
|
innerAlive = false;
|
|
innerIterator = sentinel;
|
|
return sentinel;
|
|
}
|
|
}
|
|
if (innerIterator === sentinel) {
|
|
innerAlive = true;
|
|
try {
|
|
var mapped = Call(mapper, void 0, [value, counter]);
|
|
innerIterator = GetIteratorFlattenable(mapped, "REJECT-STRINGS");
|
|
} catch (e) {
|
|
innerAlive = false;
|
|
innerIterator = sentinel;
|
|
closeIfAbrupt(ThrowCompletion(e));
|
|
} finally {
|
|
counter += 1;
|
|
}
|
|
}
|
|
if (innerAlive) {
|
|
var innerValue;
|
|
try {
|
|
innerValue = IteratorStepValue(innerIterator);
|
|
} catch (e) {
|
|
innerAlive = false;
|
|
innerIterator = sentinel;
|
|
closeIfAbrupt(ThrowCompletion(e));
|
|
}
|
|
if (innerIterator["[[Done]]"]) {
|
|
innerAlive = false;
|
|
innerIterator = sentinel;
|
|
return closure();
|
|
}
|
|
return innerValue;
|
|
}
|
|
return sentinel;
|
|
};
|
|
SLOT.set(closure, "[[Sentinel]]", sentinel);
|
|
SLOT.set(closure, "[[CloseIfAbrupt]]", closeIfAbrupt);
|
|
var result = CreateIteratorFromClosure(closure, "Iterator Helper", iterHelperProto, ["[[UnderlyingIterators]]"]);
|
|
SLOT.set(result, "[[UnderlyingIterators]]", [iterated]);
|
|
return result;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.flatMap/polyfill.js
|
|
var require_polyfill2 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.flatMap/polyfill.js"(exports, module) {
|
|
"use strict";
|
|
var implementation = require_implementation5();
|
|
module.exports = function getPolyfill() {
|
|
if (typeof Iterator === "function" && typeof Iterator.prototype.flatMap === "function") {
|
|
try {
|
|
Iterator.prototype.flatMap.call({ next: null }, function() {
|
|
}).next();
|
|
} catch (e) {
|
|
return Iterator.prototype.flatMap;
|
|
}
|
|
}
|
|
return implementation;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.flatMap/shim.js
|
|
var require_shim2 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.flatMap/shim.js"(exports, module) {
|
|
"use strict";
|
|
var define = require_define_properties();
|
|
var getPolyfill = require_polyfill2();
|
|
var $IteratorPrototype = require_implementation4();
|
|
module.exports = function shimIteratorPrototypeFlatMap() {
|
|
var polyfill = getPolyfill();
|
|
define(
|
|
$IteratorPrototype,
|
|
{ flatMap: polyfill },
|
|
{ flatMap: function() {
|
|
return $IteratorPrototype.flatMap !== polyfill;
|
|
} }
|
|
);
|
|
return polyfill;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.map/implementation.js
|
|
var require_implementation6 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.map/implementation.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var Call = require_Call();
|
|
var CompletionRecord = require_CompletionRecord();
|
|
var CreateIteratorFromClosure = require_CreateIteratorFromClosure();
|
|
var GetIteratorDirect = require_GetIteratorDirect();
|
|
var IsCallable = require_IsCallable();
|
|
var IteratorClose = require_IteratorClose();
|
|
var IteratorStepValue = require_IteratorStepValue();
|
|
var ThrowCompletion = require_ThrowCompletion();
|
|
var Type = require_Type2();
|
|
var iterHelperProto = require_IteratorHelperPrototype();
|
|
var SLOT = require_internal_slot();
|
|
module.exports = function map(mapper) {
|
|
if (this instanceof map) {
|
|
throw new $TypeError("`map` is not a constructor");
|
|
}
|
|
var O = this;
|
|
if (Type(O) !== "Object") {
|
|
throw new $TypeError("`this` value must be an Object");
|
|
}
|
|
if (!IsCallable(mapper)) {
|
|
throw new $TypeError("`mapper` must be a function");
|
|
}
|
|
var iterated = GetIteratorDirect(O);
|
|
var closeIfAbrupt = function(abruptCompletion) {
|
|
if (!(abruptCompletion instanceof CompletionRecord)) {
|
|
throw new $TypeError("`abruptCompletion` must be a Completion Record");
|
|
}
|
|
IteratorClose(
|
|
iterated,
|
|
abruptCompletion
|
|
);
|
|
};
|
|
var sentinel = {};
|
|
var counter = 0;
|
|
var closure = function() {
|
|
var value = IteratorStepValue(iterated);
|
|
if (iterated["[[Done]]"]) {
|
|
return sentinel;
|
|
}
|
|
var mapped;
|
|
try {
|
|
mapped = Call(mapper, void 0, [value, counter]);
|
|
return mapped;
|
|
} catch (e) {
|
|
closeIfAbrupt(ThrowCompletion(e));
|
|
throw e;
|
|
} finally {
|
|
counter += 1;
|
|
}
|
|
};
|
|
SLOT.set(closure, "[[Sentinel]]", sentinel);
|
|
SLOT.set(closure, "[[CloseIfAbrupt]]", closeIfAbrupt);
|
|
var result = CreateIteratorFromClosure(closure, "Iterator Helper", iterHelperProto, ["[[UnderlyingIterators]]"]);
|
|
SLOT.set(result, "[[UnderlyingIterators]]", [iterated]);
|
|
return result;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.map/polyfill.js
|
|
var require_polyfill3 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.map/polyfill.js"(exports, module) {
|
|
"use strict";
|
|
var implementation = require_implementation6();
|
|
module.exports = function getPolyfill() {
|
|
if (typeof Iterator === "function" && typeof Iterator.prototype.map === "function") {
|
|
try {
|
|
Iterator.prototype.map.call({ next: null }, function() {
|
|
}).next();
|
|
} catch (e) {
|
|
return Iterator.prototype.map;
|
|
}
|
|
}
|
|
return implementation;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.map/shim.js
|
|
var require_shim3 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.map/shim.js"(exports, module) {
|
|
"use strict";
|
|
var define = require_define_properties();
|
|
var getPolyfill = require_polyfill3();
|
|
var $IteratorPrototype = require_implementation4();
|
|
module.exports = function shimIteratorPrototypeMap() {
|
|
var polyfill = getPolyfill();
|
|
define(
|
|
$IteratorPrototype,
|
|
{ map: polyfill },
|
|
{ map: function() {
|
|
return $IteratorPrototype.map !== polyfill;
|
|
} }
|
|
);
|
|
return polyfill;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.reduce/implementation.js
|
|
var require_implementation7 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.reduce/implementation.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var Call = require_Call();
|
|
var GetIteratorDirect = require_GetIteratorDirect();
|
|
var IsCallable = require_IsCallable();
|
|
var IteratorClose = require_IteratorClose();
|
|
var IteratorStepValue = require_IteratorStepValue();
|
|
var ThrowCompletion = require_ThrowCompletion();
|
|
var Type = require_Type2();
|
|
module.exports = function reduce(reducer) {
|
|
if (this instanceof reduce) {
|
|
throw new $TypeError("`reduce` is not a constructor");
|
|
}
|
|
var O = this;
|
|
if (Type(O) !== "Object") {
|
|
throw new $TypeError("`this` value must be an Object");
|
|
}
|
|
if (!IsCallable(reducer)) {
|
|
throw new $TypeError("`reducer` must be a function");
|
|
}
|
|
var iterated = GetIteratorDirect(O);
|
|
var accumulator;
|
|
var counter;
|
|
if (arguments.length < 2) {
|
|
accumulator = IteratorStepValue(iterated);
|
|
if (iterated["[[Done]]"]) {
|
|
throw new $TypeError("Reduce of empty iterator with no initial value");
|
|
}
|
|
counter = 1;
|
|
} else {
|
|
accumulator = arguments[1];
|
|
counter = 0;
|
|
}
|
|
while (true) {
|
|
var value = IteratorStepValue(iterated);
|
|
if (iterated["[[Done]]"]) {
|
|
return accumulator;
|
|
}
|
|
try {
|
|
var result = Call(reducer, void 0, [accumulator, value, counter]);
|
|
accumulator = result;
|
|
} catch (e) {
|
|
IteratorClose(
|
|
iterated,
|
|
ThrowCompletion(e)
|
|
);
|
|
}
|
|
counter += 1;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.reduce/polyfill.js
|
|
var require_polyfill4 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.reduce/polyfill.js"(exports, module) {
|
|
"use strict";
|
|
var implementation = require_implementation7();
|
|
module.exports = function getPolyfill() {
|
|
return typeof Iterator === "function" && typeof Iterator.prototype.reduce === "function" ? Iterator.prototype.reduce : implementation;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.reduce/shim.js
|
|
var require_shim4 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.reduce/shim.js"(exports, module) {
|
|
"use strict";
|
|
var define = require_define_properties();
|
|
var getPolyfill = require_polyfill4();
|
|
var $IteratorPrototype = require_implementation4();
|
|
module.exports = function shimIteratorPrototypeReduce() {
|
|
var polyfill = getPolyfill();
|
|
define(
|
|
$IteratorPrototype,
|
|
{ reduce: polyfill },
|
|
{ reduce: function() {
|
|
return $IteratorPrototype.reduce !== polyfill;
|
|
} }
|
|
);
|
|
return polyfill;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.toArray/implementation.js
|
|
var require_implementation8 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.toArray/implementation.js"(exports, module) {
|
|
"use strict";
|
|
var $TypeError = require_type();
|
|
var GetIteratorDirect = require_GetIteratorDirect();
|
|
var IteratorStepValue = require_IteratorStepValue();
|
|
var Type = require_Type2();
|
|
module.exports = function toArray() {
|
|
if (this instanceof toArray) {
|
|
throw new $TypeError("`toArray` is not a constructor");
|
|
}
|
|
var O = this;
|
|
if (Type(O) !== "Object") {
|
|
throw new $TypeError("`this` value must be an Object");
|
|
}
|
|
var iterated = GetIteratorDirect(O);
|
|
var items = [];
|
|
while (true) {
|
|
var value = IteratorStepValue(iterated);
|
|
if (iterated["[[Done]]"]) {
|
|
return items;
|
|
}
|
|
items[items.length] = value;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.toArray/polyfill.js
|
|
var require_polyfill5 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.toArray/polyfill.js"(exports, module) {
|
|
"use strict";
|
|
var implementation = require_implementation8();
|
|
module.exports = function getPolyfill() {
|
|
return typeof Iterator === "function" && typeof Iterator.prototype.toArray === "function" ? Iterator.prototype.toArray : implementation;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.toArray/shim.js
|
|
var require_shim5 = __commonJS({
|
|
"node_modules/es-iterator-helpers/Iterator.prototype.toArray/shim.js"(exports, module) {
|
|
"use strict";
|
|
var define = require_define_properties();
|
|
var getPolyfill = require_polyfill5();
|
|
var $IteratorPrototype = require_implementation4();
|
|
module.exports = function shimIteratorPrototypeToArray() {
|
|
var polyfill = getPolyfill();
|
|
define(
|
|
$IteratorPrototype,
|
|
{ toArray: polyfill },
|
|
{ toArray: function() {
|
|
return $IteratorPrototype.toArray !== polyfill;
|
|
} }
|
|
);
|
|
return polyfill;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.find/auto.js
|
|
require_shim()();
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.flatMap/auto.js
|
|
require_shim2()();
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.map/auto.js
|
|
require_shim3()();
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.reduce/auto.js
|
|
require_shim4()();
|
|
|
|
// node_modules/es-iterator-helpers/Iterator.prototype.toArray/auto.js
|
|
require_shim5()();
|
|
})();
|