chai 5.3.2 → 5.3.3

package/index.js

@@ -1,4 +1,5 @@
 var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -51,12 +52,15 @@ __export(check_error_exports, {
 function isErrorInstance(obj) {
   return obj instanceof Error || Object.prototype.toString.call(obj) === "[object Error]";
 }
+__name(isErrorInstance, "isErrorInstance");
 function isRegExp(obj) {
   return Object.prototype.toString.call(obj) === "[object RegExp]";
 }
+__name(isRegExp, "isRegExp");
 function compatibleInstance(thrown, errorLike) {
   return isErrorInstance(errorLike) && thrown === errorLike;
 }
+__name(compatibleInstance, "compatibleInstance");
 function compatibleConstructor(thrown, errorLike) {
   if (isErrorInstance(errorLike)) {
     return thrown.constructor === errorLike.constructor || thrown instanceof errorLike.constructor;
@@ -65,6 +69,7 @@ function compatibleConstructor(thrown, errorLike) {
   }
   return false;
 }
+__name(compatibleConstructor, "compatibleConstructor");
 function compatibleMessage(thrown, errMatcher) {
   const comparisonString = typeof thrown === "string" ? thrown : thrown.message;
   if (isRegExp(errMatcher)) {
@@ -74,6 +79,7 @@ function compatibleMessage(thrown, errMatcher) {
   }
   return false;
 }
+__name(compatibleMessage, "compatibleMessage");
 function getConstructorName(errorLike) {
   let constructorName = errorLike;
   if (isErrorInstance(errorLike)) {
@@ -87,6 +93,7 @@ function getConstructorName(errorLike) {
   }
   return constructorName;
 }
+__name(getConstructorName, "getConstructorName");
 function getMessage(errorLike) {
   let msg = "";
   if (errorLike && errorLike.message) {
@@ -96,6 +103,7 @@ function getMessage(errorLike) {
   }
   return msg;
 }
+__name(getMessage, "getMessage");
 
 // lib/chai/utils/flag.js
 function flag(obj, key, value) {
@@ -106,12 +114,14 @@ function flag(obj, key, value) {
     return flags[key];
   }
 }
+__name(flag, "flag");
 
 // lib/chai/utils/test.js
 function test(obj, args) {
   let negate = flag(obj, "negate"), expr = args[0];
   return negate ? !expr : expr;
 }
+__name(test, "test");
 
 // lib/chai/utils/type-detect.js
 function type(obj) {
@@ -128,10 +138,14 @@ function type(obj) {
   const type3 = Object.prototype.toString.call(obj).slice(8, -1);
   return type3;
 }
+__name(type, "type");
 
 // node_modules/assertion-error/index.js
 var canElideFrames = "captureStackTrace" in Error;
 var AssertionError = class _AssertionError extends Error {
+  static {
+    __name(this, "AssertionError");
+  }
   message;
   get name() {
     return "AssertionError";
@@ -188,11 +202,13 @@ function expectTypes(obj, types) {
     );
   }
 }
+__name(expectTypes, "expectTypes");
 
 // lib/chai/utils/getActual.js
 function getActual(obj, args) {
   return args.length > 4 ? args[4] : obj._obj;
 }
+__name(getActual, "getActual");
 
 // node_modules/loupe/lib/helpers.js
 var ansiColors = {
@@ -244,6 +260,7 @@ function colorise(value, styleType) {
   }
   return `\x1B[${color[0]}m${String(value)}\x1B[${color[1]}m`;
 }
+__name(colorise, "colorise");
 function normaliseOptions({
   showHidden = false,
   depth = 2,
@@ -275,9 +292,11 @@ function normaliseOptions({
   }
   return options;
 }
+__name(normaliseOptions, "normaliseOptions");
 function isHighSurrogate(char) {
   return char >= "\uD800" && char <= "\uDBFF";
 }
+__name(isHighSurrogate, "isHighSurrogate");
 function truncate(string, length, tail = truncator) {
   string = String(string);
   const tailLength = tail.length;
@@ -294,6 +313,7 @@ function truncate(string, length, tail = truncator) {
   }
   return string;
 }
+__name(truncate, "truncate");
 function inspectList(list, options, inspectItem, separator = ", ") {
   inspectItem = inspectItem || options.inspect;
   const size = list.length;
@@ -331,12 +351,14 @@ function inspectList(list, options, inspectItem, separator = ", ") {
   }
   return `${output}${truncated}`;
 }
+__name(inspectList, "inspectList");
 function quoteComplexKey(key) {
   if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) {
     return key;
   }
   return JSON.stringify(key).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
 }
+__name(quoteComplexKey, "quoteComplexKey");
 function inspectProperty([key, value], options) {
   options.truncate -= 2;
   if (typeof key === "string") {
@@ -348,6 +370,7 @@ function inspectProperty([key, value], options) {
   value = options.inspect(value, options);
   return `${key}: ${value}`;
 }
+__name(inspectProperty, "inspectProperty");
 
 // node_modules/loupe/lib/array.js
 function inspectArray(array, options) {
@@ -363,9 +386,10 @@ function inspectArray(array, options) {
   }
   return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ""} ]`;
 }
+__name(inspectArray, "inspectArray");
 
 // node_modules/loupe/lib/typedarray.js
-var getArrayName = (array) => {
+var getArrayName = /* @__PURE__ */ __name((array) => {
   if (typeof Buffer === "function" && array instanceof Buffer) {
     return "Buffer";
   }
@@ -373,7 +397,7 @@ var getArrayName = (array) => {
     return array[Symbol.toStringTag];
   }
   return array.constructor.name;
-};
+}, "getArrayName");
 function inspectTypedArray(array, options) {
   const name = getArrayName(array);
   options.truncate -= name.length + 4;
@@ -396,6 +420,7 @@ function inspectTypedArray(array, options) {
   }
   return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`;
 }
+__name(inspectTypedArray, "inspectTypedArray");
 
 // node_modules/loupe/lib/date.js
 function inspectDate(dateObject, options) {
@@ -407,6 +432,7 @@ function inspectDate(dateObject, options) {
   const date = split[0];
   return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, "date");
 }
+__name(inspectDate, "inspectDate");
 
 // node_modules/loupe/lib/function.js
 function inspectFunction(func, options) {
@@ -417,6 +443,7 @@ function inspectFunction(func, options) {
   }
   return options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, "special");
 }
+__name(inspectFunction, "inspectFunction");
 
 // node_modules/loupe/lib/map.js
 function inspectMapEntry([key, value], options) {
@@ -426,6 +453,7 @@ function inspectMapEntry([key, value], options) {
   value = options.inspect(value, options);
   return `${key} => ${value}`;
 }
+__name(inspectMapEntry, "inspectMapEntry");
 function mapToEntries(map) {
   const entries = [];
   map.forEach((value, key) => {
@@ -433,12 +461,14 @@ function mapToEntries(map) {
   });
   return entries;
 }
+__name(mapToEntries, "mapToEntries");
 function inspectMap(map, options) {
   if (map.size === 0)
     return "Map{}";
   options.truncate -= 7;
   return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`;
 }
+__name(inspectMap, "inspectMap");
 
 // node_modules/loupe/lib/number.js
 var isNaN = Number.isNaN || ((i) => i !== i);
@@ -457,6 +487,7 @@ function inspectNumber(number, options) {
   }
   return options.stylize(truncate(String(number), options.truncate), "number");
 }
+__name(inspectNumber, "inspectNumber");
 
 // node_modules/loupe/lib/bigint.js
 function inspectBigInt(number, options) {
@@ -465,6 +496,7 @@ function inspectBigInt(number, options) {
     nums += "n";
   return options.stylize(nums, "bigint");
 }
+__name(inspectBigInt, "inspectBigInt");
 
 // node_modules/loupe/lib/regexp.js
 function inspectRegExp(value, options) {
@@ -473,6 +505,7 @@ function inspectRegExp(value, options) {
   const source = value.source;
   return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, "regexp");
 }
+__name(inspectRegExp, "inspectRegExp");
 
 // node_modules/loupe/lib/set.js
 function arrayFromSet(set2) {
@@ -482,12 +515,14 @@ function arrayFromSet(set2) {
   });
   return values;
 }
+__name(arrayFromSet, "arrayFromSet");
 function inspectSet(set2, options) {
   if (set2.size === 0)
     return "Set{}";
   options.truncate -= 7;
   return `Set{ ${inspectList(arrayFromSet(set2), options)} }`;
 }
+__name(inspectSet, "inspectSet");
 
 // node_modules/loupe/lib/string.js
 var stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g");
@@ -505,12 +540,14 @@ var unicodeLength = 4;
 function escape(char) {
   return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-unicodeLength)}`;
 }
+__name(escape, "escape");
 function inspectString(string, options) {
   if (stringEscapeChars.test(string)) {
     string = string.replace(stringEscapeChars, escape);
   }
   return options.stylize(`'${truncate(string, options.truncate - 2)}'`, "string");
 }
+__name(inspectString, "inspectString");
 
 // node_modules/loupe/lib/symbol.js
 function inspectSymbol(value) {
@@ -519,9 +556,10 @@ function inspectSymbol(value) {
   }
   return value.toString();
 }
+__name(inspectSymbol, "inspectSymbol");
 
 // node_modules/loupe/lib/promise.js
-var getPromiseValue = () => "Promise{\u2026}";
+var getPromiseValue = /* @__PURE__ */ __name(() => "Promise{\u2026}", "getPromiseValue");
 var promise_default = getPromiseValue;
 
 // node_modules/loupe/lib/object.js
@@ -546,6 +584,7 @@ function inspectObject(object, options) {
   }
   return `{ ${propertyContents}${sep}${symbolContents} }`;
 }
+__name(inspectObject, "inspectObject");
 
 // node_modules/loupe/lib/class.js
 var toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag ? Symbol.toStringTag : false;
@@ -561,6 +600,7 @@ function inspectClass(value, options) {
   options.truncate -= name.length;
   return `${name}${inspectObject(value, options)}`;
 }
+__name(inspectClass, "inspectClass");
 
 // node_modules/loupe/lib/arguments.js
 function inspectArguments(args, options) {
@@ -569,6 +609,7 @@ function inspectArguments(args, options) {
   options.truncate -= 13;
   return `Arguments[ ${inspectList(args, options)} ]`;
 }
+__name(inspectArguments, "inspectArguments");
 
 // node_modules/loupe/lib/error.js
 var errorKeys = [
@@ -604,6 +645,7 @@ function inspectObject2(error, options) {
   const propertyContents = inspectList(properties.map((key) => [key, error[key]]), options, inspectProperty);
   return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ""}`;
 }
+__name(inspectObject2, "inspectObject");
 
 // node_modules/loupe/lib/html.js
 function inspectAttribute([key, value], options) {
@@ -613,9 +655,11 @@ function inspectAttribute([key, value], options) {
   }
   return `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}`;
 }
+__name(inspectAttribute, "inspectAttribute");
 function inspectNodeCollection(collection, options) {
   return inspectList(collection, options, inspectNode, "\n");
 }
+__name(inspectNodeCollection, "inspectNodeCollection");
 function inspectNode(node, options) {
   switch (node.nodeType) {
     case 1:
@@ -626,6 +670,7 @@ function inspectNode(node, options) {
       return options.inspect(node, options);
   }
 }
+__name(inspectNode, "inspectNode");
 function inspectHTML(element, options) {
   const properties = element.getAttributeNames();
   const name = element.tagName.toLowerCase();
@@ -646,6 +691,7 @@ function inspectHTML(element, options) {
   }
   return `${head}${propertyContents}${headClose}${children}${tail}`;
 }
+__name(inspectHTML, "inspectHTML");
 
 // node_modules/loupe/lib/index.js
 var symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function";
@@ -654,10 +700,10 @@ var nodeInspect = Symbol.for("nodejs.util.inspect.custom");
 var constructorMap = /* @__PURE__ */ new WeakMap();
 var stringTagMap = {};
 var baseTypesMap = {
-  undefined: (value, options) => options.stylize("undefined", "undefined"),
-  null: (value, options) => options.stylize("null", "null"),
-  boolean: (value, options) => options.stylize(String(value), "boolean"),
-  Boolean: (value, options) => options.stylize(String(value), "boolean"),
+  undefined: /* @__PURE__ */ __name((value, options) => options.stylize("undefined", "undefined"), "undefined"),
+  null: /* @__PURE__ */ __name((value, options) => options.stylize("null", "null"), "null"),
+  boolean: /* @__PURE__ */ __name((value, options) => options.stylize(String(value), "boolean"), "boolean"),
+  Boolean: /* @__PURE__ */ __name((value, options) => options.stylize(String(value), "boolean"), "Boolean"),
   number: inspectNumber,
   Number: inspectNumber,
   bigint: inspectBigInt,
@@ -676,8 +722,8 @@ var baseTypesMap = {
   RegExp: inspectRegExp,
   Promise: promise_default,
   // WeakSet, WeakMap are totally opaque to us
-  WeakSet: (value, options) => options.stylize("WeakSet{\u2026}", "special"),
-  WeakMap: (value, options) => options.stylize("WeakMap{\u2026}", "special"),
+  WeakSet: /* @__PURE__ */ __name((value, options) => options.stylize("WeakSet{\u2026}", "special"), "WeakSet"),
+  WeakMap: /* @__PURE__ */ __name((value, options) => options.stylize("WeakMap{\u2026}", "special"), "WeakMap"),
   Arguments: inspectArguments,
   Int8Array: inspectTypedArray,
   Uint8Array: inspectTypedArray,
@@ -688,14 +734,14 @@ var baseTypesMap = {
   Uint32Array: inspectTypedArray,
   Float32Array: inspectTypedArray,
   Float64Array: inspectTypedArray,
-  Generator: () => "",
-  DataView: () => "",
-  ArrayBuffer: () => "",
+  Generator: /* @__PURE__ */ __name(() => "", "Generator"),
+  DataView: /* @__PURE__ */ __name(() => "", "DataView"),
+  ArrayBuffer: /* @__PURE__ */ __name(() => "", "ArrayBuffer"),
   Error: inspectObject2,
   HTMLCollection: inspectNodeCollection,
   NodeList: inspectNodeCollection
 };
-var inspectCustom = (value, options, type3) => {
+var inspectCustom = /* @__PURE__ */ __name((value, options, type3) => {
   if (chaiInspect in value && typeof value[chaiInspect] === "function") {
     return value[chaiInspect](options);
   }
@@ -712,7 +758,7 @@ var inspectCustom = (value, options, type3) => {
     return stringTagMap[type3](value, options);
   }
   return "";
-};
+}, "inspectCustom");
 var toString = Object.prototype.toString;
 function inspect(value, opts = {}) {
   const options = normaliseOptions(opts, inspect);
@@ -750,6 +796,7 @@ function inspect(value, opts = {}) {
   }
   return options.stylize(String(value), type3);
 }
+__name(inspect, "inspect");
 
 // lib/chai/config.js
 var config = {
@@ -870,6 +917,7 @@ function inspect2(obj, showHidden, depth, colors) {
   };
   return inspect(obj, options);
 }
+__name(inspect2, "inspect");
 
 // lib/chai/utils/objDisplay.js
 function objDisplay(obj) {
@@ -889,6 +937,7 @@ function objDisplay(obj) {
     return str;
   }
 }
+__name(objDisplay, "objDisplay");
 
 // lib/chai/utils/getMessage.js
 function getMessage2(obj, args) {
@@ -909,6 +958,7 @@ function getMessage2(obj, args) {
   });
   return flagMsg ? flagMsg + ": " + msg : msg;
 }
+__name(getMessage2, "getMessage");
 
 // lib/chai/utils/transferFlags.js
 function transferFlags(assertion, object, includeAll) {
@@ -923,6 +973,7 @@ function transferFlags(assertion, object, includeAll) {
     }
   }
 }
+__name(transferFlags, "transferFlags");
 
 // node_modules/deep-eql/index.js
 function type2(obj) {
@@ -940,21 +991,23 @@ function type2(obj) {
   const sliceEnd = -1;
   return Object.prototype.toString.call(obj).slice(sliceStart, sliceEnd);
 }
+__name(type2, "type");
 function FakeMap() {
   this._key = "chai/deep-eql__" + Math.random() + Date.now();
 }
+__name(FakeMap, "FakeMap");
 FakeMap.prototype = {
-  get: function get(key) {
+  get: /* @__PURE__ */ __name(function get(key) {
     return key[this._key];
-  },
-  set: function set(key, value) {
+  }, "get"),
+  set: /* @__PURE__ */ __name(function set(key, value) {
     if (Object.isExtensible(key)) {
       Object.defineProperty(key, this._key, {
         value,
         configurable: true
       });
     }
-  }
+  }, "set")
 };
 var MemoizeMap = typeof WeakMap === "function" ? WeakMap : FakeMap;
 function memoizeCompare(leftHandOperand, rightHandOperand, memoizeMap) {
@@ -970,6 +1023,7 @@ function memoizeCompare(leftHandOperand, rightHandOperand, memoizeMap) {
   }
   return null;
 }
+__name(memoizeCompare, "memoizeCompare");
 function memoizeSet(leftHandOperand, rightHandOperand, memoizeMap, result) {
   if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {
     return;
@@ -983,6 +1037,7 @@ function memoizeSet(leftHandOperand, rightHandOperand, memoizeMap, result) {
     memoizeMap.set(leftHandOperand, leftHandMap);
   }
 }
+__name(memoizeSet, "memoizeSet");
 var deep_eql_default = deepEqual;
 function deepEqual(leftHandOperand, rightHandOperand, options) {
   if (options && options.comparator) {
@@ -994,6 +1049,7 @@ function deepEqual(leftHandOperand, rightHandOperand, options) {
   }
   return extensiveDeepEqual(leftHandOperand, rightHandOperand, options);
 }
+__name(deepEqual, "deepEqual");
 function simpleEqual(leftHandOperand, rightHandOperand) {
   if (leftHandOperand === rightHandOperand) {
     return leftHandOperand !== 0 || 1 / leftHandOperand === 1 / rightHandOperand;
@@ -1007,6 +1063,7 @@ function simpleEqual(leftHandOperand, rightHandOperand) {
   }
   return null;
 }
+__name(simpleEqual, "simpleEqual");
 function extensiveDeepEqual(leftHandOperand, rightHandOperand, options) {
   options = options || {};
   options.memoize = options.memoize === false ? false : options.memoize || new MemoizeMap();
@@ -1040,6 +1097,7 @@ function extensiveDeepEqual(leftHandOperand, rightHandOperand, options) {
   memoizeSet(leftHandOperand, rightHandOperand, options.memoize, result);
   return result;
 }
+__name(extensiveDeepEqual, "extensiveDeepEqual");
 function extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options) {
   switch (leftHandType) {
     case "String":
@@ -1096,9 +1154,11 @@ function extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandTyp
       return objectEqual(leftHandOperand, rightHandOperand, options);
   }
 }
+__name(extensiveDeepEqualByType, "extensiveDeepEqualByType");
 function regexpEqual(leftHandOperand, rightHandOperand) {
   return leftHandOperand.toString() === rightHandOperand.toString();
 }
+__name(regexpEqual, "regexpEqual");
 function entriesEqual(leftHandOperand, rightHandOperand, options) {
   try {
     if (leftHandOperand.size !== rightHandOperand.size) {
@@ -1112,14 +1172,15 @@ function entriesEqual(leftHandOperand, rightHandOperand, options) {
   }
   var leftHandItems = [];
   var rightHandItems = [];
-  leftHandOperand.forEach(function gatherEntries(key, value) {
+  leftHandOperand.forEach(/* @__PURE__ */ __name(function gatherEntries(key, value) {
     leftHandItems.push([key, value]);
-  });
-  rightHandOperand.forEach(function gatherEntries(key, value) {
+  }, "gatherEntries"));
+  rightHandOperand.forEach(/* @__PURE__ */ __name(function gatherEntries(key, value) {
     rightHandItems.push([key, value]);
-  });
+  }, "gatherEntries"));
   return iterableEqual(leftHandItems.sort(), rightHandItems.sort(), options);
 }
+__name(entriesEqual, "entriesEqual");
 function iterableEqual(leftHandOperand, rightHandOperand, options) {
   var length = leftHandOperand.length;
   if (length !== rightHandOperand.length) {
@@ -1136,12 +1197,15 @@ function iterableEqual(leftHandOperand, rightHandOperand, options) {
   }
   return true;
 }
+__name(iterableEqual, "iterableEqual");
 function generatorEqual(leftHandOperand, rightHandOperand, options) {
   return iterableEqual(getGeneratorEntries(leftHandOperand), getGeneratorEntries(rightHandOperand), options);
 }
+__name(generatorEqual, "generatorEqual");
 function hasIteratorFunction(target) {
   return typeof Symbol !== "undefined" && typeof target === "object" && typeof Symbol.iterator !== "undefined" && typeof target[Symbol.iterator] === "function";
 }
+__name(hasIteratorFunction, "hasIteratorFunction");
 function getIteratorEntries(target) {
   if (hasIteratorFunction(target)) {
     try {
@@ -1152,6 +1216,7 @@ function getIteratorEntries(target) {
   }
   return [];
 }
+__name(getIteratorEntries, "getIteratorEntries");
 function getGeneratorEntries(generator) {
   var generatorResult = generator.next();
   var accumulator = [generatorResult.value];
@@ -1161,6 +1226,7 @@ function getGeneratorEntries(generator) {
   }
   return accumulator;
 }
+__name(getGeneratorEntries, "getGeneratorEntries");
 function getEnumerableKeys(target) {
   var keys = [];
   for (var key in target) {
@@ -1168,6 +1234,7 @@ function getEnumerableKeys(target) {
   }
   return keys;
 }
+__name(getEnumerableKeys, "getEnumerableKeys");
 function getEnumerableSymbols(target) {
   var keys = [];
   var allKeys = Object.getOwnPropertySymbols(target);
@@ -1179,6 +1246,7 @@ function getEnumerableSymbols(target) {
   }
   return keys;
 }
+__name(getEnumerableSymbols, "getEnumerableSymbols");
 function keysEqual(leftHandOperand, rightHandOperand, keys, options) {
   var length = keys.length;
   if (length === 0) {
@@ -1191,6 +1259,7 @@ function keysEqual(leftHandOperand, rightHandOperand, keys, options) {
   }
   return true;
 }
+__name(keysEqual, "keysEqual");
 function objectEqual(leftHandOperand, rightHandOperand, options) {
   var leftHandKeys = getEnumerableKeys(leftHandOperand);
   var rightHandKeys = getEnumerableKeys(rightHandOperand);
@@ -1216,17 +1285,20 @@ function objectEqual(leftHandOperand, rightHandOperand, options) {
   }
   return false;
 }
+__name(objectEqual, "objectEqual");
 function isPrimitive(value) {
   return value === null || typeof value !== "object";
 }
+__name(isPrimitive, "isPrimitive");
 function mapSymbols(arr) {
-  return arr.map(function mapSymbol(entry) {
+  return arr.map(/* @__PURE__ */ __name(function mapSymbol(entry) {
     if (typeof entry === "symbol") {
       return entry.toString();
     }
     return entry;
-  });
+  }, "mapSymbol"));
 }
+__name(mapSymbols, "mapSymbols");
 
 // node_modules/pathval/index.js
 function hasProperty(obj, name) {
@@ -1235,6 +1307,7 @@ function hasProperty(obj, name) {
   }
   return name in Object(obj);
 }
+__name(hasProperty, "hasProperty");
 function parsePath(path) {
   const str = path.replace(/([^\\])\[/g, "$1.[");
   const parts = str.match(/(\\\.|[^.]+?)+/g);
@@ -1253,6 +1326,7 @@ function parsePath(path) {
     return parsed;
   });
 }
+__name(parsePath, "parsePath");
 function internalGetPathValue(obj, parsed, pathDepth) {
   let temporaryValue = obj;
   let res = null;
@@ -1272,6 +1346,7 @@ function internalGetPathValue(obj, parsed, pathDepth) {
   }
   return res;
 }
+__name(internalGetPathValue, "internalGetPathValue");
 function getPathInfo(obj, path) {
   const parsed = parsePath(path);
   const last = parsed[parsed.length - 1];
@@ -1283,9 +1358,13 @@ function getPathInfo(obj, path) {
   info.exists = hasProperty(info.parent, info.name);
   return info;
 }
+__name(getPathInfo, "getPathInfo");
 
 // lib/chai/assertion.js
 var Assertion = class _Assertion {
+  static {
+    __name(this, "Assertion");
+  }
   /** @type {{}} */
   __flags = {};
   /**
@@ -1464,13 +1543,14 @@ var Assertion = class _Assertion {
 function isProxyEnabled() {
   return config.useProxy && typeof Proxy !== "undefined" && typeof Reflect !== "undefined";
 }
+__name(isProxyEnabled, "isProxyEnabled");
 
 // lib/chai/utils/addProperty.js
 function addProperty(ctx, name, getter) {
   getter = getter === void 0 ? function() {
   } : getter;
   Object.defineProperty(ctx, name, {
-    get: function propertyGetter() {
+    get: /* @__PURE__ */ __name(function propertyGetter() {
       if (!isProxyEnabled() && !flag(this, "lockSsfi")) {
         flag(this, "ssfi", propertyGetter);
       }
@@ -1479,10 +1559,11 @@ function addProperty(ctx, name, getter) {
       let newAssertion = new Assertion();
       transferFlags(this, newAssertion);
       return newAssertion;
-    },
+    }, "propertyGetter"),
     configurable: true
   });
 }
+__name(addProperty, "addProperty");
 
 // lib/chai/utils/addLengthGuard.js
 var fnLengthDesc = Object.getOwnPropertyDescriptor(function() {
@@ -1490,7 +1571,7 @@ var fnLengthDesc = Object.getOwnPropertyDescriptor(function() {
 function addLengthGuard(fn, assertionName, isChainable) {
   if (!fnLengthDesc.configurable) return fn;
   Object.defineProperty(fn, "length", {
-    get: function() {
+    get: /* @__PURE__ */ __name(function() {
       if (isChainable) {
         throw Error(
           "Invalid Chai property: " + assertionName + '.length. Due to a compatibility issue, "length" cannot directly follow "' + assertionName + '". Use "' + assertionName + '.lengthOf" instead.'
@@ -1499,10 +1580,11 @@ function addLengthGuard(fn, assertionName, isChainable) {
       throw Error(
         "Invalid Chai property: " + assertionName + '.length. See docs for proper usage of "' + assertionName + '".'
       );
-    }
+    }, "get")
   });
   return fn;
 }
+__name(addLengthGuard, "addLengthGuard");
 
 // lib/chai/utils/getProperties.js
 function getProperties(object) {
@@ -1512,6 +1594,7 @@ function getProperties(object) {
       result.push(property);
     }
   }
+  __name(addProperty2, "addProperty");
   let proto = Object.getPrototypeOf(object);
   while (proto !== null) {
     Object.getOwnPropertyNames(proto).forEach(addProperty2);
@@ -1519,13 +1602,14 @@ function getProperties(object) {
   }
   return result;
 }
+__name(getProperties, "getProperties");
 
 // lib/chai/utils/proxify.js
 var builtins = ["__flags", "__methods", "_obj", "assert"];
 function proxify(obj, nonChainableMethodName) {
   if (!isProxyEnabled()) return obj;
   return new Proxy(obj, {
-    get: function proxyGetter(target, property) {
+    get: /* @__PURE__ */ __name(function proxyGetter(target, property) {
       if (typeof property === "string" && config.proxyExcludedKeys.indexOf(property) === -1 && !Reflect.has(target, property)) {
         if (nonChainableMethodName) {
           throw Error(
@@ -1559,9 +1643,10 @@ function proxify(obj, nonChainableMethodName) {
         flag(target, "ssfi", proxyGetter);
       }
       return Reflect.get(target, property);
-    }
+    }, "proxyGetter")
   });
 }
+__name(proxify, "proxify");
 function stringDistanceCapped(strA, strB, cap) {
   if (Math.abs(strA.length - strB.length) >= cap) {
     return cap;
@@ -1590,10 +1675,11 @@ function stringDistanceCapped(strA, strB, cap) {
   }
   return memo[strA.length][strB.length];
 }
+__name(stringDistanceCapped, "stringDistanceCapped");
 
 // lib/chai/utils/addMethod.js
 function addMethod(ctx, name, method) {
-  let methodWrapper = function() {
+  let methodWrapper = /* @__PURE__ */ __name(function() {
     if (!flag(this, "lockSsfi")) {
       flag(this, "ssfi", methodWrapper);
     }
@@ -1602,18 +1688,19 @@ function addMethod(ctx, name, method) {
     let newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
-  };
+  }, "methodWrapper");
   addLengthGuard(methodWrapper, name, false);
   ctx[name] = proxify(methodWrapper, name);
 }
+__name(addMethod, "addMethod");
 
 // lib/chai/utils/overwriteProperty.js
 function overwriteProperty(ctx, name, getter) {
-  let _get = Object.getOwnPropertyDescriptor(ctx, name), _super = function() {
-  };
+  let _get = Object.getOwnPropertyDescriptor(ctx, name), _super = /* @__PURE__ */ __name(function() {
+  }, "_super");
   if (_get && "function" === typeof _get.get) _super = _get.get;
   Object.defineProperty(ctx, name, {
-    get: function overwritingPropertyGetter() {
+    get: /* @__PURE__ */ __name(function overwritingPropertyGetter() {
       if (!isProxyEnabled() && !flag(this, "lockSsfi")) {
         flag(this, "ssfi", overwritingPropertyGetter);
       }
@@ -1627,18 +1714,19 @@ function overwriteProperty(ctx, name, getter) {
       let newAssertion = new Assertion();
       transferFlags(this, newAssertion);
       return newAssertion;
-    },
+    }, "overwritingPropertyGetter"),
     configurable: true
   });
 }
+__name(overwriteProperty, "overwriteProperty");
 
 // lib/chai/utils/overwriteMethod.js
 function overwriteMethod(ctx, name, method) {
-  let _method = ctx[name], _super = function() {
+  let _method = ctx[name], _super = /* @__PURE__ */ __name(function() {
     throw new Error(name + " is not a function");
-  };
+  }, "_super");
   if (_method && "function" === typeof _method) _super = _method;
-  let overwritingMethodWrapper = function() {
+  let overwritingMethodWrapper = /* @__PURE__ */ __name(function() {
     if (!flag(this, "lockSsfi")) {
       flag(this, "ssfi", overwritingMethodWrapper);
     }
@@ -1652,15 +1740,16 @@ function overwriteMethod(ctx, name, method) {
     let newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
-  };
+  }, "overwritingMethodWrapper");
   addLengthGuard(overwritingMethodWrapper, name, false);
   ctx[name] = proxify(overwritingMethodWrapper, name);
 }
+__name(overwriteMethod, "overwriteMethod");
 
 // lib/chai/utils/addChainableMethod.js
 var canSetPrototype = typeof Object.setPrototypeOf === "function";
-var testFn = function() {
-};
+var testFn = /* @__PURE__ */ __name(function() {
+}, "testFn");
 var excludeNames = Object.getOwnPropertyNames(testFn).filter(function(name) {
   let propDesc = Object.getOwnPropertyDescriptor(testFn, name);
   if (typeof propDesc !== "object") return true;
@@ -1670,8 +1759,8 @@ var call = Function.prototype.call;
 var apply = Function.prototype.apply;
 function addChainableMethod(ctx, name, method, chainingBehavior) {
   if (typeof chainingBehavior !== "function") {
-    chainingBehavior = function() {
-    };
+    chainingBehavior = /* @__PURE__ */ __name(function() {
+    }, "chainingBehavior");
   }
   let chainableBehavior = {
     method,
@@ -1682,9 +1771,9 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
   }
   ctx.__methods[name] = chainableBehavior;
   Object.defineProperty(ctx, name, {
-    get: function chainableMethodGetter() {
+    get: /* @__PURE__ */ __name(function chainableMethodGetter() {
       chainableBehavior.chainingBehavior.call(this);
-      let chainableMethodWrapper = function() {
+      let chainableMethodWrapper = /* @__PURE__ */ __name(function() {
         if (!flag(this, "lockSsfi")) {
           flag(this, "ssfi", chainableMethodWrapper);
         }
@@ -1695,7 +1784,7 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
         let newAssertion = new Assertion();
         transferFlags(this, newAssertion);
         return newAssertion;
-      };
+      }, "chainableMethodWrapper");
       addLengthGuard(chainableMethodWrapper, name, true);
       if (canSetPrototype) {
         let prototype = Object.create(this);
@@ -1714,16 +1803,17 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
       }
       transferFlags(this, chainableMethodWrapper);
       return proxify(chainableMethodWrapper);
-    },
+    }, "chainableMethodGetter"),
     configurable: true
   });
 }
+__name(addChainableMethod, "addChainableMethod");
 
 // lib/chai/utils/overwriteChainableMethod.js
 function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
   let chainableBehavior = ctx.__methods[name];
   let _chainingBehavior = chainableBehavior.chainingBehavior;
-  chainableBehavior.chainingBehavior = function overwritingChainableMethodGetter() {
+  chainableBehavior.chainingBehavior = /* @__PURE__ */ __name(function overwritingChainableMethodGetter() {
     let result = chainingBehavior(_chainingBehavior).call(this);
     if (result !== void 0) {
       return result;
@@ -1731,9 +1821,9 @@ function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
     let newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
-  };
+  }, "overwritingChainableMethodGetter");
   let _method = chainableBehavior.method;
-  chainableBehavior.method = function overwritingChainableMethodWrapper() {
+  chainableBehavior.method = /* @__PURE__ */ __name(function overwritingChainableMethodWrapper() {
     let result = method(_method).apply(this, arguments);
     if (result !== void 0) {
       return result;
@@ -1741,13 +1831,15 @@ function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
     let newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
-  };
+  }, "overwritingChainableMethodWrapper");
 }
+__name(overwriteChainableMethod, "overwriteChainableMethod");
 
 // lib/chai/utils/compareByInspect.js
 function compareByInspect(a, b) {
   return inspect2(a) < inspect2(b) ? -1 : 1;
 }
+__name(compareByInspect, "compareByInspect");
 
 // lib/chai/utils/getOwnEnumerablePropertySymbols.js
 function getOwnEnumerablePropertySymbols(obj) {
@@ -1756,11 +1848,13 @@ function getOwnEnumerablePropertySymbols(obj) {
     return Object.getOwnPropertyDescriptor(obj, sym).enumerable;
   });
 }
+__name(getOwnEnumerablePropertySymbols, "getOwnEnumerablePropertySymbols");
 
 // lib/chai/utils/getOwnEnumerableProperties.js
 function getOwnEnumerableProperties(obj) {
   return Object.keys(obj).concat(getOwnEnumerablePropertySymbols(obj));
 }
+__name(getOwnEnumerableProperties, "getOwnEnumerableProperties");
 
 // lib/chai/utils/isNaN.js
 var isNaN2 = Number.isNaN;
@@ -1771,6 +1865,7 @@ function isObjectType(obj) {
   let objectTypes = ["Array", "Object", "Function"];
   return objectTypes.indexOf(objectType) !== -1;
 }
+__name(isObjectType, "isObjectType");
 function getOperator(obj, args) {
   let operator = flag(obj, "operator");
   let negate = flag(obj, "negate");
@@ -1793,17 +1888,21 @@ function getOperator(obj, args) {
   }
   return isObject ? "deepStrictEqual" : "strictEqual";
 }
+__name(getOperator, "getOperator");
 
 // lib/chai/utils/index.js
 function getName(fn) {
   return fn.name;
 }
+__name(getName, "getName");
 function isRegExp2(obj) {
   return Object.prototype.toString.call(obj) === "[object RegExp]";
 }
+__name(isRegExp2, "isRegExp");
 function isNumeric(obj) {
   return ["Number", "BigInt"].includes(type(obj));
 }
+__name(isNumeric, "isNumeric");
 
 // lib/chai/core/assertions.js
 var { flag: flag2 } = utils_exports;
@@ -1881,14 +1980,17 @@ function an(type3, msg) {
     );
   }
 }
+__name(an, "an");
 Assertion.addChainableMethod("an", an);
 Assertion.addChainableMethod("a", an);
 function SameValueZero(a, b) {
   return isNaN2(a) && isNaN2(b) || a === b;
 }
+__name(SameValueZero, "SameValueZero");
 function includeChainingBehavior() {
   flag2(this, "contains", true);
 }
+__name(includeChainingBehavior, "includeChainingBehavior");
 function include(val, msg) {
   if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), negate = flag2(this, "negate"), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), descriptor = isDeep ? "deep " : "", isEql = isDeep ? flag2(this, "eql") : SameValueZero;
@@ -1972,6 +2074,7 @@ function include(val, msg) {
     "expected #{this} to not " + descriptor + "include " + inspect2(val)
   );
 }
+__name(include, "include");
 Assertion.addChainableMethod("include", include, includeChainingBehavior);
 Assertion.addChainableMethod("contain", include, includeChainingBehavior);
 Assertion.addChainableMethod("contains", include, includeChainingBehavior);
@@ -2054,6 +2157,7 @@ function assertExist() {
     "expected #{this} to not exist"
   );
 }
+__name(assertExist, "assertExist");
 Assertion.addProperty("exist", assertExist);
 Assertion.addProperty("exists", assertExist);
 Assertion.addProperty("empty", function() {
@@ -2103,6 +2207,7 @@ function checkArguments() {
     "expected #{this} to not be arguments"
   );
 }
+__name(checkArguments, "checkArguments");
 Assertion.addProperty("arguments", checkArguments);
 Assertion.addProperty("Arguments", checkArguments);
 function assertEqual(val, msg) {
@@ -2124,6 +2229,7 @@ function assertEqual(val, msg) {
     );
   }
 }
+__name(assertEqual, "assertEqual");
 Assertion.addMethod("equal", assertEqual);
 Assertion.addMethod("equals", assertEqual);
 Assertion.addMethod("eq", assertEqual);
@@ -2139,6 +2245,7 @@ function assertEql(obj, msg) {
     true
   );
 }
+__name(assertEql, "assertEql");
 Assertion.addMethod("eql", assertEql);
 Assertion.addMethod("eqls", assertEql);
 function assertAbove(n, msg) {
@@ -2191,6 +2298,7 @@ function assertAbove(n, msg) {
     );
   }
 }
+__name(assertAbove, "assertAbove");
 Assertion.addMethod("above", assertAbove);
 Assertion.addMethod("gt", assertAbove);
 Assertion.addMethod("greaterThan", assertAbove);
@@ -2237,6 +2345,7 @@ function assertLeast(n, msg) {
     );
   }
 }
+__name(assertLeast, "assertLeast");
 Assertion.addMethod("least", assertLeast);
 Assertion.addMethod("gte", assertLeast);
 Assertion.addMethod("greaterThanOrEqual", assertLeast);
@@ -2283,6 +2392,7 @@ function assertBelow(n, msg) {
     );
   }
 }
+__name(assertBelow, "assertBelow");
 Assertion.addMethod("below", assertBelow);
 Assertion.addMethod("lt", assertBelow);
 Assertion.addMethod("lessThan", assertBelow);
@@ -2329,6 +2439,7 @@ function assertMost(n, msg) {
     );
   }
 }
+__name(assertMost, "assertMost");
 Assertion.addMethod("most", assertMost);
 Assertion.addMethod("lte", assertMost);
 Assertion.addMethod("lessThanOrEqual", assertMost);
@@ -2401,6 +2512,7 @@ function assertInstanceOf(constructor, msg) {
     "expected #{this} to not be an instance of " + name
   );
 }
+__name(assertInstanceOf, "assertInstanceOf");
 Assertion.addMethod("instanceof", assertInstanceOf);
 Assertion.addMethod("instanceOf", assertInstanceOf);
 function assertProperty(name, val, msg) {
@@ -2466,11 +2578,13 @@ function assertProperty(name, val, msg) {
   }
   flag2(this, "object", value);
 }
+__name(assertProperty, "assertProperty");
 Assertion.addMethod("property", assertProperty);
 function assertOwnProperty(_name, _value, _msg) {
   flag2(this, "own", true);
   assertProperty.apply(this, arguments);
 }
+__name(assertOwnProperty, "assertOwnProperty");
 Assertion.addMethod("ownProperty", assertOwnProperty);
 Assertion.addMethod("haveOwnProperty", assertOwnProperty);
 function assertOwnPropertyDescriptor(name, descriptor, msg) {
@@ -2500,11 +2614,13 @@ function assertOwnPropertyDescriptor(name, descriptor, msg) {
   }
   flag2(this, "object", actualDescriptor);
 }
+__name(assertOwnPropertyDescriptor, "assertOwnPropertyDescriptor");
 Assertion.addMethod("ownPropertyDescriptor", assertOwnPropertyDescriptor);
 Assertion.addMethod("haveOwnPropertyDescriptor", assertOwnPropertyDescriptor);
 function assertLengthChain() {
   flag2(this, "doLength", true);
 }
+__name(assertLengthChain, "assertLengthChain");
 function assertLength(n, msg) {
   if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), descriptor = "length", itemsCount;
@@ -2526,6 +2642,7 @@ function assertLength(n, msg) {
     itemsCount
   );
 }
+__name(assertLength, "assertLength");
 Assertion.addChainableMethod("length", assertLength, assertLengthChain);
 Assertion.addChainableMethod("lengthOf", assertLength, assertLengthChain);
 function assertMatch(re, msg) {
@@ -2537,6 +2654,7 @@ function assertMatch(re, msg) {
     "expected #{this} not to match " + re
   );
 }
+__name(assertMatch, "assertMatch");
 Assertion.addMethod("match", assertMatch);
 Assertion.addMethod("matches", assertMatch);
 Assertion.addMethod("string", function(str, msg) {
@@ -2632,6 +2750,7 @@ function assertKeys(keys) {
     true
   );
 }
+__name(assertKeys, "assertKeys");
 Assertion.addMethod("keys", assertKeys);
 Assertion.addMethod("key", assertKeys);
 function assertThrows(errorLike, errMsgMatcher, msg) {
@@ -2752,6 +2871,7 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
   }
   flag2(this, "object", caughtErr);
 }
+__name(assertThrows, "assertThrows");
 Assertion.addMethod("throw", assertThrows);
 Assertion.addMethod("throws", assertThrows);
 Assertion.addMethod("Throw", assertThrows);
@@ -2764,6 +2884,7 @@ function respondTo(method, msg) {
     "expected #{this} to not respond to " + inspect2(method)
   );
 }
+__name(respondTo, "respondTo");
 Assertion.addMethod("respondTo", respondTo);
 Assertion.addMethod("respondsTo", respondTo);
 Assertion.addProperty("itself", function() {
@@ -2781,6 +2902,7 @@ function satisfy(matcher, msg) {
     result
   );
 }
+__name(satisfy, "satisfy");
 Assertion.addMethod("satisfy", satisfy);
 Assertion.addMethod("satisfies", satisfy);
 function closeTo(expected, delta, msg) {
@@ -2805,14 +2927,15 @@ function closeTo(expected, delta, msg) {
     );
   }
   new Assertion(expected, flagMsg, ssfi, true).is.numeric;
-  const abs = (x) => x < 0n ? -x : x;
-  const strip = (number) => parseFloat(parseFloat(number).toPrecision(12));
+  const abs = /* @__PURE__ */ __name((x) => x < 0n ? -x : x, "abs");
+  const strip = /* @__PURE__ */ __name((number) => parseFloat(parseFloat(number).toPrecision(12)), "strip");
   this.assert(
     strip(abs(obj - expected)) <= delta,
     "expected #{this} to be close to " + expected + " +/- " + delta,
     "expected #{this} not to be close to " + expected + " +/- " + delta
   );
 }
+__name(closeTo, "closeTo");
 Assertion.addMethod("closeTo", closeTo);
 Assertion.addMethod("approximately", closeTo);
 function isSubsetOf(_subset, _superset, cmp, contains, ordered) {
@@ -2837,6 +2960,7 @@ function isSubsetOf(_subset, _superset, cmp, contains, ordered) {
     });
   });
 }
+__name(isSubsetOf, "isSubsetOf");
 Assertion.addMethod("members", function(subset, msg) {
   if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
@@ -2910,6 +3034,7 @@ function oneOf(list, msg) {
     }
   }
 }
+__name(oneOf, "oneOf");
 Assertion.addMethod("oneOf", oneOf);
 function assertChanges(subject, prop, msg) {
   if (msg) flag2(this, "message", msg);
@@ -2937,6 +3062,7 @@ function assertChanges(subject, prop, msg) {
     "expected " + msgObj + " to not change"
   );
 }
+__name(assertChanges, "assertChanges");
 Assertion.addMethod("change", assertChanges);
 Assertion.addMethod("changes", assertChanges);
 function assertIncreases(subject, prop, msg) {
@@ -2966,6 +3092,7 @@ function assertIncreases(subject, prop, msg) {
     "expected " + msgObj + " to not increase"
   );
 }
+__name(assertIncreases, "assertIncreases");
 Assertion.addMethod("increase", assertIncreases);
 Assertion.addMethod("increases", assertIncreases);
 function assertDecreases(subject, prop, msg) {
@@ -2995,6 +3122,7 @@ function assertDecreases(subject, prop, msg) {
     "expected " + msgObj + " to not decrease"
   );
 }
+__name(assertDecreases, "assertDecreases");
 Assertion.addMethod("decrease", assertDecreases);
 Assertion.addMethod("decreases", assertDecreases);
 function assertDelta(delta, msg) {
@@ -3016,6 +3144,7 @@ function assertDelta(delta, msg) {
     "expected " + msgObj + " to not " + behavior + " by " + delta
   );
 }
+__name(assertDelta, "assertDelta");
 Assertion.addMethod("by", assertDelta);
 Assertion.addProperty("extensible", function() {
   let obj = flag2(this, "object");
@@ -3094,6 +3223,7 @@ function compareSubset(expected, actual) {
     return actualValue === expectedValue;
   });
 }
+__name(compareSubset, "compareSubset");
 Assertion.addMethod("containSubset", function(expected) {
   const actual = flag(this, "object");
   const showDiff = config.showDiff;
@@ -3111,6 +3241,7 @@ Assertion.addMethod("containSubset", function(expected) {
 function expect(val, message) {
   return new Assertion(val, message);
 }
+__name(expect, "expect");
 expect.fail = function(actual, expected, message, operator) {
   if (arguments.length < 2) {
     message = actual;
@@ -3141,6 +3272,7 @@ function loadShould() {
     }
     return new Assertion(this, null, shouldGetter);
   }
+  __name(shouldGetter, "shouldGetter");
   function shouldSetter(value) {
     Object.defineProperty(this, "should", {
       value,
@@ -3149,6 +3281,7 @@ function loadShould() {
       writable: true
     });
   }
+  __name(shouldSetter, "shouldSetter");
   Object.defineProperty(Object.prototype, "should", {
     set: shouldSetter,
     get: shouldGetter,
@@ -3194,6 +3327,7 @@ function loadShould() {
   should2.not["throw"] = should2.not["Throw"];
   return should2;
 }
+__name(loadShould, "loadShould");
 var should = loadShould;
 var Should = loadShould;
 
@@ -3202,6 +3336,7 @@ function assert(express, errmsg) {
   let test2 = new Assertion(null, null, assert, true);
   test2.assert(express, errmsg, "[ negation message unavailable ]");
 }
+__name(assert, "assert");
 assert.fail = function(actual, expected, message, operator) {
   if (arguments.length < 2) {
     message = actual;
@@ -3992,6 +4127,7 @@ function use(fn) {
   }
   return exports;
 }
+__name(use, "use");
 export {
   Assertion,
   AssertionError,

package/package.json

@@ -24,7 +24,7 @@
     "Veselin Todorov <hi@vesln.com>",
     "John Firebaugh <john.firebaugh@gmail.com>"
   ],
-  "version": "5.3.2",
+  "version": "5.3.3",
   "repository": {
     "type": "git",
     "url": "https://github.com/chaijs/chai"
@@ -34,7 +34,7 @@
   },
   "main": "./index.js",
   "scripts": {
-    "build": "esbuild --bundle --format=esm --outfile=index.js lib/chai.js",
+    "build": "esbuild --bundle --format=esm --keep-names --outfile=index.js lib/chai.js",
     "prebuild": "npm run clean",
     "format": "prettier --write lib",
     "pretest": "npm run lint",