@mastra/evals 0.14.1-alpha.0 → 0.14.1-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. package/CHANGELOG.md +9 -0
  2. package/dist/{dist-KKO3PIUK.cjs → dist-LDTK3TIP.cjs} +1206 -1198
  3. package/dist/dist-LDTK3TIP.cjs.map +1 -0
  4. package/dist/{dist-E463LOAZ.js → dist-OWYZEOJK.js} +1206 -1198
  5. package/dist/dist-OWYZEOJK.js.map +1 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.js +1 -1
  8. package/package.json +4 -4
  9. package/dist/dist-E463LOAZ.js.map +0 -1
  10. package/dist/dist-KKO3PIUK.cjs.map +0 -1
package/dist/{dist-E463LOAZ.js → dist-OWYZEOJK.js} RENAMED
@@ -420,49 +420,49 @@ var require_js_tokens = __commonJS({
420
420
  }
421
421
  });
422
422
 
423
- // ../../node_modules/.pnpm/expect-type@1.2.1/node_modules/expect-type/dist/branding.js
423
+ // ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/branding.js
424
424
  var require_branding = __commonJS({
425
- "../../node_modules/.pnpm/expect-type@1.2.1/node_modules/expect-type/dist/branding.js"(exports) {
425
+ "../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/branding.js"(exports) {
426
426
  Object.defineProperty(exports, "__esModule", { value: true });
427
427
  }
428
428
  });
429
429
 
430
- // ../../node_modules/.pnpm/expect-type@1.2.1/node_modules/expect-type/dist/messages.js
430
+ // ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/messages.js
431
431
  var require_messages = __commonJS({
432
- "../../node_modules/.pnpm/expect-type@1.2.1/node_modules/expect-type/dist/messages.js"(exports) {
432
+ "../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/messages.js"(exports) {
433
433
  Object.defineProperty(exports, "__esModule", { value: true });
434
434
  }
435
435
  });
436
436
 
437
- // ../../node_modules/.pnpm/expect-type@1.2.1/node_modules/expect-type/dist/overloads.js
437
+ // ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/overloads.js
438
438
  var require_overloads = __commonJS({
439
- "../../node_modules/.pnpm/expect-type@1.2.1/node_modules/expect-type/dist/overloads.js"(exports) {
439
+ "../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/overloads.js"(exports) {
440
440
  Object.defineProperty(exports, "__esModule", { value: true });
441
441
  }
442
442
  });
443
443
 
444
- // ../../node_modules/.pnpm/expect-type@1.2.1/node_modules/expect-type/dist/utils.js
444
+ // ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/utils.js
445
445
  var require_utils = __commonJS({
446
- "../../node_modules/.pnpm/expect-type@1.2.1/node_modules/expect-type/dist/utils.js"(exports) {
446
+ "../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/utils.js"(exports) {
447
447
  Object.defineProperty(exports, "__esModule", { value: true });
448
448
  }
449
449
  });
450
450
 
451
- // ../../node_modules/.pnpm/expect-type@1.2.1/node_modules/expect-type/dist/index.js
451
+ // ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/index.js
452
452
  var require_dist = __commonJS({
453
- "../../node_modules/.pnpm/expect-type@1.2.1/node_modules/expect-type/dist/index.js"(exports) {
454
- var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
455
- if (k2 === void 0) k2 = k;
456
- var desc = Object.getOwnPropertyDescriptor(m2, k);
453
+ "../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/index.js"(exports) {
454
+ var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k2, k22) {
455
+ if (k22 === void 0) k22 = k2;
456
+ var desc = Object.getOwnPropertyDescriptor(m2, k2);
457
457
  if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
458
458
  desc = { enumerable: true, get: function() {
459
- return m2[k];
459
+ return m2[k2];
460
460
  } };
461
461
  }
462
- Object.defineProperty(o, k2, desc);
463
- }) : (function(o, m2, k, k2) {
464
- if (k2 === void 0) k2 = k;
465
- o[k2] = m2[k];
462
+ Object.defineProperty(o, k22, desc);
463
+ }) : (function(o, m2, k2, k22) {
464
+ if (k22 === void 0) k22 = k2;
465
+ o[k22] = m2[k2];
466
466
  }));
467
467
  var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
468
468
  for (var p3 in m2) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p3)) __createBinding(exports2, m2, p3);
@@ -583,27 +583,27 @@ function C(n = false) {
583
583
  }
584
584
  function p(n = false) {
585
585
  let e = C(n), i = (r2, t, c, o) => {
586
- let l = "", s2 = 0;
586
+ let l2 = "", s2 = 0;
587
587
  do
588
- l += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
588
+ l2 += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
589
589
  while (~o);
590
- return l + r2.substring(s2);
590
+ return l2 + r2.substring(s2);
591
591
  }, g = (r2, t, c = r2) => {
592
- let o = (l) => {
593
- let s2 = String(l), b = s2.indexOf(t, r2.length);
594
- return ~b ? r2 + i(s2, t, c, b) + t : r2 + s2 + t;
592
+ let o = (l2) => {
593
+ let s2 = String(l2), b2 = s2.indexOf(t, r2.length);
594
+ return ~b2 ? r2 + i(s2, t, c, b2) + t : r2 + s2 + t;
595
595
  };
596
596
  return o.open = r2, o.close = t, o;
597
- }, u2 = {
597
+ }, u3 = {
598
598
  isColorSupported: e
599
599
  }, d = (r2) => `\x1B[${r2}m`;
600
600
  for (let [r2, t] of h)
601
- u2[r2] = e ? g(
601
+ u3[r2] = e ? g(
602
602
  d(t[0]),
603
603
  d(t[1]),
604
604
  t[2]
605
605
  ) : a;
606
- return u2;
606
+ return u3;
607
607
  }
608
608
  var r = process.env.FORCE_TTY !== void 0 || isatty(1);
609
609
  var u = p(r);
@@ -611,13 +611,13 @@ var u = p(r);
611
611
  // ../../node_modules/.pnpm/@vitest+pretty-format@3.2.4/node_modules/@vitest/pretty-format/dist/index.js
612
612
  function _mergeNamespaces(n, m2) {
613
613
  m2.forEach(function(e) {
614
- e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
615
- if (k !== "default" && !(k in n)) {
616
- var d = Object.getOwnPropertyDescriptor(e, k);
617
- Object.defineProperty(n, k, d.get ? d : {
614
+ e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k2) {
615
+ if (k2 !== "default" && !(k2 in n)) {
616
+ var d = Object.getOwnPropertyDescriptor(e, k2);
617
+ Object.defineProperty(n, k2, d.get ? d : {
618
618
  enumerable: true,
619
619
  get: function() {
620
- return e[k];
620
+ return e[k2];
621
621
  }
622
622
  });
623
623
  }
@@ -692,7 +692,7 @@ function printIteratorValues(iterator, config2, indentation, depth, refs, printe
692
692
  function printListItems(list, config2, indentation, depth, refs, printer2) {
693
693
  let result = "";
694
694
  list = list instanceof ArrayBuffer ? new DataView(list) : list;
695
- const isDataView = (l) => l instanceof DataView;
695
+ const isDataView = (l2) => l2 instanceof DataView;
696
696
  const length = isDataView(list) ? list.byteLength : list.length;
697
697
  if (length > 0) {
698
698
  result += config2.spacingOuter;
@@ -953,8 +953,8 @@ var plugin$2 = {
953
953
  serialize: serialize$2,
954
954
  test: test$2
955
955
  };
956
- function getDefaultExportFromCjs(x) {
957
- return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
956
+ function getDefaultExportFromCjs(x2) {
957
+ return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
958
958
  }
959
959
  var reactIs$1 = { exports: {} };
960
960
  var reactIs_production = {};
@@ -1166,25 +1166,25 @@ var hasRequiredReactIs_production_min;
1166
1166
  function requireReactIs_production_min() {
1167
1167
  if (hasRequiredReactIs_production_min) return reactIs_production_min;
1168
1168
  hasRequiredReactIs_production_min = 1;
1169
- var b = Symbol.for("react.element"), c = Symbol.for("react.portal"), d = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f3 = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), h3 = Symbol.for("react.context"), k = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m2 = Symbol.for("react.suspense"), n = Symbol.for("react.suspense_list"), p3 = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u2;
1170
- u2 = Symbol.for("react.module.reference");
1171
- function v(a3) {
1169
+ var b2 = Symbol.for("react.element"), c = Symbol.for("react.portal"), d = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f4 = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), h4 = Symbol.for("react.context"), k2 = Symbol.for("react.server_context"), l2 = Symbol.for("react.forward_ref"), m2 = Symbol.for("react.suspense"), n = Symbol.for("react.suspense_list"), p3 = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u3;
1170
+ u3 = Symbol.for("react.module.reference");
1171
+ function v2(a3) {
1172
1172
  if ("object" === typeof a3 && null !== a3) {
1173
1173
  var r2 = a3.$$typeof;
1174
1174
  switch (r2) {
1175
- case b:
1175
+ case b2:
1176
1176
  switch (a3 = a3.type, a3) {
1177
1177
  case d:
1178
- case f3:
1178
+ case f4:
1179
1179
  case e:
1180
1180
  case m2:
1181
1181
  case n:
1182
1182
  return a3;
1183
1183
  default:
1184
1184
  switch (a3 = a3 && a3.$$typeof, a3) {
1185
- case k:
1186
- case h3:
1187
- case l:
1185
+ case k2:
1186
+ case h4:
1187
+ case l2:
1188
1188
  case q:
1189
1189
  case p3:
1190
1190
  case g:
@@ -1198,15 +1198,15 @@ function requireReactIs_production_min() {
1198
1198
  }
1199
1199
  }
1200
1200
  }
1201
- reactIs_production_min.ContextConsumer = h3;
1201
+ reactIs_production_min.ContextConsumer = h4;
1202
1202
  reactIs_production_min.ContextProvider = g;
1203
- reactIs_production_min.Element = b;
1204
- reactIs_production_min.ForwardRef = l;
1203
+ reactIs_production_min.Element = b2;
1204
+ reactIs_production_min.ForwardRef = l2;
1205
1205
  reactIs_production_min.Fragment = d;
1206
1206
  reactIs_production_min.Lazy = q;
1207
1207
  reactIs_production_min.Memo = p3;
1208
1208
  reactIs_production_min.Portal = c;
1209
- reactIs_production_min.Profiler = f3;
1209
+ reactIs_production_min.Profiler = f4;
1210
1210
  reactIs_production_min.StrictMode = e;
1211
1211
  reactIs_production_min.Suspense = m2;
1212
1212
  reactIs_production_min.SuspenseList = n;
@@ -1217,45 +1217,45 @@ function requireReactIs_production_min() {
1217
1217
  return false;
1218
1218
  };
1219
1219
  reactIs_production_min.isContextConsumer = function(a3) {
1220
- return v(a3) === h3;
1220
+ return v2(a3) === h4;
1221
1221
  };
1222
1222
  reactIs_production_min.isContextProvider = function(a3) {
1223
- return v(a3) === g;
1223
+ return v2(a3) === g;
1224
1224
  };
1225
1225
  reactIs_production_min.isElement = function(a3) {
1226
- return "object" === typeof a3 && null !== a3 && a3.$$typeof === b;
1226
+ return "object" === typeof a3 && null !== a3 && a3.$$typeof === b2;
1227
1227
  };
1228
1228
  reactIs_production_min.isForwardRef = function(a3) {
1229
- return v(a3) === l;
1229
+ return v2(a3) === l2;
1230
1230
  };
1231
1231
  reactIs_production_min.isFragment = function(a3) {
1232
- return v(a3) === d;
1232
+ return v2(a3) === d;
1233
1233
  };
1234
1234
  reactIs_production_min.isLazy = function(a3) {
1235
- return v(a3) === q;
1235
+ return v2(a3) === q;
1236
1236
  };
1237
1237
  reactIs_production_min.isMemo = function(a3) {
1238
- return v(a3) === p3;
1238
+ return v2(a3) === p3;
1239
1239
  };
1240
1240
  reactIs_production_min.isPortal = function(a3) {
1241
- return v(a3) === c;
1241
+ return v2(a3) === c;
1242
1242
  };
1243
1243
  reactIs_production_min.isProfiler = function(a3) {
1244
- return v(a3) === f3;
1244
+ return v2(a3) === f4;
1245
1245
  };
1246
1246
  reactIs_production_min.isStrictMode = function(a3) {
1247
- return v(a3) === e;
1247
+ return v2(a3) === e;
1248
1248
  };
1249
1249
  reactIs_production_min.isSuspense = function(a3) {
1250
- return v(a3) === m2;
1250
+ return v2(a3) === m2;
1251
1251
  };
1252
1252
  reactIs_production_min.isSuspenseList = function(a3) {
1253
- return v(a3) === n;
1253
+ return v2(a3) === n;
1254
1254
  };
1255
1255
  reactIs_production_min.isValidElementType = function(a3) {
1256
- return "string" === typeof a3 || "function" === typeof a3 || a3 === d || a3 === f3 || a3 === e || a3 === m2 || a3 === n || a3 === t || "object" === typeof a3 && null !== a3 && (a3.$$typeof === q || a3.$$typeof === p3 || a3.$$typeof === g || a3.$$typeof === h3 || a3.$$typeof === l || a3.$$typeof === u2 || void 0 !== a3.getModuleId) ? true : false;
1256
+ return "string" === typeof a3 || "function" === typeof a3 || a3 === d || a3 === f4 || a3 === e || a3 === m2 || a3 === n || a3 === t || "object" === typeof a3 && null !== a3 && (a3.$$typeof === q || a3.$$typeof === p3 || a3.$$typeof === g || a3.$$typeof === h4 || a3.$$typeof === l2 || a3.$$typeof === u3 || void 0 !== a3.getModuleId) ? true : false;
1257
1257
  };
1258
- reactIs_production_min.typeOf = v;
1258
+ reactIs_production_min.typeOf = v2;
1259
1259
  return reactIs_production_min;
1260
1260
  }
1261
1261
  var reactIs_development = {};
@@ -1473,7 +1473,7 @@ var reactIsMethods = [
1473
1473
  "isSuspenseList",
1474
1474
  "isValidElementType"
1475
1475
  ];
1476
- var ReactIs = Object.fromEntries(reactIsMethods.map((m2) => [m2, (v) => ReactIs18[m2](v) || ReactIs19[m2](v)]));
1476
+ var ReactIs = Object.fromEntries(reactIsMethods.map((m2) => [m2, (v2) => ReactIs18[m2](v2) || ReactIs19[m2](v2)]));
1477
1477
  function getChildren(arg, children = []) {
1478
1478
  if (Array.isArray(arg)) {
1479
1479
  for (const item of arg) {
@@ -1840,7 +1840,7 @@ var plugins = {
1840
1840
  Error: ErrorPlugin
1841
1841
  };
1842
1842
 
1843
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/helpers.js
1843
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/helpers.js
1844
1844
  var ansiColors = {
1845
1845
  bold: ["1", "22"],
1846
1846
  dim: ["2", "22"],
@@ -1995,7 +1995,7 @@ function inspectProperty([key, value], options) {
1995
1995
  return `${key}: ${value}`;
1996
1996
  }
1997
1997
 
1998
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/array.js
1998
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/array.js
1999
1999
  function inspectArray(array2, options) {
2000
2000
  const nonIndexProperties = Object.keys(array2).slice(array2.length);
2001
2001
  if (!array2.length && !nonIndexProperties.length)
@@ -2010,7 +2010,7 @@ function inspectArray(array2, options) {
2010
2010
  return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ""} ]`;
2011
2011
  }
2012
2012
 
2013
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/typedarray.js
2013
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/typedarray.js
2014
2014
  var getArrayName = (array2) => {
2015
2015
  if (typeof Buffer === "function" && array2 instanceof Buffer) {
2016
2016
  return "Buffer";
@@ -2043,7 +2043,7 @@ function inspectTypedArray(array2, options) {
2043
2043
  return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`;
2044
2044
  }
2045
2045
 
2046
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/date.js
2046
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/date.js
2047
2047
  function inspectDate(dateObject, options) {
2048
2048
  const stringRepresentation = dateObject.toJSON();
2049
2049
  if (stringRepresentation === null) {
@@ -2054,7 +2054,7 @@ function inspectDate(dateObject, options) {
2054
2054
  return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, "date");
2055
2055
  }
2056
2056
 
2057
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/function.js
2057
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/function.js
2058
2058
  function inspectFunction(func, options) {
2059
2059
  const functionType = func[Symbol.toStringTag] || "Function";
2060
2060
  const name = func.name;
@@ -2064,7 +2064,7 @@ function inspectFunction(func, options) {
2064
2064
  return options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, "special");
2065
2065
  }
2066
2066
 
2067
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/map.js
2067
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/map.js
2068
2068
  function inspectMapEntry([key, value], options) {
2069
2069
  options.truncate -= 4;
2070
2070
  key = options.inspect(key, options);
@@ -2086,7 +2086,7 @@ function inspectMap(map2, options) {
2086
2086
  return `Map{ ${inspectList(mapToEntries(map2), options, inspectMapEntry)} }`;
2087
2087
  }
2088
2088
 
2089
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/number.js
2089
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/number.js
2090
2090
  var isNaN = Number.isNaN || ((i) => i !== i);
2091
2091
  function inspectNumber(number, options) {
2092
2092
  if (isNaN(number)) {
@@ -2104,7 +2104,7 @@ function inspectNumber(number, options) {
2104
2104
  return options.stylize(truncate(String(number), options.truncate), "number");
2105
2105
  }
2106
2106
 
2107
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/bigint.js
2107
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/bigint.js
2108
2108
  function inspectBigInt(number, options) {
2109
2109
  let nums = truncate(number.toString(), options.truncate - 1);
2110
2110
  if (nums !== truncator)
@@ -2112,7 +2112,7 @@ function inspectBigInt(number, options) {
2112
2112
  return options.stylize(nums, "bigint");
2113
2113
  }
2114
2114
 
2115
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/regexp.js
2115
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/regexp.js
2116
2116
  function inspectRegExp(value, options) {
2117
2117
  const flags = value.toString().split("/")[2];
2118
2118
  const sourceLength = options.truncate - (2 + flags.length);
@@ -2120,7 +2120,7 @@ function inspectRegExp(value, options) {
2120
2120
  return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, "regexp");
2121
2121
  }
2122
2122
 
2123
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/set.js
2123
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/set.js
2124
2124
  function arrayFromSet(set3) {
2125
2125
  const values = [];
2126
2126
  set3.forEach((value) => {
@@ -2135,7 +2135,7 @@ function inspectSet(set3, options) {
2135
2135
  return `Set{ ${inspectList(arrayFromSet(set3), options)} }`;
2136
2136
  }
2137
2137
 
2138
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/string.js
2138
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/string.js
2139
2139
  var stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g");
2140
2140
  var escapeCharacters = {
2141
2141
  "\b": "\\b",
@@ -2157,7 +2157,7 @@ function inspectString(string2, options) {
2157
2157
  return options.stylize(`'${truncate(string2, options.truncate - 2)}'`, "string");
2158
2158
  }
2159
2159
 
2160
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/symbol.js
2160
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/symbol.js
2161
2161
  function inspectSymbol(value) {
2162
2162
  if ("description" in Symbol.prototype) {
2163
2163
  return value.description ? `Symbol(${value.description})` : "Symbol()";
@@ -2165,24 +2165,11 @@ function inspectSymbol(value) {
2165
2165
  return value.toString();
2166
2166
  }
2167
2167
 
2168
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/promise.js
2168
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/promise.js
2169
2169
  var getPromiseValue = () => "Promise{\u2026}";
2170
- try {
2171
- const { getPromiseDetails, kPending, kRejected } = process.binding("util");
2172
- if (Array.isArray(getPromiseDetails(Promise.resolve()))) {
2173
- getPromiseValue = (value, options) => {
2174
- const [state, innerValue] = getPromiseDetails(value);
2175
- if (state === kPending) {
2176
- return "Promise{<pending>}";
2177
- }
2178
- return `Promise${state === kRejected ? "!" : ""}{${options.inspect(innerValue, options)}}`;
2179
- };
2180
- }
2181
- } catch (notNode) {
2182
- }
2183
2170
  var promise_default = getPromiseValue;
2184
2171
 
2185
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/object.js
2172
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/object.js
2186
2173
  function inspectObject(object2, options) {
2187
2174
  const properties = Object.getOwnPropertyNames(object2);
2188
2175
  const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object2) : [];
@@ -2205,7 +2192,7 @@ function inspectObject(object2, options) {
2205
2192
  return `{ ${propertyContents}${sep2}${symbolContents} }`;
2206
2193
  }
2207
2194
 
2208
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/class.js
2195
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/class.js
2209
2196
  var toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag ? Symbol.toStringTag : false;
2210
2197
  function inspectClass(value, options) {
2211
2198
  let name = "";
@@ -2220,7 +2207,7 @@ function inspectClass(value, options) {
2220
2207
  return `${name}${inspectObject(value, options)}`;
2221
2208
  }
2222
2209
 
2223
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/arguments.js
2210
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/arguments.js
2224
2211
  function inspectArguments(args, options) {
2225
2212
  if (args.length === 0)
2226
2213
  return "Arguments[]";
@@ -2228,7 +2215,7 @@ function inspectArguments(args, options) {
2228
2215
  return `Arguments[ ${inspectList(args, options)} ]`;
2229
2216
  }
2230
2217
 
2231
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/error.js
2218
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/error.js
2232
2219
  var errorKeys = [
2233
2220
  "stack",
2234
2221
  "line",
@@ -2263,7 +2250,7 @@ function inspectObject2(error, options) {
2263
2250
  return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ""}`;
2264
2251
  }
2265
2252
 
2266
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/html.js
2253
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/html.js
2267
2254
  function inspectAttribute([key, value], options) {
2268
2255
  options.truncate -= 3;
2269
2256
  if (!value) {
@@ -2305,7 +2292,7 @@ function inspectHTML(element, options) {
2305
2292
  return `${head}${propertyContents}${headClose}${children}${tail}`;
2306
2293
  }
2307
2294
 
2308
- // ../../node_modules/.pnpm/loupe@3.1.4/node_modules/loupe/lib/index.js
2295
+ // ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/index.js
2309
2296
  var symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function";
2310
2297
  var chaiInspect = symbolsSupported ? Symbol.for("chai/inspect") : "@@chai/inspect";
2311
2298
  var nodeInspect = Symbol.for("nodejs.util.inspect.custom");
@@ -2353,12 +2340,12 @@ var baseTypesMap = {
2353
2340
  HTMLCollection: inspectNodeCollection,
2354
2341
  NodeList: inspectNodeCollection
2355
2342
  };
2356
- var inspectCustom = (value, options, type3) => {
2343
+ var inspectCustom = (value, options, type3, inspectFn) => {
2357
2344
  if (chaiInspect in value && typeof value[chaiInspect] === "function") {
2358
2345
  return value[chaiInspect](options);
2359
2346
  }
2360
2347
  if (nodeInspect in value && typeof value[nodeInspect] === "function") {
2361
- return value[nodeInspect](options.depth, options);
2348
+ return value[nodeInspect](options.depth, options, inspectFn);
2362
2349
  }
2363
2350
  if ("inspect" in value && typeof value.inspect === "function") {
2364
2351
  return value.inspect(options.depth, options);
@@ -2383,7 +2370,7 @@ function inspect(value, opts = {}) {
2383
2370
  return baseTypesMap[type3](value, options);
2384
2371
  }
2385
2372
  if (customInspect && value) {
2386
- const output = inspectCustom(value, options, type3);
2373
+ const output = inspectCustom(value, options, type3, inspect);
2387
2374
  if (output) {
2388
2375
  if (typeof output === "string")
2389
2376
  return output;
@@ -2458,14 +2445,14 @@ function format2(...args) {
2458
2445
  const len = args.length;
2459
2446
  let i = 1;
2460
2447
  const template = args[0];
2461
- let str = String(template).replace(formatRegExp, (x) => {
2462
- if (x === "%%") {
2448
+ let str = String(template).replace(formatRegExp, (x2) => {
2449
+ if (x2 === "%%") {
2463
2450
  return "%";
2464
2451
  }
2465
2452
  if (i >= len) {
2466
- return x;
2453
+ return x2;
2467
2454
  }
2468
- switch (x) {
2455
+ switch (x2) {
2469
2456
  case "%s": {
2470
2457
  const value = args[i++];
2471
2458
  if (typeof value === "bigint") {
@@ -2523,14 +2510,14 @@ function format2(...args) {
2523
2510
  throw err;
2524
2511
  }
2525
2512
  default:
2526
- return x;
2513
+ return x2;
2527
2514
  }
2528
2515
  });
2529
- for (let x = args[i]; i < len; x = args[++i]) {
2530
- if (x === null || typeof x !== "object") {
2531
- str += ` ${x}`;
2516
+ for (let x2 = args[i]; i < len; x2 = args[++i]) {
2517
+ if (x2 === null || typeof x2 !== "object") {
2518
+ str += ` ${x2}`;
2532
2519
  } else {
2533
- str += ` ${inspect2(x)}`;
2520
+ str += ` ${inspect2(x2)}`;
2534
2521
  }
2535
2522
  }
2536
2523
  return str;
@@ -2563,8 +2550,8 @@ function objDisplay(obj, options = {}) {
2563
2550
  }
2564
2551
  return str;
2565
2552
  }
2566
- function getDefaultExportFromCjs2(x) {
2567
- return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
2553
+ function getDefaultExportFromCjs2(x2) {
2554
+ return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
2568
2555
  }
2569
2556
 
2570
2557
  // ../../node_modules/.pnpm/@vitest+utils@3.2.4/node_modules/@vitest/utils/dist/helpers.js
@@ -2624,15 +2611,15 @@ function deepClone(val, options = defaultCloneOptions) {
2624
2611
  return clone(val, seen, options);
2625
2612
  }
2626
2613
  function clone(val, seen, options = defaultCloneOptions) {
2627
- let k, out;
2614
+ let k2, out;
2628
2615
  if (seen.has(val)) {
2629
2616
  return seen.get(val);
2630
2617
  }
2631
2618
  if (Array.isArray(val)) {
2632
- out = Array.from({ length: k = val.length });
2619
+ out = Array.from({ length: k2 = val.length });
2633
2620
  seen.set(val, out);
2634
- while (k--) {
2635
- out[k] = clone(val[k], seen, options);
2621
+ while (k2--) {
2622
+ out[k2] = clone(val[k2], seen, options);
2636
2623
  }
2637
2624
  return out;
2638
2625
  }
@@ -2640,28 +2627,28 @@ function clone(val, seen, options = defaultCloneOptions) {
2640
2627
  out = Object.create(Object.getPrototypeOf(val));
2641
2628
  seen.set(val, out);
2642
2629
  const props = getOwnProperties(val);
2643
- for (const k2 of props) {
2644
- const descriptor = Object.getOwnPropertyDescriptor(val, k2);
2630
+ for (const k3 of props) {
2631
+ const descriptor = Object.getOwnPropertyDescriptor(val, k3);
2645
2632
  if (!descriptor) {
2646
2633
  continue;
2647
2634
  }
2648
- const cloned = clone(val[k2], seen, options);
2635
+ const cloned = clone(val[k3], seen, options);
2649
2636
  if (options.forceWritable) {
2650
- Object.defineProperty(out, k2, {
2637
+ Object.defineProperty(out, k3, {
2651
2638
  enumerable: descriptor.enumerable,
2652
2639
  configurable: true,
2653
2640
  writable: true,
2654
2641
  value: cloned
2655
2642
  });
2656
2643
  } else if ("get" in descriptor) {
2657
- Object.defineProperty(out, k2, {
2644
+ Object.defineProperty(out, k3, {
2658
2645
  ...descriptor,
2659
2646
  get() {
2660
2647
  return cloned;
2661
2648
  }
2662
2649
  });
2663
2650
  } else {
2664
- Object.defineProperty(out, k2, {
2651
+ Object.defineProperty(out, k3, {
2665
2652
  ...descriptor,
2666
2653
  value: cloned
2667
2654
  });
@@ -3654,19 +3641,19 @@ function joinAlignedDiffsNoExpand(diffs, options) {
3654
3641
  let aEnd = 0;
3655
3642
  let bEnd = 0;
3656
3643
  const pushCommonLine = (line) => {
3657
- const j = lines.length;
3658
- lines.push(printCommonLine(line, j === 0 || j === jLast, options));
3644
+ const j2 = lines.length;
3645
+ lines.push(printCommonLine(line, j2 === 0 || j2 === jLast, options));
3659
3646
  aEnd += 1;
3660
3647
  bEnd += 1;
3661
3648
  };
3662
3649
  const pushDeleteLine = (line) => {
3663
- const j = lines.length;
3664
- lines.push(printDeleteLine(line, j === 0 || j === jLast, options));
3650
+ const j2 = lines.length;
3651
+ lines.push(printDeleteLine(line, j2 === 0 || j2 === jLast, options));
3665
3652
  aEnd += 1;
3666
3653
  };
3667
3654
  const pushInsertLine = (line) => {
3668
- const j = lines.length;
3669
- lines.push(printInsertLine(line, j === 0 || j === jLast, options));
3655
+ const j2 = lines.length;
3656
+ lines.push(printInsertLine(line, j2 === 0 || j2 === jLast, options));
3670
3657
  bEnd += 1;
3671
3658
  };
3672
3659
  i = 0;
@@ -3793,20 +3780,20 @@ function isEmptyString(lines) {
3793
3780
  }
3794
3781
  function countChanges(diffs) {
3795
3782
  let a3 = 0;
3796
- let b = 0;
3783
+ let b2 = 0;
3797
3784
  diffs.forEach((diff2) => {
3798
3785
  switch (diff2[0]) {
3799
3786
  case DIFF_DELETE:
3800
3787
  a3 += 1;
3801
3788
  break;
3802
3789
  case DIFF_INSERT:
3803
- b += 1;
3790
+ b2 += 1;
3804
3791
  break;
3805
3792
  }
3806
3793
  });
3807
3794
  return {
3808
3795
  a: a3,
3809
- b
3796
+ b: b2
3810
3797
  };
3811
3798
  }
3812
3799
  function printAnnotation({ aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator, includeChangeCounts, omitAnnotationLines }, changeCounts) {
@@ -3828,9 +3815,9 @@ function printAnnotation({ aAnnotation, aColor, aIndicator, bAnnotation, bColor,
3828
3815
  bRest = `${bAnnotationPadding} ${bIndicator} ${bCountPadding}${bCount}`;
3829
3816
  }
3830
3817
  const a3 = `${aIndicator} ${aAnnotation}${aRest}`;
3831
- const b = `${bIndicator} ${bAnnotation}${bRest}`;
3818
+ const b2 = `${bIndicator} ${bAnnotation}${bRest}`;
3832
3819
  return `${aColor(a3)}
3833
- ${bColor(b)}
3820
+ ${bColor(b2)}
3834
3821
 
3835
3822
  `;
3836
3823
  }
@@ -3944,25 +3931,25 @@ function getType3(value) {
3944
3931
  function getNewLineSymbol(string2) {
3945
3932
  return string2.includes("\r\n") ? "\r\n" : "\n";
3946
3933
  }
3947
- function diffStrings(a3, b, options) {
3934
+ function diffStrings(a3, b2, options) {
3948
3935
  const truncate3 = (options === null || options === void 0 ? void 0 : options.truncateThreshold) ?? false;
3949
3936
  const truncateThreshold = Math.max(Math.floor((options === null || options === void 0 ? void 0 : options.truncateThreshold) ?? 0), 0);
3950
3937
  let aLength = a3.length;
3951
- let bLength = b.length;
3938
+ let bLength = b2.length;
3952
3939
  if (truncate3) {
3953
3940
  const aMultipleLines = a3.includes("\n");
3954
- const bMultipleLines = b.includes("\n");
3941
+ const bMultipleLines = b2.includes("\n");
3955
3942
  const aNewLineSymbol = getNewLineSymbol(a3);
3956
- const bNewLineSymbol = getNewLineSymbol(b);
3943
+ const bNewLineSymbol = getNewLineSymbol(b2);
3957
3944
  const _a = aMultipleLines ? `${a3.split(aNewLineSymbol, truncateThreshold).join(aNewLineSymbol)}
3958
3945
  ` : a3;
3959
- const _b = bMultipleLines ? `${b.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}
3960
- ` : b;
3946
+ const _b = bMultipleLines ? `${b2.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}
3947
+ ` : b2;
3961
3948
  aLength = _a.length;
3962
3949
  bLength = _b.length;
3963
3950
  }
3964
- const truncated = aLength !== a3.length || bLength !== b.length;
3965
- const isCommon = (aIndex2, bIndex2) => a3[aIndex2] === b[bIndex2];
3951
+ const truncated = aLength !== a3.length || bLength !== b2.length;
3952
+ const isCommon = (aIndex2, bIndex2) => a3[aIndex2] === b2[bIndex2];
3966
3953
  let aIndex = 0;
3967
3954
  let bIndex = 0;
3968
3955
  const diffs = [];
@@ -3971,18 +3958,18 @@ function diffStrings(a3, b, options) {
3971
3958
  diffs.push(new Diff(DIFF_DELETE, a3.slice(aIndex, aCommon)));
3972
3959
  }
3973
3960
  if (bIndex !== bCommon) {
3974
- diffs.push(new Diff(DIFF_INSERT, b.slice(bIndex, bCommon)));
3961
+ diffs.push(new Diff(DIFF_INSERT, b2.slice(bIndex, bCommon)));
3975
3962
  }
3976
3963
  aIndex = aCommon + nCommon;
3977
3964
  bIndex = bCommon + nCommon;
3978
- diffs.push(new Diff(DIFF_EQUAL, b.slice(bCommon, bIndex)));
3965
+ diffs.push(new Diff(DIFF_EQUAL, b2.slice(bCommon, bIndex)));
3979
3966
  };
3980
3967
  diffSequences(aLength, bLength, isCommon, foundSubsequence);
3981
3968
  if (aIndex !== aLength) {
3982
3969
  diffs.push(new Diff(DIFF_DELETE, a3.slice(aIndex)));
3983
3970
  }
3984
3971
  if (bIndex !== bLength) {
3985
- diffs.push(new Diff(DIFF_INSERT, b.slice(bIndex)));
3972
+ diffs.push(new Diff(DIFF_INSERT, b2.slice(bIndex)));
3986
3973
  }
3987
3974
  return [diffs, truncated];
3988
3975
  }
@@ -4124,22 +4111,22 @@ function hasCommonDiff(diffs, isMultiline) {
4124
4111
  }
4125
4112
  return diffs.some((diff2) => diff2[0] === DIFF_EQUAL);
4126
4113
  }
4127
- function diffStringsUnified(a3, b, options) {
4128
- if (a3 !== b && a3.length !== 0 && b.length !== 0) {
4129
- const isMultiline = a3.includes("\n") || b.includes("\n");
4114
+ function diffStringsUnified(a3, b2, options) {
4115
+ if (a3 !== b2 && a3.length !== 0 && b2.length !== 0) {
4116
+ const isMultiline = a3.includes("\n") || b2.includes("\n");
4130
4117
  const [diffs, truncated] = diffStringsRaw(isMultiline ? `${a3}
4131
- ` : a3, isMultiline ? `${b}
4132
- ` : b, true, options);
4118
+ ` : a3, isMultiline ? `${b2}
4119
+ ` : b2, true, options);
4133
4120
  if (hasCommonDiff(diffs, isMultiline)) {
4134
4121
  const optionsNormalized = normalizeDiffOptions(options);
4135
4122
  const lines = getAlignedDiffs(diffs, optionsNormalized.changeColor);
4136
4123
  return printDiffLines(lines, truncated, optionsNormalized);
4137
4124
  }
4138
4125
  }
4139
- return diffLinesUnified(a3.split("\n"), b.split("\n"), options);
4126
+ return diffLinesUnified(a3.split("\n"), b2.split("\n"), options);
4140
4127
  }
4141
- function diffStringsRaw(a3, b, cleanup, options) {
4142
- const [diffs, truncated] = diffStrings(a3, b, options);
4128
+ function diffStringsRaw(a3, b2, cleanup, options) {
4129
+ const [diffs, truncated] = diffStrings(a3, b2, options);
4143
4130
  {
4144
4131
  diff_cleanupSemantic(diffs);
4145
4132
  }
@@ -4168,8 +4155,8 @@ var FALLBACK_FORMAT_OPTIONS = {
4168
4155
  maxDepth: 8,
4169
4156
  plugins: PLUGINS2
4170
4157
  };
4171
- function diff(a3, b, options) {
4172
- if (Object.is(a3, b)) {
4158
+ function diff(a3, b2, options) {
4159
+ if (Object.is(a3, b2)) {
4173
4160
  return "";
4174
4161
  }
4175
4162
  const aType = getType3(a3);
@@ -4185,14 +4172,14 @@ function diff(a3, b, options) {
4185
4172
  expectedType = a3.getExpectedType();
4186
4173
  omitDifference = expectedType === "string";
4187
4174
  }
4188
- if (expectedType !== getType3(b)) {
4175
+ if (expectedType !== getType3(b2)) {
4189
4176
  let truncate4 = function(s2) {
4190
4177
  return s2.length <= MAX_LENGTH ? s2 : `${s2.slice(0, MAX_LENGTH)}...`;
4191
4178
  };
4192
4179
  const { aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator } = normalizeDiffOptions(options);
4193
4180
  const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
4194
4181
  let aDisplay = format(a3, formatOptions);
4195
- let bDisplay = format(b, formatOptions);
4182
+ let bDisplay = format(b2, formatOptions);
4196
4183
  const MAX_LENGTH = 1e5;
4197
4184
  aDisplay = truncate4(aDisplay);
4198
4185
  bDisplay = truncate4(bDisplay);
@@ -4209,21 +4196,21 @@ ${bDiff}`;
4209
4196
  }
4210
4197
  switch (aType) {
4211
4198
  case "string":
4212
- return diffLinesUnified(a3.split("\n"), b.split("\n"), options);
4199
+ return diffLinesUnified(a3.split("\n"), b2.split("\n"), options);
4213
4200
  case "boolean":
4214
4201
  case "number":
4215
- return comparePrimitive(a3, b, options);
4202
+ return comparePrimitive(a3, b2, options);
4216
4203
  case "map":
4217
- return compareObjects(sortMap(a3), sortMap(b), options);
4204
+ return compareObjects(sortMap(a3), sortMap(b2), options);
4218
4205
  case "set":
4219
- return compareObjects(sortSet(a3), sortSet(b), options);
4206
+ return compareObjects(sortSet(a3), sortSet(b2), options);
4220
4207
  default:
4221
- return compareObjects(a3, b, options);
4208
+ return compareObjects(a3, b2, options);
4222
4209
  }
4223
4210
  }
4224
- function comparePrimitive(a3, b, options) {
4211
+ function comparePrimitive(a3, b2, options) {
4225
4212
  const aFormat = format(a3, FORMAT_OPTIONS);
4226
- const bFormat = format(b, FORMAT_OPTIONS);
4213
+ const bFormat = format(b2, FORMAT_OPTIONS);
4227
4214
  return aFormat === bFormat ? "" : diffLinesUnified(aFormat.split("\n"), bFormat.split("\n"), options);
4228
4215
  }
4229
4216
  function sortMap(map2) {
@@ -4232,19 +4219,19 @@ function sortMap(map2) {
4232
4219
  function sortSet(set3) {
4233
4220
  return new Set(Array.from(set3.values()).sort());
4234
4221
  }
4235
- function compareObjects(a3, b, options) {
4222
+ function compareObjects(a3, b2, options) {
4236
4223
  let difference;
4237
4224
  let hasThrown = false;
4238
4225
  try {
4239
4226
  const formatOptions = getFormatOptions(FORMAT_OPTIONS, options);
4240
- difference = getObjectsDifference(a3, b, formatOptions, options);
4227
+ difference = getObjectsDifference(a3, b2, formatOptions, options);
4241
4228
  } catch {
4242
4229
  hasThrown = true;
4243
4230
  }
4244
4231
  const noDiffMessage = getCommonMessage(NO_DIFF_MESSAGE, options);
4245
4232
  if (difference === void 0 || difference === noDiffMessage) {
4246
4233
  const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
4247
- difference = getObjectsDifference(a3, b, formatOptions, options);
4234
+ difference = getObjectsDifference(a3, b2, formatOptions, options);
4248
4235
  if (difference !== noDiffMessage && !hasThrown) {
4249
4236
  difference = `${getCommonMessage(SIMILAR_MESSAGE, options)}
4250
4237
 
@@ -4262,18 +4249,18 @@ function getFormatOptions(formatOptions, options) {
4262
4249
  maxDepth: maxDepth ?? formatOptions.maxDepth
4263
4250
  };
4264
4251
  }
4265
- function getObjectsDifference(a3, b, formatOptions, options) {
4252
+ function getObjectsDifference(a3, b2, formatOptions, options) {
4266
4253
  const formatOptionsZeroIndent = {
4267
4254
  ...formatOptions,
4268
4255
  indent: 0
4269
4256
  };
4270
4257
  const aCompare = format(a3, formatOptionsZeroIndent);
4271
- const bCompare = format(b, formatOptionsZeroIndent);
4258
+ const bCompare = format(b2, formatOptionsZeroIndent);
4272
4259
  if (aCompare === bCompare) {
4273
4260
  return getCommonMessage(NO_DIFF_MESSAGE, options);
4274
4261
  } else {
4275
4262
  const aDisplay = format(a3, formatOptions);
4276
- const bDisplay = format(b, formatOptions);
4263
+ const bDisplay = format(b2, formatOptions);
4277
4264
  return diffLinesUnified2(aDisplay.split("\n"), bDisplay.split("\n"), aCompare.split("\n"), bCompare.split("\n"), options);
4278
4265
  }
4279
4266
  }
@@ -4369,166 +4356,166 @@ function getCommonAndChangedSubstrings(diffs, op, hasCommonDiff2) {
4369
4356
  return diffs.reduce((reduced, diff2) => reduced + (diff2[0] === DIFF_EQUAL ? diff2[1] : diff2[0] === op ? hasCommonDiff2 ? u.inverse(diff2[1]) : diff2[1] : ""), "");
4370
4357
  }
4371
4358
 
4372
- // ../../node_modules/.pnpm/tinyspy@4.0.3/node_modules/tinyspy/dist/index.js
4373
- function assert(condition, message) {
4374
- if (!condition)
4375
- throw new Error(message);
4359
+ // ../../node_modules/.pnpm/tinyspy@4.0.4/node_modules/tinyspy/dist/index.js
4360
+ function S(e, t) {
4361
+ if (!e)
4362
+ throw new Error(t);
4376
4363
  }
4377
- function isType(type3, value) {
4378
- return typeof value === type3;
4364
+ function f2(e, t) {
4365
+ return typeof t === e;
4379
4366
  }
4380
- function isPromise(value) {
4381
- return value instanceof Promise;
4367
+ function w(e) {
4368
+ return e instanceof Promise;
4382
4369
  }
4383
- function define(obj, key, descriptor) {
4384
- Object.defineProperty(obj, key, descriptor);
4370
+ function u2(e, t, r2) {
4371
+ Object.defineProperty(e, t, r2);
4385
4372
  }
4386
- function defineValue(obj, key, value) {
4387
- define(obj, key, { value, configurable: true, writable: true });
4373
+ function l(e, t, r2) {
4374
+ u2(e, t, { value: r2, configurable: true, writable: true });
4388
4375
  }
4389
- var SYMBOL_STATE = Symbol.for("tinyspy:spy");
4390
- var spies = /* @__PURE__ */ new Set();
4391
- var reset = (state) => {
4392
- state.called = false, state.callCount = 0, state.calls = [], state.results = [], state.resolves = [], state.next = [];
4376
+ var y = Symbol.for("tinyspy:spy");
4377
+ var x = /* @__PURE__ */ new Set();
4378
+ var h2 = (e) => {
4379
+ e.called = false, e.callCount = 0, e.calls = [], e.results = [], e.resolves = [], e.next = [];
4393
4380
  };
4394
- var defineState = (spy2) => (define(spy2, SYMBOL_STATE, {
4395
- value: { reset: () => reset(spy2[SYMBOL_STATE]) }
4396
- }), spy2[SYMBOL_STATE]);
4397
- var getInternalState = (spy2) => spy2[SYMBOL_STATE] || defineState(spy2);
4398
- function createInternalSpy(cb) {
4399
- assert(
4400
- isType("function", cb) || isType("undefined", cb),
4381
+ var k = (e) => (u2(e, y, {
4382
+ value: { reset: () => h2(e[y]) }
4383
+ }), e[y]);
4384
+ var T = (e) => e[y] || k(e);
4385
+ function R(e) {
4386
+ S(
4387
+ f2("function", e) || f2("undefined", e),
4401
4388
  "cannot spy on a non-function value"
4402
4389
  );
4403
- let fn2 = function(...args) {
4404
- let state2 = getInternalState(fn2);
4405
- state2.called = true, state2.callCount++, state2.calls.push(args);
4406
- let next = state2.next.shift();
4407
- if (next) {
4408
- state2.results.push(next);
4409
- let [type22, result2] = next;
4410
- if (type22 === "ok")
4411
- return result2;
4412
- throw result2;
4413
- }
4414
- let result, type3 = "ok", resultIndex = state2.results.length;
4415
- if (state2.impl)
4390
+ let t = function(...s2) {
4391
+ let n = T(t);
4392
+ n.called = true, n.callCount++, n.calls.push(s2);
4393
+ let d = n.next.shift();
4394
+ if (d) {
4395
+ n.results.push(d);
4396
+ let [a3, i] = d;
4397
+ if (a3 === "ok")
4398
+ return i;
4399
+ throw i;
4400
+ }
4401
+ let o, c = "ok", p3 = n.results.length;
4402
+ if (n.impl)
4416
4403
  try {
4417
- new.target ? result = Reflect.construct(state2.impl, args, new.target) : result = state2.impl.apply(this, args), type3 = "ok";
4418
- } catch (err) {
4419
- throw result = err, type3 = "error", state2.results.push([type3, err]), err;
4404
+ new.target ? o = Reflect.construct(n.impl, s2, new.target) : o = n.impl.apply(this, s2), c = "ok";
4405
+ } catch (a3) {
4406
+ throw o = a3, c = "error", n.results.push([c, a3]), a3;
4420
4407
  }
4421
- let resultTuple = [type3, result];
4422
- return isPromise(result) && result.then(
4423
- (r2) => state2.resolves[resultIndex] = ["ok", r2],
4424
- (e) => state2.resolves[resultIndex] = ["error", e]
4425
- ), state2.results.push(resultTuple), result;
4408
+ let g = [c, o];
4409
+ return w(o) && o.then(
4410
+ (a3) => n.resolves[p3] = ["ok", a3],
4411
+ (a3) => n.resolves[p3] = ["error", a3]
4412
+ ), n.results.push(g), o;
4426
4413
  };
4427
- defineValue(fn2, "_isMockFunction", true), defineValue(fn2, "length", cb ? cb.length : 0), defineValue(fn2, "name", cb && cb.name || "spy");
4428
- let state = getInternalState(fn2);
4429
- return state.reset(), state.impl = cb, fn2;
4430
- }
4431
- function isMockFunction(obj) {
4432
- return !!obj && obj._isMockFunction === true;
4433
- }
4434
- var getDescriptor = (obj, method) => {
4435
- let objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
4436
- if (objDescriptor)
4437
- return [obj, objDescriptor];
4438
- let currentProto = Object.getPrototypeOf(obj);
4439
- for (; currentProto !== null; ) {
4440
- let descriptor = Object.getOwnPropertyDescriptor(currentProto, method);
4441
- if (descriptor)
4442
- return [currentProto, descriptor];
4443
- currentProto = Object.getPrototypeOf(currentProto);
4414
+ l(t, "_isMockFunction", true), l(t, "length", e ? e.length : 0), l(t, "name", e && e.name || "spy");
4415
+ let r2 = T(t);
4416
+ return r2.reset(), r2.impl = e, t;
4417
+ }
4418
+ function v(e) {
4419
+ return !!e && e._isMockFunction === true;
4420
+ }
4421
+ var b = (e, t) => {
4422
+ let r2 = Object.getOwnPropertyDescriptor(e, t);
4423
+ if (r2)
4424
+ return [e, r2];
4425
+ let s2 = Object.getPrototypeOf(e);
4426
+ for (; s2 !== null; ) {
4427
+ let n = Object.getOwnPropertyDescriptor(s2, t);
4428
+ if (n)
4429
+ return [s2, n];
4430
+ s2 = Object.getPrototypeOf(s2);
4444
4431
  }
4445
4432
  };
4446
- var setPototype = (fn2, val) => {
4447
- val != null && typeof val == "function" && val.prototype != null && Object.setPrototypeOf(fn2.prototype, val.prototype);
4433
+ var P = (e, t) => {
4434
+ t != null && typeof t == "function" && t.prototype != null && Object.setPrototypeOf(e.prototype, t.prototype);
4448
4435
  };
4449
- function internalSpyOn(obj, methodName, mock) {
4450
- assert(
4451
- !isType("undefined", obj),
4436
+ function M(e, t, r2) {
4437
+ S(
4438
+ !f2("undefined", e),
4452
4439
  "spyOn could not find an object to spy upon"
4453
- ), assert(
4454
- isType("object", obj) || isType("function", obj),
4440
+ ), S(
4441
+ f2("object", e) || f2("function", e),
4455
4442
  "cannot spyOn on a primitive value"
4456
4443
  );
4457
- let [accessName, accessType] = (() => {
4458
- if (!isType("object", methodName))
4459
- return [methodName, "value"];
4460
- if ("getter" in methodName && "setter" in methodName)
4444
+ let [s2, n] = (() => {
4445
+ if (!f2("object", t))
4446
+ return [t, "value"];
4447
+ if ("getter" in t && "setter" in t)
4461
4448
  throw new Error("cannot spy on both getter and setter");
4462
- if ("getter" in methodName)
4463
- return [methodName.getter, "get"];
4464
- if ("setter" in methodName)
4465
- return [methodName.setter, "set"];
4449
+ if ("getter" in t)
4450
+ return [t.getter, "get"];
4451
+ if ("setter" in t)
4452
+ return [t.setter, "set"];
4466
4453
  throw new Error("specify getter or setter to spy on");
4467
- })(), [originalDescriptorObject, originalDescriptor] = getDescriptor(obj, accessName) || [];
4468
- assert(
4469
- originalDescriptor || accessName in obj,
4470
- `${String(accessName)} does not exist`
4454
+ })(), [d, o] = b(e, s2) || [];
4455
+ S(
4456
+ o || s2 in e,
4457
+ `${String(s2)} does not exist`
4471
4458
  );
4472
- let ssr = false;
4473
- accessType === "value" && originalDescriptor && !originalDescriptor.value && originalDescriptor.get && (accessType = "get", ssr = true, mock = originalDescriptor.get());
4474
- let original;
4475
- originalDescriptor ? original = originalDescriptor[accessType] : accessType !== "value" ? original = () => obj[accessName] : original = obj[accessName], original && isSpyFunction(original) && (original = original[SYMBOL_STATE].getOriginal());
4476
- let reassign = (cb) => {
4477
- let { value, ...desc } = originalDescriptor || {
4459
+ let c = false;
4460
+ n === "value" && o && !o.value && o.get && (n = "get", c = true, r2 = o.get());
4461
+ let p3;
4462
+ o ? p3 = o[n] : n !== "value" ? p3 = () => e[s2] : p3 = e[s2], p3 && j(p3) && (p3 = p3[y].getOriginal());
4463
+ let g = (I) => {
4464
+ let { value: F, ...O } = o || {
4478
4465
  configurable: true,
4479
4466
  writable: true
4480
4467
  };
4481
- accessType !== "value" && delete desc.writable, desc[accessType] = cb, define(obj, accessName, desc);
4482
- }, restore = () => {
4483
- originalDescriptorObject !== obj ? Reflect.deleteProperty(obj, accessName) : originalDescriptor && !original ? define(obj, accessName, originalDescriptor) : reassign(original);
4468
+ n !== "value" && delete O.writable, O[n] = I, u2(e, s2, O);
4469
+ }, a3 = () => {
4470
+ d !== e ? Reflect.deleteProperty(e, s2) : o && !p3 ? u2(e, s2, o) : g(p3);
4484
4471
  };
4485
- mock || (mock = original);
4486
- let spy2 = wrap(createInternalSpy(mock), mock);
4487
- accessType === "value" && setPototype(spy2, original);
4488
- let state = spy2[SYMBOL_STATE];
4489
- return defineValue(state, "restore", restore), defineValue(state, "getOriginal", () => ssr ? original() : original), defineValue(state, "willCall", (newCb) => (state.impl = newCb, spy2)), reassign(
4490
- ssr ? () => (setPototype(spy2, mock), spy2) : spy2
4491
- ), spies.add(spy2), spy2;
4492
- }
4493
- var ignoreProperties = /* @__PURE__ */ new Set([
4472
+ r2 || (r2 = p3);
4473
+ let i = E(R(r2), r2);
4474
+ n === "value" && P(i, p3);
4475
+ let m2 = i[y];
4476
+ return l(m2, "restore", a3), l(m2, "getOriginal", () => c ? p3() : p3), l(m2, "willCall", (I) => (m2.impl = I, i)), g(
4477
+ c ? () => (P(i, r2), i) : i
4478
+ ), x.add(i), i;
4479
+ }
4480
+ var K = /* @__PURE__ */ new Set([
4494
4481
  "length",
4495
4482
  "name",
4496
4483
  "prototype"
4497
4484
  ]);
4498
- function getAllProperties(original) {
4499
- let properties = /* @__PURE__ */ new Set(), descriptors2 = {};
4500
- for (; original && original !== Object.prototype && original !== Function.prototype; ) {
4501
- let ownProperties = [
4502
- ...Object.getOwnPropertyNames(original),
4503
- ...Object.getOwnPropertySymbols(original)
4485
+ function D(e) {
4486
+ let t = /* @__PURE__ */ new Set(), r2 = {};
4487
+ for (; e && e !== Object.prototype && e !== Function.prototype; ) {
4488
+ let s2 = [
4489
+ ...Object.getOwnPropertyNames(e),
4490
+ ...Object.getOwnPropertySymbols(e)
4504
4491
  ];
4505
- for (let prop of ownProperties)
4506
- descriptors2[prop] || ignoreProperties.has(prop) || (properties.add(prop), descriptors2[prop] = Object.getOwnPropertyDescriptor(original, prop));
4507
- original = Object.getPrototypeOf(original);
4492
+ for (let n of s2)
4493
+ r2[n] || K.has(n) || (t.add(n), r2[n] = Object.getOwnPropertyDescriptor(e, n));
4494
+ e = Object.getPrototypeOf(e);
4508
4495
  }
4509
4496
  return {
4510
- properties,
4511
- descriptors: descriptors2
4497
+ properties: t,
4498
+ descriptors: r2
4512
4499
  };
4513
4500
  }
4514
- function wrap(mock, original) {
4515
- if (!original || // the original is already a spy, so it has all the properties
4516
- SYMBOL_STATE in original)
4517
- return mock;
4518
- let { properties, descriptors: descriptors2 } = getAllProperties(original);
4519
- for (let key of properties) {
4520
- let descriptor = descriptors2[key];
4521
- getDescriptor(mock, key) || define(mock, key, descriptor);
4501
+ function E(e, t) {
4502
+ if (!t || // the original is already a spy, so it has all the properties
4503
+ y in t)
4504
+ return e;
4505
+ let { properties: r2, descriptors: s2 } = D(t);
4506
+ for (let n of r2) {
4507
+ let d = s2[n];
4508
+ b(e, n) || u2(e, n, d);
4522
4509
  }
4523
- return mock;
4510
+ return e;
4524
4511
  }
4525
- function isSpyFunction(obj) {
4526
- return isMockFunction(obj) && "getOriginal" in obj[SYMBOL_STATE];
4512
+ function j(e) {
4513
+ return v(e) && "getOriginal" in e[y];
4527
4514
  }
4528
4515
 
4529
4516
  // ../../node_modules/.pnpm/@vitest+spy@3.2.4/node_modules/@vitest/spy/dist/index.js
4530
4517
  var mocks = /* @__PURE__ */ new Set();
4531
- function isMockFunction2(fn2) {
4518
+ function isMockFunction(fn2) {
4532
4519
  return typeof fn2 === "function" && "_isMockFunction" in fn2 && fn2._isMockFunction;
4533
4520
  }
4534
4521
  function spyOn(obj, method, accessType) {
@@ -4538,13 +4525,13 @@ function spyOn(obj, method, accessType) {
4538
4525
  };
4539
4526
  const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
4540
4527
  let state;
4541
- const descriptor = getDescriptor2(obj, method);
4528
+ const descriptor = getDescriptor(obj, method);
4542
4529
  const fn2 = descriptor && descriptor[accessType || "value"];
4543
- if (isMockFunction2(fn2)) {
4530
+ if (isMockFunction(fn2)) {
4544
4531
  state = fn2.mock._state();
4545
4532
  }
4546
4533
  try {
4547
- const stub = internalSpyOn(obj, objMethod);
4534
+ const stub = M(obj, objMethod);
4548
4535
  const spy = enhanceSpy(stub);
4549
4536
  if (state) {
4550
4537
  spy.mock._state(state);
@@ -4566,7 +4553,7 @@ function enhanceSpy(spy) {
4566
4553
  let instances = [];
4567
4554
  let contexts = [];
4568
4555
  let invocations = [];
4569
- const state = getInternalState(spy);
4556
+ const state = T(spy);
4570
4557
  const mockContext = {
4571
4558
  get calls() {
4572
4559
  return state.calls;
@@ -4664,18 +4651,18 @@ function enhanceSpy(spy) {
4664
4651
  implementation = fn2;
4665
4652
  state.willCall(mockCall);
4666
4653
  implementationChangedTemporarily = true;
4667
- const reset2 = () => {
4654
+ const reset = () => {
4668
4655
  implementation = originalImplementation;
4669
4656
  implementationChangedTemporarily = false;
4670
4657
  };
4671
4658
  const result = cb();
4672
4659
  if (typeof result === "object" && result && typeof result.then === "function") {
4673
4660
  return result.then(() => {
4674
- reset2();
4661
+ reset();
4675
4662
  return stub;
4676
4663
  });
4677
4664
  }
4678
- reset2();
4665
+ reset();
4679
4666
  return stub;
4680
4667
  }
4681
4668
  stub.withImplementation = withImplementation;
@@ -4694,14 +4681,14 @@ function enhanceSpy(spy) {
4694
4681
  return stub;
4695
4682
  }
4696
4683
  function fn(implementation) {
4697
- const enhancedSpy = enhanceSpy(internalSpyOn({ spy: implementation || function() {
4684
+ const enhancedSpy = enhanceSpy(M({ spy: implementation || function() {
4698
4685
  } }, "spy"));
4699
4686
  if (implementation) {
4700
4687
  enhancedSpy.mockImplementation(implementation);
4701
4688
  }
4702
4689
  return enhancedSpy;
4703
4690
  }
4704
- function getDescriptor2(obj, method) {
4691
+ function getDescriptor(obj, method) {
4705
4692
  const objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
4706
4693
  if (objDescriptor) {
4707
4694
  return objDescriptor;
@@ -4719,8 +4706,8 @@ function getDescriptor2(obj, method) {
4719
4706
  // ../../node_modules/.pnpm/@vitest+utils@3.2.4/node_modules/@vitest/utils/dist/error.js
4720
4707
  var IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
4721
4708
  var IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
4722
- function isImmutable(v) {
4723
- return v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
4709
+ function isImmutable(v2) {
4710
+ return v2 && (v2[IS_COLLECTION_SYMBOL] || v2[IS_RECORD_SYMBOL]);
4724
4711
  }
4725
4712
  var OBJECT_PROTO = Object.getPrototypeOf({});
4726
4713
  function getUnserializableMessage(err) {
@@ -4866,13 +4853,13 @@ Inner error message: ${err === null || err === void 0 ? void 0 : err.message}`))
4866
4853
  }
4867
4854
  }
4868
4855
 
4869
- // ../../node_modules/.pnpm/chai@5.2.0/node_modules/chai/chai.js
4856
+ // ../../node_modules/.pnpm/chai@5.3.3/node_modules/chai/index.js
4870
4857
  var chai_exports = {};
4871
4858
  __export(chai_exports, {
4872
4859
  Assertion: () => Assertion,
4873
4860
  AssertionError: () => AssertionError,
4874
4861
  Should: () => Should,
4875
- assert: () => assert2,
4862
+ assert: () => assert,
4876
4863
  config: () => config,
4877
4864
  expect: () => expect,
4878
4865
  should: () => should,
@@ -4880,19 +4867,11 @@ __export(chai_exports, {
4880
4867
  util: () => utils_exports
4881
4868
  });
4882
4869
  var __defProp = Object.defineProperty;
4883
- var __getOwnPropNames = Object.getOwnPropertyNames;
4884
4870
  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
4885
- var __commonJS2 = (cb, mod) => function __require() {
4886
- return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
4887
- };
4888
4871
  var __export2 = (target, all) => {
4889
4872
  for (var name in all)
4890
4873
  __defProp(target, name, { get: all[name], enumerable: true });
4891
4874
  };
4892
- var require_util = __commonJS2({
4893
- "(disabled):util"() {
4894
- }
4895
- });
4896
4875
  var utils_exports = {};
4897
4876
  __export2(utils_exports, {
4898
4877
  addChainableMethod: () => addChainableMethod,
@@ -4990,7 +4969,7 @@ function getMessage(errorLike) {
4990
4969
  }
4991
4970
  __name(getMessage, "getMessage");
4992
4971
  function flag(obj, key, value) {
4993
- var flags = obj.__flags || (obj.__flags = /* @__PURE__ */ Object.create(null));
4972
+ let flags = obj.__flags || (obj.__flags = /* @__PURE__ */ Object.create(null));
4994
4973
  if (arguments.length === 3) {
4995
4974
  flags[key] = value;
4996
4975
  } else {
@@ -4999,7 +4978,7 @@ function flag(obj, key, value) {
4999
4978
  }
5000
4979
  __name(flag, "flag");
5001
4980
  function test2(obj, args) {
5002
- var negate = flag(obj, "negate"), expr = args[0];
4981
+ let negate = flag(obj, "negate"), expr = args[0];
5003
4982
  return negate ? !expr : expr;
5004
4983
  }
5005
4984
  __name(test2, "test");
@@ -5053,20 +5032,20 @@ var AssertionError = class _AssertionError extends Error {
5053
5032
  }
5054
5033
  };
5055
5034
  function expectTypes(obj, types) {
5056
- var flagMsg = flag(obj, "message");
5057
- var ssfi = flag(obj, "ssfi");
5035
+ let flagMsg = flag(obj, "message");
5036
+ let ssfi = flag(obj, "ssfi");
5058
5037
  flagMsg = flagMsg ? flagMsg + ": " : "";
5059
5038
  obj = flag(obj, "object");
5060
5039
  types = types.map(function(t) {
5061
5040
  return t.toLowerCase();
5062
5041
  });
5063
5042
  types.sort();
5064
- var str = types.map(function(t, index2) {
5065
- var art = ~["a", "e", "i", "o", "u"].indexOf(t.charAt(0)) ? "an" : "a";
5066
- var or = types.length > 1 && index2 === types.length - 1 ? "or " : "";
5043
+ let str = types.map(function(t, index2) {
5044
+ let art = ~["a", "e", "i", "o", "u"].indexOf(t.charAt(0)) ? "an" : "a";
5045
+ let or = types.length > 1 && index2 === types.length - 1 ? "or " : "";
5067
5046
  return or + art + " " + t;
5068
5047
  }).join(", ");
5069
- var objType = type(obj).toLowerCase();
5048
+ let objType = type(obj).toLowerCase();
5070
5049
  if (!types.some(function(expected) {
5071
5050
  return objType === expected;
5072
5051
  })) {
@@ -5324,10 +5303,8 @@ function mapToEntries2(map2) {
5324
5303
  }
5325
5304
  __name(mapToEntries2, "mapToEntries");
5326
5305
  function inspectMap2(map2, options) {
5327
- const size = map2.size - 1;
5328
- if (size <= 0) {
5306
+ if (map2.size === 0)
5329
5307
  return "Map{}";
5330
- }
5331
5308
  options.truncate -= 7;
5332
5309
  return `Map{ ${inspectList2(mapToEntries2(map2), options, inspectMapEntry2)} }`;
5333
5310
  }
@@ -5408,19 +5385,6 @@ function inspectSymbol2(value) {
5408
5385
  }
5409
5386
  __name(inspectSymbol2, "inspectSymbol");
5410
5387
  var getPromiseValue2 = /* @__PURE__ */ __name(() => "Promise{\u2026}", "getPromiseValue");
5411
- try {
5412
- const { getPromiseDetails, kPending, kRejected } = process.binding("util");
5413
- if (Array.isArray(getPromiseDetails(Promise.resolve()))) {
5414
- getPromiseValue2 = /* @__PURE__ */ __name((value, options) => {
5415
- const [state, innerValue] = getPromiseDetails(value);
5416
- if (state === kPending) {
5417
- return "Promise{<pending>}";
5418
- }
5419
- return `Promise${state === kRejected ? "!" : ""}{${options.inspect(innerValue, options)}}`;
5420
- }, "getPromiseValue");
5421
- }
5422
- } catch (notNode) {
5423
- }
5424
5388
  var promise_default2 = getPromiseValue2;
5425
5389
  function inspectObject3(object2, options) {
5426
5390
  const properties = Object.getOwnPropertyNames(object2);
@@ -5507,10 +5471,21 @@ function inspectAttribute2([key, value], options) {
5507
5471
  return `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}`;
5508
5472
  }
5509
5473
  __name(inspectAttribute2, "inspectAttribute");
5510
- function inspectHTMLCollection(collection, options) {
5511
- return inspectList2(collection, options, inspectHTML2, "\n");
5474
+ function inspectNodeCollection2(collection, options) {
5475
+ return inspectList2(collection, options, inspectNode2, "\n");
5476
+ }
5477
+ __name(inspectNodeCollection2, "inspectNodeCollection");
5478
+ function inspectNode2(node, options) {
5479
+ switch (node.nodeType) {
5480
+ case 1:
5481
+ return inspectHTML2(node, options);
5482
+ case 3:
5483
+ return options.inspect(node.data, options);
5484
+ default:
5485
+ return options.inspect(node, options);
5486
+ }
5512
5487
  }
5513
- __name(inspectHTMLCollection, "inspectHTMLCollection");
5488
+ __name(inspectNode2, "inspectNode");
5514
5489
  function inspectHTML2(element, options) {
5515
5490
  const properties = element.getAttributeNames();
5516
5491
  const name = element.tagName.toLowerCase();
@@ -5525,7 +5500,7 @@ function inspectHTML2(element, options) {
5525
5500
  }
5526
5501
  options.truncate -= propertyContents.length;
5527
5502
  const truncate22 = options.truncate;
5528
- let children = inspectHTMLCollection(element.children, options);
5503
+ let children = inspectNodeCollection2(element.children, options);
5529
5504
  if (children && children.length > truncate22) {
5530
5505
  children = `${truncator2}(${element.children.length})`;
5531
5506
  }
@@ -5534,20 +5509,14 @@ function inspectHTML2(element, options) {
5534
5509
  __name(inspectHTML2, "inspectHTML");
5535
5510
  var symbolsSupported2 = typeof Symbol === "function" && typeof Symbol.for === "function";
5536
5511
  var chaiInspect2 = symbolsSupported2 ? Symbol.for("chai/inspect") : "@@chai/inspect";
5537
- var nodeInspect2 = false;
5538
- try {
5539
- const nodeUtil = require_util();
5540
- nodeInspect2 = nodeUtil.inspect ? nodeUtil.inspect.custom : false;
5541
- } catch (noNodeInspect) {
5542
- nodeInspect2 = false;
5543
- }
5512
+ var nodeInspect2 = Symbol.for("nodejs.util.inspect.custom");
5544
5513
  var constructorMap2 = /* @__PURE__ */ new WeakMap();
5545
5514
  var stringTagMap2 = {};
5546
5515
  var baseTypesMap2 = {
5547
- undefined: (value, options) => options.stylize("undefined", "undefined"),
5548
- null: (value, options) => options.stylize("null", "null"),
5549
- boolean: (value, options) => options.stylize(String(value), "boolean"),
5550
- Boolean: (value, options) => options.stylize(String(value), "boolean"),
5516
+ undefined: /* @__PURE__ */ __name((value, options) => options.stylize("undefined", "undefined"), "undefined"),
5517
+ null: /* @__PURE__ */ __name((value, options) => options.stylize("null", "null"), "null"),
5518
+ boolean: /* @__PURE__ */ __name((value, options) => options.stylize(String(value), "boolean"), "boolean"),
5519
+ Boolean: /* @__PURE__ */ __name((value, options) => options.stylize(String(value), "boolean"), "Boolean"),
5551
5520
  number: inspectNumber2,
5552
5521
  Number: inspectNumber2,
5553
5522
  bigint: inspectBigInt2,
@@ -5566,8 +5535,8 @@ var baseTypesMap2 = {
5566
5535
  RegExp: inspectRegExp2,
5567
5536
  Promise: promise_default2,
5568
5537
  // WeakSet, WeakMap are totally opaque to us
5569
- WeakSet: (value, options) => options.stylize("WeakSet{\u2026}", "special"),
5570
- WeakMap: (value, options) => options.stylize("WeakMap{\u2026}", "special"),
5538
+ WeakSet: /* @__PURE__ */ __name((value, options) => options.stylize("WeakSet{\u2026}", "special"), "WeakSet"),
5539
+ WeakMap: /* @__PURE__ */ __name((value, options) => options.stylize("WeakMap{\u2026}", "special"), "WeakMap"),
5571
5540
  Arguments: inspectArguments2,
5572
5541
  Int8Array: inspectTypedArray2,
5573
5542
  Uint8Array: inspectTypedArray2,
@@ -5578,18 +5547,18 @@ var baseTypesMap2 = {
5578
5547
  Uint32Array: inspectTypedArray2,
5579
5548
  Float32Array: inspectTypedArray2,
5580
5549
  Float64Array: inspectTypedArray2,
5581
- Generator: () => "",
5582
- DataView: () => "",
5583
- ArrayBuffer: () => "",
5550
+ Generator: /* @__PURE__ */ __name(() => "", "Generator"),
5551
+ DataView: /* @__PURE__ */ __name(() => "", "DataView"),
5552
+ ArrayBuffer: /* @__PURE__ */ __name(() => "", "ArrayBuffer"),
5584
5553
  Error: inspectObject22,
5585
- HTMLCollection: inspectHTMLCollection,
5586
- NodeList: inspectHTMLCollection
5554
+ HTMLCollection: inspectNodeCollection2,
5555
+ NodeList: inspectNodeCollection2
5587
5556
  };
5588
5557
  var inspectCustom2 = /* @__PURE__ */ __name((value, options, type3) => {
5589
5558
  if (chaiInspect2 in value && typeof value[chaiInspect2] === "function") {
5590
5559
  return value[chaiInspect2](options);
5591
5560
  }
5592
- if (nodeInspect2 && nodeInspect2 in value && typeof value[nodeInspect2] === "function") {
5561
+ if (nodeInspect2 in value && typeof value[nodeInspect2] === "function") {
5593
5562
  return value[nodeInspect2](options.depth, options);
5594
5563
  }
5595
5564
  if ("inspect" in value && typeof value.inspect === "function") {
@@ -5749,7 +5718,7 @@ var config = {
5749
5718
  deepEqual: null
5750
5719
  };
5751
5720
  function inspect22(obj, showHidden, depth, colors) {
5752
- var options = {
5721
+ let options = {
5753
5722
  colors,
5754
5723
  depth: typeof depth === "undefined" ? 2 : depth,
5755
5724
  showHidden,
@@ -5759,14 +5728,14 @@ function inspect22(obj, showHidden, depth, colors) {
5759
5728
  }
5760
5729
  __name(inspect22, "inspect");
5761
5730
  function objDisplay2(obj) {
5762
- var str = inspect22(obj), type3 = Object.prototype.toString.call(obj);
5731
+ let str = inspect22(obj), type3 = Object.prototype.toString.call(obj);
5763
5732
  if (config.truncateThreshold && str.length >= config.truncateThreshold) {
5764
5733
  if (type3 === "[object Function]") {
5765
5734
  return !obj.name || obj.name === "" ? "[Function]" : "[Function: " + obj.name + "]";
5766
5735
  } else if (type3 === "[object Array]") {
5767
5736
  return "[ Array(" + obj.length + ") ]";
5768
5737
  } else if (type3 === "[object Object]") {
5769
- var keys2 = Object.keys(obj), kstr = keys2.length > 2 ? keys2.splice(0, 2).join(", ") + ", ..." : keys2.join(", ");
5738
+ let keys2 = Object.keys(obj), kstr = keys2.length > 2 ? keys2.splice(0, 2).join(", ") + ", ..." : keys2.join(", ");
5770
5739
  return "{ Object (" + kstr + ") }";
5771
5740
  } else {
5772
5741
  return str;
@@ -5777,9 +5746,13 @@ function objDisplay2(obj) {
5777
5746
  }
5778
5747
  __name(objDisplay2, "objDisplay");
5779
5748
  function getMessage2(obj, args) {
5780
- var negate = flag(obj, "negate"), val = flag(obj, "object"), expected = args[3], actual = getActual(obj, args), msg = negate ? args[2] : args[1], flagMsg = flag(obj, "message");
5781
- if (typeof msg === "function")
5782
- msg = msg();
5749
+ let negate = flag(obj, "negate");
5750
+ let val = flag(obj, "object");
5751
+ let expected = args[3];
5752
+ let actual = getActual(obj, args);
5753
+ let msg = negate ? args[2] : args[1];
5754
+ let flagMsg = flag(obj, "message");
5755
+ if (typeof msg === "function") msg = msg();
5783
5756
  msg = msg || "";
5784
5757
  msg = msg.replace(/#\{this\}/g, function() {
5785
5758
  return objDisplay2(val);
@@ -5792,12 +5765,12 @@ function getMessage2(obj, args) {
5792
5765
  }
5793
5766
  __name(getMessage2, "getMessage");
5794
5767
  function transferFlags(assertion, object2, includeAll) {
5795
- var flags = assertion.__flags || (assertion.__flags = /* @__PURE__ */ Object.create(null));
5768
+ let flags = assertion.__flags || (assertion.__flags = /* @__PURE__ */ Object.create(null));
5796
5769
  if (!object2.__flags) {
5797
5770
  object2.__flags = /* @__PURE__ */ Object.create(null);
5798
5771
  }
5799
5772
  includeAll = arguments.length === 3 ? includeAll : true;
5800
- for (var flag3 in flags) {
5773
+ for (let flag3 in flags) {
5801
5774
  if (includeAll || flag3 !== "object" && flag3 !== "ssfi" && flag3 !== "lockSsfi" && flag3 != "message") {
5802
5775
  object2.__flags[flag3] = flags[flag3];
5803
5776
  }
@@ -6185,96 +6158,183 @@ function getPathInfo(obj, path) {
6185
6158
  return info;
6186
6159
  }
6187
6160
  __name(getPathInfo, "getPathInfo");
6188
- function Assertion(obj, msg, ssfi, lockSsfi) {
6189
- flag(this, "ssfi", ssfi || Assertion);
6190
- flag(this, "lockSsfi", lockSsfi);
6191
- flag(this, "object", obj);
6192
- flag(this, "message", msg);
6193
- flag(this, "eql", config.deepEqual || deep_eql_default);
6194
- return proxify(this);
6195
- }
6196
- __name(Assertion, "Assertion");
6197
- Object.defineProperty(Assertion, "includeStack", {
6198
- get: function() {
6161
+ var Assertion = class _Assertion {
6162
+ static {
6163
+ __name(this, "Assertion");
6164
+ }
6165
+ /** @type {{}} */
6166
+ __flags = {};
6167
+ /**
6168
+ * Creates object for chaining.
6169
+ * `Assertion` objects contain metadata in the form of flags. Three flags can
6170
+ * be assigned during instantiation by passing arguments to this constructor:
6171
+ *
6172
+ * - `object`: This flag contains the target of the assertion. For example, in
6173
+ * the assertion `expect(numKittens).to.equal(7);`, the `object` flag will
6174
+ * contain `numKittens` so that the `equal` assertion can reference it when
6175
+ * needed.
6176
+ *
6177
+ * - `message`: This flag contains an optional custom error message to be
6178
+ * prepended to the error message that's generated by the assertion when it
6179
+ * fails.
6180
+ *
6181
+ * - `ssfi`: This flag stands for "start stack function indicator". It
6182
+ * contains a function reference that serves as the starting point for
6183
+ * removing frames from the stack trace of the error that's created by the
6184
+ * assertion when it fails. The goal is to provide a cleaner stack trace to
6185
+ * end users by removing Chai's internal functions. Note that it only works
6186
+ * in environments that support `Error.captureStackTrace`, and only when
6187
+ * `Chai.config.includeStack` hasn't been set to `false`.
6188
+ *
6189
+ * - `lockSsfi`: This flag controls whether or not the given `ssfi` flag
6190
+ * should retain its current value, even as assertions are chained off of
6191
+ * this object. This is usually set to `true` when creating a new assertion
6192
+ * from within another assertion. It's also temporarily set to `true` before
6193
+ * an overwritten assertion gets called by the overwriting assertion.
6194
+ *
6195
+ * - `eql`: This flag contains the deepEqual function to be used by the assertion.
6196
+ *
6197
+ * @param {unknown} obj target of the assertion
6198
+ * @param {string} [msg] (optional) custom error message
6199
+ * @param {Function} [ssfi] (optional) starting point for removing stack frames
6200
+ * @param {boolean} [lockSsfi] (optional) whether or not the ssfi flag is locked
6201
+ */
6202
+ constructor(obj, msg, ssfi, lockSsfi) {
6203
+ flag(this, "ssfi", ssfi || _Assertion);
6204
+ flag(this, "lockSsfi", lockSsfi);
6205
+ flag(this, "object", obj);
6206
+ flag(this, "message", msg);
6207
+ flag(this, "eql", config.deepEqual || deep_eql_default);
6208
+ return proxify(this);
6209
+ }
6210
+ /** @returns {boolean} */
6211
+ static get includeStack() {
6199
6212
  console.warn(
6200
6213
  "Assertion.includeStack is deprecated, use chai.config.includeStack instead."
6201
6214
  );
6202
6215
  return config.includeStack;
6203
- },
6204
- set: function(value) {
6216
+ }
6217
+ /** @param {boolean} value */
6218
+ static set includeStack(value) {
6205
6219
  console.warn(
6206
6220
  "Assertion.includeStack is deprecated, use chai.config.includeStack instead."
6207
6221
  );
6208
6222
  config.includeStack = value;
6209
6223
  }
6210
- });
6211
- Object.defineProperty(Assertion, "showDiff", {
6212
- get: function() {
6224
+ /** @returns {boolean} */
6225
+ static get showDiff() {
6213
6226
  console.warn(
6214
6227
  "Assertion.showDiff is deprecated, use chai.config.showDiff instead."
6215
6228
  );
6216
6229
  return config.showDiff;
6217
- },
6218
- set: function(value) {
6230
+ }
6231
+ /** @param {boolean} value */
6232
+ static set showDiff(value) {
6219
6233
  console.warn(
6220
6234
  "Assertion.showDiff is deprecated, use chai.config.showDiff instead."
6221
6235
  );
6222
6236
  config.showDiff = value;
6223
6237
  }
6224
- });
6225
- Assertion.addProperty = function(name, fn2) {
6226
- addProperty(this.prototype, name, fn2);
6227
- };
6228
- Assertion.addMethod = function(name, fn2) {
6229
- addMethod(this.prototype, name, fn2);
6230
- };
6231
- Assertion.addChainableMethod = function(name, fn2, chainingBehavior) {
6232
- addChainableMethod(this.prototype, name, fn2, chainingBehavior);
6233
- };
6234
- Assertion.overwriteProperty = function(name, fn2) {
6235
- overwriteProperty(this.prototype, name, fn2);
6236
- };
6237
- Assertion.overwriteMethod = function(name, fn2) {
6238
- overwriteMethod(this.prototype, name, fn2);
6239
- };
6240
- Assertion.overwriteChainableMethod = function(name, fn2, chainingBehavior) {
6241
- overwriteChainableMethod(this.prototype, name, fn2, chainingBehavior);
6242
- };
6243
- Assertion.prototype.assert = function(expr, msg, negateMsg, expected, _actual, showDiff) {
6244
- var ok = test2(this, arguments);
6245
- if (false !== showDiff)
6246
- showDiff = true;
6247
- if (void 0 === expected && void 0 === _actual)
6248
- showDiff = false;
6249
- if (true !== config.showDiff)
6250
- showDiff = false;
6251
- if (!ok) {
6252
- msg = getMessage2(this, arguments);
6253
- var actual = getActual(this, arguments);
6254
- var assertionErrorObjectProperties = {
6255
- actual,
6256
- expected,
6257
- showDiff
6258
- };
6259
- var operator = getOperator(this, arguments);
6260
- if (operator) {
6261
- assertionErrorObjectProperties.operator = operator;
6238
+ /**
6239
+ * @param {string} name
6240
+ * @param {Function} fn
6241
+ */
6242
+ static addProperty(name, fn2) {
6243
+ addProperty(this.prototype, name, fn2);
6244
+ }
6245
+ /**
6246
+ * @param {string} name
6247
+ * @param {Function} fn
6248
+ */
6249
+ static addMethod(name, fn2) {
6250
+ addMethod(this.prototype, name, fn2);
6251
+ }
6252
+ /**
6253
+ * @param {string} name
6254
+ * @param {Function} fn
6255
+ * @param {Function} chainingBehavior
6256
+ */
6257
+ static addChainableMethod(name, fn2, chainingBehavior) {
6258
+ addChainableMethod(this.prototype, name, fn2, chainingBehavior);
6259
+ }
6260
+ /**
6261
+ * @param {string} name
6262
+ * @param {Function} fn
6263
+ */
6264
+ static overwriteProperty(name, fn2) {
6265
+ overwriteProperty(this.prototype, name, fn2);
6266
+ }
6267
+ /**
6268
+ * @param {string} name
6269
+ * @param {Function} fn
6270
+ */
6271
+ static overwriteMethod(name, fn2) {
6272
+ overwriteMethod(this.prototype, name, fn2);
6273
+ }
6274
+ /**
6275
+ * @param {string} name
6276
+ * @param {Function} fn
6277
+ * @param {Function} chainingBehavior
6278
+ */
6279
+ static overwriteChainableMethod(name, fn2, chainingBehavior) {
6280
+ overwriteChainableMethod(this.prototype, name, fn2, chainingBehavior);
6281
+ }
6282
+ /**
6283
+ * ### .assert(expression, message, negateMessage, expected, actual, showDiff)
6284
+ *
6285
+ * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.
6286
+ *
6287
+ * @name assert
6288
+ * @param {unknown} _expr to be tested
6289
+ * @param {string | Function} msg or function that returns message to display if expression fails
6290
+ * @param {string | Function} _negateMsg or function that returns negatedMessage to display if negated expression fails
6291
+ * @param {unknown} expected value (remember to check for negation)
6292
+ * @param {unknown} _actual (optional) will default to `this.obj`
6293
+ * @param {boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails
6294
+ * @returns {void}
6295
+ */
6296
+ assert(_expr, msg, _negateMsg, expected, _actual, showDiff) {
6297
+ const ok = test2(this, arguments);
6298
+ if (false !== showDiff) showDiff = true;
6299
+ if (void 0 === expected && void 0 === _actual) showDiff = false;
6300
+ if (true !== config.showDiff) showDiff = false;
6301
+ if (!ok) {
6302
+ msg = getMessage2(this, arguments);
6303
+ const actual = getActual(this, arguments);
6304
+ const assertionErrorObjectProperties = {
6305
+ actual,
6306
+ expected,
6307
+ showDiff
6308
+ };
6309
+ const operator = getOperator(this, arguments);
6310
+ if (operator) {
6311
+ assertionErrorObjectProperties.operator = operator;
6312
+ }
6313
+ throw new AssertionError(
6314
+ msg,
6315
+ assertionErrorObjectProperties,
6316
+ // @ts-expect-error Not sure what to do about these types yet
6317
+ config.includeStack ? this.assert : flag(this, "ssfi")
6318
+ );
6262
6319
  }
6263
- throw new AssertionError(
6264
- msg,
6265
- assertionErrorObjectProperties,
6266
- config.includeStack ? this.assert : flag(this, "ssfi")
6267
- );
6268
6320
  }
6269
- };
6270
- Object.defineProperty(Assertion.prototype, "_obj", {
6271
- get: function() {
6321
+ /**
6322
+ * Quick reference to stored `actual` value for plugin developers.
6323
+ *
6324
+ * @returns {unknown}
6325
+ */
6326
+ get _obj() {
6272
6327
  return flag(this, "object");
6273
- },
6274
- set: function(val) {
6328
+ }
6329
+ /**
6330
+ * Quick reference to stored `actual` value for plugin developers.
6331
+ *
6332
+ * @param {unknown} val
6333
+ */
6334
+ set _obj(val) {
6275
6335
  flag(this, "object", val);
6276
6336
  }
6277
- });
6337
+ };
6278
6338
  function isProxyEnabled() {
6279
6339
  return config.useProxy && typeof Proxy !== "undefined" && typeof Reflect !== "undefined";
6280
6340
  }
@@ -6287,10 +6347,9 @@ function addProperty(ctx, name, getter) {
6287
6347
  if (!isProxyEnabled() && !flag(this, "lockSsfi")) {
6288
6348
  flag(this, "ssfi", propertyGetter);
6289
6349
  }
6290
- var result = getter.call(this);
6291
- if (result !== void 0)
6292
- return result;
6293
- var newAssertion = new Assertion();
6350
+ let result = getter.call(this);
6351
+ if (result !== void 0) return result;
6352
+ let newAssertion = new Assertion();
6294
6353
  transferFlags(this, newAssertion);
6295
6354
  return newAssertion;
6296
6355
  }, "propertyGetter"),
@@ -6301,10 +6360,9 @@ __name(addProperty, "addProperty");
6301
6360
  var fnLengthDesc = Object.getOwnPropertyDescriptor(function() {
6302
6361
  }, "length");
6303
6362
  function addLengthGuard(fn2, assertionName, isChainable) {
6304
- if (!fnLengthDesc.configurable)
6305
- return fn2;
6363
+ if (!fnLengthDesc.configurable) return fn2;
6306
6364
  Object.defineProperty(fn2, "length", {
6307
- get: function() {
6365
+ get: /* @__PURE__ */ __name(function() {
6308
6366
  if (isChainable) {
6309
6367
  throw Error(
6310
6368
  "Invalid Chai property: " + assertionName + '.length. Due to a compatibility issue, "length" cannot directly follow "' + assertionName + '". Use "' + assertionName + '.lengthOf" instead.'
@@ -6313,20 +6371,20 @@ function addLengthGuard(fn2, assertionName, isChainable) {
6313
6371
  throw Error(
6314
6372
  "Invalid Chai property: " + assertionName + '.length. See docs for proper usage of "' + assertionName + '".'
6315
6373
  );
6316
- }
6374
+ }, "get")
6317
6375
  });
6318
6376
  return fn2;
6319
6377
  }
6320
6378
  __name(addLengthGuard, "addLengthGuard");
6321
6379
  function getProperties(object2) {
6322
- var result = Object.getOwnPropertyNames(object2);
6380
+ let result = Object.getOwnPropertyNames(object2);
6323
6381
  function addProperty2(property) {
6324
6382
  if (result.indexOf(property) === -1) {
6325
6383
  result.push(property);
6326
6384
  }
6327
6385
  }
6328
6386
  __name(addProperty2, "addProperty");
6329
- var proto = Object.getPrototypeOf(object2);
6387
+ let proto = Object.getPrototypeOf(object2);
6330
6388
  while (proto !== null) {
6331
6389
  Object.getOwnPropertyNames(proto).forEach(addProperty2);
6332
6390
  proto = Object.getPrototypeOf(proto);
@@ -6336,8 +6394,7 @@ function getProperties(object2) {
6336
6394
  __name(getProperties, "getProperties");
6337
6395
  var builtins = ["__flags", "__methods", "_obj", "assert"];
6338
6396
  function proxify(obj, nonChainableMethodName) {
6339
- if (!isProxyEnabled())
6340
- return obj;
6397
+ if (!isProxyEnabled()) return obj;
6341
6398
  return new Proxy(obj, {
6342
6399
  get: /* @__PURE__ */ __name(function proxyGetter(target, property) {
6343
6400
  if (typeof property === "string" && config.proxyExcludedKeys.indexOf(property) === -1 && !Reflect.has(target, property)) {
@@ -6346,15 +6403,15 @@ function proxify(obj, nonChainableMethodName) {
6346
6403
  "Invalid Chai property: " + nonChainableMethodName + "." + property + '. See docs for proper usage of "' + nonChainableMethodName + '".'
6347
6404
  );
6348
6405
  }
6349
- var suggestion = null;
6350
- var suggestionDistance = 4;
6406
+ let suggestion = null;
6407
+ let suggestionDistance = 4;
6351
6408
  getProperties(target).forEach(function(prop) {
6352
6409
  if (
6353
6410
  // we actually mean to check `Object.prototype` here
6354
6411
  // eslint-disable-next-line no-prototype-builtins
6355
6412
  !Object.prototype.hasOwnProperty(prop) && builtins.indexOf(prop) === -1
6356
6413
  ) {
6357
- var dist = stringDistanceCapped(property, prop, suggestionDistance);
6414
+ let dist = stringDistanceCapped(property, prop, suggestionDistance);
6358
6415
  if (dist < suggestionDistance) {
6359
6416
  suggestion = prop;
6360
6417
  suggestionDistance = dist;
@@ -6381,25 +6438,25 @@ function stringDistanceCapped(strA, strB, cap) {
6381
6438
  if (Math.abs(strA.length - strB.length) >= cap) {
6382
6439
  return cap;
6383
6440
  }
6384
- var memo = [];
6441
+ let memo = [];
6385
6442
  for (let i = 0; i <= strA.length; i++) {
6386
6443
  memo[i] = Array(strB.length + 1).fill(0);
6387
6444
  memo[i][0] = i;
6388
6445
  }
6389
- for (let j = 0; j < strB.length; j++) {
6390
- memo[0][j] = j;
6446
+ for (let j2 = 0; j2 < strB.length; j2++) {
6447
+ memo[0][j2] = j2;
6391
6448
  }
6392
6449
  for (let i = 1; i <= strA.length; i++) {
6393
- var ch = strA.charCodeAt(i - 1);
6394
- for (let j = 1; j <= strB.length; j++) {
6395
- if (Math.abs(i - j) >= cap) {
6396
- memo[i][j] = cap;
6450
+ let ch = strA.charCodeAt(i - 1);
6451
+ for (let j2 = 1; j2 <= strB.length; j2++) {
6452
+ if (Math.abs(i - j2) >= cap) {
6453
+ memo[i][j2] = cap;
6397
6454
  continue;
6398
6455
  }
6399
- memo[i][j] = Math.min(
6400
- memo[i - 1][j] + 1,
6401
- memo[i][j - 1] + 1,
6402
- memo[i - 1][j - 1] + (ch === strB.charCodeAt(j - 1) ? 0 : 1)
6456
+ memo[i][j2] = Math.min(
6457
+ memo[i - 1][j2] + 1,
6458
+ memo[i][j2 - 1] + 1,
6459
+ memo[i - 1][j2 - 1] + (ch === strB.charCodeAt(j2 - 1) ? 0 : 1)
6403
6460
  );
6404
6461
  }
6405
6462
  }
@@ -6407,14 +6464,13 @@ function stringDistanceCapped(strA, strB, cap) {
6407
6464
  }
6408
6465
  __name(stringDistanceCapped, "stringDistanceCapped");
6409
6466
  function addMethod(ctx, name, method) {
6410
- var methodWrapper = /* @__PURE__ */ __name(function() {
6467
+ let methodWrapper = /* @__PURE__ */ __name(function() {
6411
6468
  if (!flag(this, "lockSsfi")) {
6412
6469
  flag(this, "ssfi", methodWrapper);
6413
6470
  }
6414
- var result = method.apply(this, arguments);
6415
- if (result !== void 0)
6416
- return result;
6417
- var newAssertion = new Assertion();
6471
+ let result = method.apply(this, arguments);
6472
+ if (result !== void 0) return result;
6473
+ let newAssertion = new Assertion();
6418
6474
  transferFlags(this, newAssertion);
6419
6475
  return newAssertion;
6420
6476
  }, "methodWrapper");
@@ -6423,23 +6479,22 @@ function addMethod(ctx, name, method) {
6423
6479
  }
6424
6480
  __name(addMethod, "addMethod");
6425
6481
  function overwriteProperty(ctx, name, getter) {
6426
- var _get = Object.getOwnPropertyDescriptor(ctx, name), _super = /* @__PURE__ */ __name(function() {
6482
+ let _get = Object.getOwnPropertyDescriptor(ctx, name), _super = /* @__PURE__ */ __name(function() {
6427
6483
  }, "_super");
6428
- if (_get && "function" === typeof _get.get)
6429
- _super = _get.get;
6484
+ if (_get && "function" === typeof _get.get) _super = _get.get;
6430
6485
  Object.defineProperty(ctx, name, {
6431
6486
  get: /* @__PURE__ */ __name(function overwritingPropertyGetter() {
6432
6487
  if (!isProxyEnabled() && !flag(this, "lockSsfi")) {
6433
6488
  flag(this, "ssfi", overwritingPropertyGetter);
6434
6489
  }
6435
- var origLockSsfi = flag(this, "lockSsfi");
6490
+ let origLockSsfi = flag(this, "lockSsfi");
6436
6491
  flag(this, "lockSsfi", true);
6437
- var result = getter(_super).call(this);
6492
+ let result = getter(_super).call(this);
6438
6493
  flag(this, "lockSsfi", origLockSsfi);
6439
6494
  if (result !== void 0) {
6440
6495
  return result;
6441
6496
  }
6442
- var newAssertion = new Assertion();
6497
+ let newAssertion = new Assertion();
6443
6498
  transferFlags(this, newAssertion);
6444
6499
  return newAssertion;
6445
6500
  }, "overwritingPropertyGetter"),
@@ -6448,23 +6503,22 @@ function overwriteProperty(ctx, name, getter) {
6448
6503
  }
6449
6504
  __name(overwriteProperty, "overwriteProperty");
6450
6505
  function overwriteMethod(ctx, name, method) {
6451
- var _method = ctx[name], _super = /* @__PURE__ */ __name(function() {
6506
+ let _method = ctx[name], _super = /* @__PURE__ */ __name(function() {
6452
6507
  throw new Error(name + " is not a function");
6453
6508
  }, "_super");
6454
- if (_method && "function" === typeof _method)
6455
- _super = _method;
6456
- var overwritingMethodWrapper = /* @__PURE__ */ __name(function() {
6509
+ if (_method && "function" === typeof _method) _super = _method;
6510
+ let overwritingMethodWrapper = /* @__PURE__ */ __name(function() {
6457
6511
  if (!flag(this, "lockSsfi")) {
6458
6512
  flag(this, "ssfi", overwritingMethodWrapper);
6459
6513
  }
6460
- var origLockSsfi = flag(this, "lockSsfi");
6514
+ let origLockSsfi = flag(this, "lockSsfi");
6461
6515
  flag(this, "lockSsfi", true);
6462
- var result = method(_super).apply(this, arguments);
6516
+ let result = method(_super).apply(this, arguments);
6463
6517
  flag(this, "lockSsfi", origLockSsfi);
6464
6518
  if (result !== void 0) {
6465
6519
  return result;
6466
6520
  }
6467
- var newAssertion = new Assertion();
6521
+ let newAssertion = new Assertion();
6468
6522
  transferFlags(this, newAssertion);
6469
6523
  return newAssertion;
6470
6524
  }, "overwritingMethodWrapper");
@@ -6476,9 +6530,8 @@ var canSetPrototype = typeof Object.setPrototypeOf === "function";
6476
6530
  var testFn = /* @__PURE__ */ __name(function() {
6477
6531
  }, "testFn");
6478
6532
  var excludeNames = Object.getOwnPropertyNames(testFn).filter(function(name) {
6479
- var propDesc = Object.getOwnPropertyDescriptor(testFn, name);
6480
- if (typeof propDesc !== "object")
6481
- return true;
6533
+ let propDesc = Object.getOwnPropertyDescriptor(testFn, name);
6534
+ if (typeof propDesc !== "object") return true;
6482
6535
  return !propDesc.configurable;
6483
6536
  });
6484
6537
  var call = Function.prototype.call;
@@ -6488,7 +6541,7 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
6488
6541
  chainingBehavior = /* @__PURE__ */ __name(function() {
6489
6542
  }, "chainingBehavior");
6490
6543
  }
6491
- var chainableBehavior = {
6544
+ let chainableBehavior = {
6492
6545
  method,
6493
6546
  chainingBehavior
6494
6547
  };
@@ -6499,31 +6552,31 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
6499
6552
  Object.defineProperty(ctx, name, {
6500
6553
  get: /* @__PURE__ */ __name(function chainableMethodGetter() {
6501
6554
  chainableBehavior.chainingBehavior.call(this);
6502
- var chainableMethodWrapper = /* @__PURE__ */ __name(function() {
6555
+ let chainableMethodWrapper = /* @__PURE__ */ __name(function() {
6503
6556
  if (!flag(this, "lockSsfi")) {
6504
6557
  flag(this, "ssfi", chainableMethodWrapper);
6505
6558
  }
6506
- var result = chainableBehavior.method.apply(this, arguments);
6559
+ let result = chainableBehavior.method.apply(this, arguments);
6507
6560
  if (result !== void 0) {
6508
6561
  return result;
6509
6562
  }
6510
- var newAssertion = new Assertion();
6563
+ let newAssertion = new Assertion();
6511
6564
  transferFlags(this, newAssertion);
6512
6565
  return newAssertion;
6513
6566
  }, "chainableMethodWrapper");
6514
6567
  addLengthGuard(chainableMethodWrapper, name, true);
6515
6568
  if (canSetPrototype) {
6516
- var prototype = Object.create(this);
6569
+ let prototype = Object.create(this);
6517
6570
  prototype.call = call;
6518
6571
  prototype.apply = apply;
6519
6572
  Object.setPrototypeOf(chainableMethodWrapper, prototype);
6520
6573
  } else {
6521
- var asserterNames = Object.getOwnPropertyNames(ctx);
6574
+ let asserterNames = Object.getOwnPropertyNames(ctx);
6522
6575
  asserterNames.forEach(function(asserterName) {
6523
6576
  if (excludeNames.indexOf(asserterName) !== -1) {
6524
6577
  return;
6525
6578
  }
6526
- var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
6579
+ let pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
6527
6580
  Object.defineProperty(chainableMethodWrapper, asserterName, pd);
6528
6581
  });
6529
6582
  }
@@ -6535,36 +6588,35 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
6535
6588
  }
6536
6589
  __name(addChainableMethod, "addChainableMethod");
6537
6590
  function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
6538
- var chainableBehavior = ctx.__methods[name];
6539
- var _chainingBehavior = chainableBehavior.chainingBehavior;
6591
+ let chainableBehavior = ctx.__methods[name];
6592
+ let _chainingBehavior = chainableBehavior.chainingBehavior;
6540
6593
  chainableBehavior.chainingBehavior = /* @__PURE__ */ __name(function overwritingChainableMethodGetter() {
6541
- var result = chainingBehavior(_chainingBehavior).call(this);
6594
+ let result = chainingBehavior(_chainingBehavior).call(this);
6542
6595
  if (result !== void 0) {
6543
6596
  return result;
6544
6597
  }
6545
- var newAssertion = new Assertion();
6598
+ let newAssertion = new Assertion();
6546
6599
  transferFlags(this, newAssertion);
6547
6600
  return newAssertion;
6548
6601
  }, "overwritingChainableMethodGetter");
6549
- var _method = chainableBehavior.method;
6602
+ let _method = chainableBehavior.method;
6550
6603
  chainableBehavior.method = /* @__PURE__ */ __name(function overwritingChainableMethodWrapper() {
6551
- var result = method(_method).apply(this, arguments);
6604
+ let result = method(_method).apply(this, arguments);
6552
6605
  if (result !== void 0) {
6553
6606
  return result;
6554
6607
  }
6555
- var newAssertion = new Assertion();
6608
+ let newAssertion = new Assertion();
6556
6609
  transferFlags(this, newAssertion);
6557
6610
  return newAssertion;
6558
6611
  }, "overwritingChainableMethodWrapper");
6559
6612
  }
6560
6613
  __name(overwriteChainableMethod, "overwriteChainableMethod");
6561
- function compareByInspect(a3, b) {
6562
- return inspect22(a3) < inspect22(b) ? -1 : 1;
6614
+ function compareByInspect(a3, b2) {
6615
+ return inspect22(a3) < inspect22(b2) ? -1 : 1;
6563
6616
  }
6564
6617
  __name(compareByInspect, "compareByInspect");
6565
6618
  function getOwnEnumerablePropertySymbols(obj) {
6566
- if (typeof Object.getOwnPropertySymbols !== "function")
6567
- return [];
6619
+ if (typeof Object.getOwnPropertySymbols !== "function") return [];
6568
6620
  return Object.getOwnPropertySymbols(obj).filter(function(sym) {
6569
6621
  return Object.getOwnPropertyDescriptor(obj, sym).enumerable;
6570
6622
  });
@@ -6576,21 +6628,20 @@ function getOwnEnumerableProperties(obj) {
6576
6628
  __name(getOwnEnumerableProperties, "getOwnEnumerableProperties");
6577
6629
  var isNaN22 = Number.isNaN;
6578
6630
  function isObjectType(obj) {
6579
- var objectType = type(obj);
6580
- var objectTypes = ["Array", "Object", "Function"];
6631
+ let objectType = type(obj);
6632
+ let objectTypes = ["Array", "Object", "Function"];
6581
6633
  return objectTypes.indexOf(objectType) !== -1;
6582
6634
  }
6583
6635
  __name(isObjectType, "isObjectType");
6584
6636
  function getOperator(obj, args) {
6585
- var operator = flag(obj, "operator");
6586
- var negate = flag(obj, "negate");
6587
- var expected = args[3];
6588
- var msg = negate ? args[2] : args[1];
6637
+ let operator = flag(obj, "operator");
6638
+ let negate = flag(obj, "negate");
6639
+ let expected = args[3];
6640
+ let msg = negate ? args[2] : args[1];
6589
6641
  if (operator) {
6590
6642
  return operator;
6591
6643
  }
6592
- if (typeof msg === "function")
6593
- msg = msg();
6644
+ if (typeof msg === "function") msg = msg();
6594
6645
  msg = msg || "";
6595
6646
  if (!msg) {
6596
6647
  return void 0;
@@ -6598,7 +6649,7 @@ function getOperator(obj, args) {
6598
6649
  if (/\shave\s/.test(msg)) {
6599
6650
  return void 0;
6600
6651
  }
6601
- var isObject3 = isObjectType(expected);
6652
+ let isObject3 = isObjectType(expected);
6602
6653
  if (/\snot\s/.test(msg)) {
6603
6654
  return isObject3 ? "notDeepStrictEqual" : "notStrictEqual";
6604
6655
  }
@@ -6674,10 +6725,9 @@ var functionTypes = {
6674
6725
  asyncgeneratorfunction: ["asyncgeneratorfunction"]
6675
6726
  };
6676
6727
  function an(type3, msg) {
6677
- if (msg)
6678
- flag2(this, "message", msg);
6728
+ if (msg) flag2(this, "message", msg);
6679
6729
  type3 = type3.toLowerCase();
6680
- var obj = flag2(this, "object"), article = ~["a", "e", "i", "o", "u"].indexOf(type3.charAt(0)) ? "an " : "a ";
6730
+ let obj = flag2(this, "object"), article = ~["a", "e", "i", "o", "u"].indexOf(type3.charAt(0)) ? "an " : "a ";
6681
6731
  const detectedType = type(obj).toLowerCase();
6682
6732
  if (functionTypes["function"].includes(type3)) {
6683
6733
  this.assert(
@@ -6696,8 +6746,8 @@ function an(type3, msg) {
6696
6746
  __name(an, "an");
6697
6747
  Assertion.addChainableMethod("an", an);
6698
6748
  Assertion.addChainableMethod("a", an);
6699
- function SameValueZero(a3, b) {
6700
- return isNaN22(a3) && isNaN22(b) || a3 === b;
6749
+ function SameValueZero(a3, b2) {
6750
+ return isNaN22(a3) && isNaN22(b2) || a3 === b2;
6701
6751
  }
6702
6752
  __name(SameValueZero, "SameValueZero");
6703
6753
  function includeChainingBehavior() {
@@ -6705,11 +6755,10 @@ function includeChainingBehavior() {
6705
6755
  }
6706
6756
  __name(includeChainingBehavior, "includeChainingBehavior");
6707
6757
  function include(val, msg) {
6708
- if (msg)
6709
- flag2(this, "message", msg);
6710
- var 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;
6758
+ if (msg) flag2(this, "message", msg);
6759
+ 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;
6711
6760
  flagMsg = flagMsg ? flagMsg + ": " : "";
6712
- var included = false;
6761
+ let included = false;
6713
6762
  switch (objType) {
6714
6763
  case "string":
6715
6764
  included = obj.indexOf(val) !== -1;
@@ -6747,7 +6796,7 @@ function include(val, msg) {
6747
6796
  included = obj.indexOf(val) !== -1;
6748
6797
  }
6749
6798
  break;
6750
- default:
6799
+ default: {
6751
6800
  if (val !== Object(val)) {
6752
6801
  throw new AssertionError(
6753
6802
  flagMsg + "the given combination of arguments (" + objType + " and " + type(val).toLowerCase() + ") is invalid for this assertion. You can use an array, a map, an object, a set, a string, or a weakset instead of a " + type(val).toLowerCase(),
@@ -6755,9 +6804,11 @@ function include(val, msg) {
6755
6804
  ssfi
6756
6805
  );
6757
6806
  }
6758
- var props = Object.keys(val), firstErr = null, numErrs = 0;
6807
+ let props = Object.keys(val);
6808
+ let firstErr = null;
6809
+ let numErrs = 0;
6759
6810
  props.forEach(function(prop) {
6760
- var propAssertion = new Assertion(obj);
6811
+ let propAssertion = new Assertion(obj);
6761
6812
  transferFlags(this, propAssertion, true);
6762
6813
  flag2(propAssertion, "lockSsfi", true);
6763
6814
  if (!negate || props.length === 1) {
@@ -6770,8 +6821,7 @@ function include(val, msg) {
6770
6821
  if (!check_error_exports.compatibleConstructor(err, AssertionError)) {
6771
6822
  throw err;
6772
6823
  }
6773
- if (firstErr === null)
6774
- firstErr = err;
6824
+ if (firstErr === null) firstErr = err;
6775
6825
  numErrs++;
6776
6826
  }
6777
6827
  }, this);
@@ -6779,6 +6829,7 @@ function include(val, msg) {
6779
6829
  throw firstErr;
6780
6830
  }
6781
6831
  return;
6832
+ }
6782
6833
  }
6783
6834
  this.assert(
6784
6835
  included,
@@ -6862,7 +6913,7 @@ Assertion.addProperty("NaN", function() {
6862
6913
  );
6863
6914
  });
6864
6915
  function assertExist() {
6865
- var val = flag2(this, "object");
6916
+ let val = flag2(this, "object");
6866
6917
  this.assert(
6867
6918
  val !== null && val !== void 0,
6868
6919
  "expected #{this} to exist",
@@ -6873,7 +6924,7 @@ __name(assertExist, "assertExist");
6873
6924
  Assertion.addProperty("exist", assertExist);
6874
6925
  Assertion.addProperty("exists", assertExist);
6875
6926
  Assertion.addProperty("empty", function() {
6876
- var val = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), itemsCount;
6927
+ let val = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), itemsCount;
6877
6928
  flagMsg = flagMsg ? flagMsg + ": " : "";
6878
6929
  switch (type(val).toLowerCase()) {
6879
6930
  case "array":
@@ -6891,9 +6942,10 @@ Assertion.addProperty("empty", function() {
6891
6942
  void 0,
6892
6943
  ssfi
6893
6944
  );
6894
- case "function":
6895
- var msg = flagMsg + ".empty was passed a function " + getName(val);
6945
+ case "function": {
6946
+ const msg = flagMsg + ".empty was passed a function " + getName(val);
6896
6947
  throw new AssertionError(msg.trim(), void 0, ssfi);
6948
+ }
6897
6949
  default:
6898
6950
  if (val !== Object(val)) {
6899
6951
  throw new AssertionError(
@@ -6911,7 +6963,7 @@ Assertion.addProperty("empty", function() {
6911
6963
  );
6912
6964
  });
6913
6965
  function checkArguments() {
6914
- var obj = flag2(this, "object"), type3 = type(obj);
6966
+ let obj = flag2(this, "object"), type3 = type(obj);
6915
6967
  this.assert(
6916
6968
  "Arguments" === type3,
6917
6969
  "expected #{this} to be arguments but got " + type3,
@@ -6922,11 +6974,10 @@ __name(checkArguments, "checkArguments");
6922
6974
  Assertion.addProperty("arguments", checkArguments);
6923
6975
  Assertion.addProperty("Arguments", checkArguments);
6924
6976
  function assertEqual(val, msg) {
6925
- if (msg)
6926
- flag2(this, "message", msg);
6927
- var obj = flag2(this, "object");
6977
+ if (msg) flag2(this, "message", msg);
6978
+ let obj = flag2(this, "object");
6928
6979
  if (flag2(this, "deep")) {
6929
- var prevLockSsfi = flag2(this, "lockSsfi");
6980
+ let prevLockSsfi = flag2(this, "lockSsfi");
6930
6981
  flag2(this, "lockSsfi", true);
6931
6982
  this.eql(val);
6932
6983
  flag2(this, "lockSsfi", prevLockSsfi);
@@ -6946,9 +6997,8 @@ Assertion.addMethod("equal", assertEqual);
6946
6997
  Assertion.addMethod("equals", assertEqual);
6947
6998
  Assertion.addMethod("eq", assertEqual);
6948
6999
  function assertEql(obj, msg) {
6949
- if (msg)
6950
- flag2(this, "message", msg);
6951
- var eql = flag2(this, "eql");
7000
+ if (msg) flag2(this, "message", msg);
7001
+ let eql = flag2(this, "eql");
6952
7002
  this.assert(
6953
7003
  eql(obj, flag2(this, "object")),
6954
7004
  "expected #{this} to deeply equal #{exp}",
@@ -6962,9 +7012,8 @@ __name(assertEql, "assertEql");
6962
7012
  Assertion.addMethod("eql", assertEql);
6963
7013
  Assertion.addMethod("eqls", assertEql);
6964
7014
  function assertAbove(n, msg) {
6965
- if (msg)
6966
- flag2(this, "message", msg);
6967
- var obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase();
7015
+ if (msg) flag2(this, "message", msg);
7016
+ let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase();
6968
7017
  if (doLength && objType !== "map" && objType !== "set") {
6969
7018
  new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
6970
7019
  }
@@ -6981,7 +7030,7 @@ function assertAbove(n, msg) {
6981
7030
  ssfi
6982
7031
  );
6983
7032
  } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
6984
- var printObj = objType === "string" ? "'" + obj + "'" : obj;
7033
+ let printObj = objType === "string" ? "'" + obj + "'" : obj;
6985
7034
  throw new AssertionError(
6986
7035
  msgPrefix + "expected " + printObj + " to be a number or a date",
6987
7036
  void 0,
@@ -6989,7 +7038,7 @@ function assertAbove(n, msg) {
6989
7038
  );
6990
7039
  }
6991
7040
  if (doLength) {
6992
- var descriptor = "length", itemsCount;
7041
+ let descriptor = "length", itemsCount;
6993
7042
  if (objType === "map" || objType === "set") {
6994
7043
  descriptor = "size";
6995
7044
  itemsCount = obj.size;
@@ -7017,9 +7066,8 @@ Assertion.addMethod("above", assertAbove);
7017
7066
  Assertion.addMethod("gt", assertAbove);
7018
7067
  Assertion.addMethod("greaterThan", assertAbove);
7019
7068
  function assertLeast(n, msg) {
7020
- if (msg)
7021
- flag2(this, "message", msg);
7022
- var obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true;
7069
+ if (msg) flag2(this, "message", msg);
7070
+ let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true;
7023
7071
  if (doLength && objType !== "map" && objType !== "set") {
7024
7072
  new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
7025
7073
  }
@@ -7028,7 +7076,7 @@ function assertLeast(n, msg) {
7028
7076
  } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
7029
7077
  errorMessage = msgPrefix + "the argument to least must be a number";
7030
7078
  } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
7031
- var printObj = objType === "string" ? "'" + obj + "'" : obj;
7079
+ let printObj = objType === "string" ? "'" + obj + "'" : obj;
7032
7080
  errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
7033
7081
  } else {
7034
7082
  shouldThrow = false;
@@ -7037,7 +7085,7 @@ function assertLeast(n, msg) {
7037
7085
  throw new AssertionError(errorMessage, void 0, ssfi);
7038
7086
  }
7039
7087
  if (doLength) {
7040
- var descriptor = "length", itemsCount;
7088
+ let descriptor = "length", itemsCount;
7041
7089
  if (objType === "map" || objType === "set") {
7042
7090
  descriptor = "size";
7043
7091
  itemsCount = obj.size;
@@ -7065,9 +7113,8 @@ Assertion.addMethod("least", assertLeast);
7065
7113
  Assertion.addMethod("gte", assertLeast);
7066
7114
  Assertion.addMethod("greaterThanOrEqual", assertLeast);
7067
7115
  function assertBelow(n, msg) {
7068
- if (msg)
7069
- flag2(this, "message", msg);
7070
- var obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true;
7116
+ if (msg) flag2(this, "message", msg);
7117
+ let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true;
7071
7118
  if (doLength && objType !== "map" && objType !== "set") {
7072
7119
  new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
7073
7120
  }
@@ -7076,7 +7123,7 @@ function assertBelow(n, msg) {
7076
7123
  } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
7077
7124
  errorMessage = msgPrefix + "the argument to below must be a number";
7078
7125
  } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
7079
- var printObj = objType === "string" ? "'" + obj + "'" : obj;
7126
+ let printObj = objType === "string" ? "'" + obj + "'" : obj;
7080
7127
  errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
7081
7128
  } else {
7082
7129
  shouldThrow = false;
@@ -7085,7 +7132,7 @@ function assertBelow(n, msg) {
7085
7132
  throw new AssertionError(errorMessage, void 0, ssfi);
7086
7133
  }
7087
7134
  if (doLength) {
7088
- var descriptor = "length", itemsCount;
7135
+ let descriptor = "length", itemsCount;
7089
7136
  if (objType === "map" || objType === "set") {
7090
7137
  descriptor = "size";
7091
7138
  itemsCount = obj.size;
@@ -7113,9 +7160,8 @@ Assertion.addMethod("below", assertBelow);
7113
7160
  Assertion.addMethod("lt", assertBelow);
7114
7161
  Assertion.addMethod("lessThan", assertBelow);
7115
7162
  function assertMost(n, msg) {
7116
- if (msg)
7117
- flag2(this, "message", msg);
7118
- var obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true;
7163
+ if (msg) flag2(this, "message", msg);
7164
+ let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true;
7119
7165
  if (doLength && objType !== "map" && objType !== "set") {
7120
7166
  new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
7121
7167
  }
@@ -7124,7 +7170,7 @@ function assertMost(n, msg) {
7124
7170
  } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
7125
7171
  errorMessage = msgPrefix + "the argument to most must be a number";
7126
7172
  } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
7127
- var printObj = objType === "string" ? "'" + obj + "'" : obj;
7173
+ let printObj = objType === "string" ? "'" + obj + "'" : obj;
7128
7174
  errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
7129
7175
  } else {
7130
7176
  shouldThrow = false;
@@ -7133,7 +7179,7 @@ function assertMost(n, msg) {
7133
7179
  throw new AssertionError(errorMessage, void 0, ssfi);
7134
7180
  }
7135
7181
  if (doLength) {
7136
- var descriptor = "length", itemsCount;
7182
+ let descriptor = "length", itemsCount;
7137
7183
  if (objType === "map" || objType === "set") {
7138
7184
  descriptor = "size";
7139
7185
  itemsCount = obj.size;
@@ -7161,9 +7207,8 @@ Assertion.addMethod("most", assertMost);
7161
7207
  Assertion.addMethod("lte", assertMost);
7162
7208
  Assertion.addMethod("lessThanOrEqual", assertMost);
7163
7209
  Assertion.addMethod("within", function(start, finish, msg) {
7164
- if (msg)
7165
- flag2(this, "message", msg);
7166
- var obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), startType = type(start).toLowerCase(), finishType = type(finish).toLowerCase(), errorMessage, shouldThrow = true, range = startType === "date" && finishType === "date" ? start.toISOString() + ".." + finish.toISOString() : start + ".." + finish;
7210
+ if (msg) flag2(this, "message", msg);
7211
+ let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), startType = type(start).toLowerCase(), finishType = type(finish).toLowerCase(), errorMessage, shouldThrow = true, range = startType === "date" && finishType === "date" ? start.toISOString() + ".." + finish.toISOString() : start + ".." + finish;
7167
7212
  if (doLength && objType !== "map" && objType !== "set") {
7168
7213
  new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
7169
7214
  }
@@ -7172,7 +7217,7 @@ Assertion.addMethod("within", function(start, finish, msg) {
7172
7217
  } else if ((!isNumeric(start) || !isNumeric(finish)) && (doLength || isNumeric(obj))) {
7173
7218
  errorMessage = msgPrefix + "the arguments to within must be numbers";
7174
7219
  } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
7175
- var printObj = objType === "string" ? "'" + obj + "'" : obj;
7220
+ let printObj = objType === "string" ? "'" + obj + "'" : obj;
7176
7221
  errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
7177
7222
  } else {
7178
7223
  shouldThrow = false;
@@ -7181,7 +7226,7 @@ Assertion.addMethod("within", function(start, finish, msg) {
7181
7226
  throw new AssertionError(errorMessage, void 0, ssfi);
7182
7227
  }
7183
7228
  if (doLength) {
7184
- var descriptor = "length", itemsCount;
7229
+ let descriptor = "length", itemsCount;
7185
7230
  if (objType === "map" || objType === "set") {
7186
7231
  descriptor = "size";
7187
7232
  itemsCount = obj.size;
@@ -7202,13 +7247,13 @@ Assertion.addMethod("within", function(start, finish, msg) {
7202
7247
  }
7203
7248
  });
7204
7249
  function assertInstanceOf(constructor, msg) {
7205
- if (msg)
7206
- flag2(this, "message", msg);
7207
- var target = flag2(this, "object");
7208
- var ssfi = flag2(this, "ssfi");
7209
- var flagMsg = flag2(this, "message");
7250
+ if (msg) flag2(this, "message", msg);
7251
+ let target = flag2(this, "object");
7252
+ let ssfi = flag2(this, "ssfi");
7253
+ let flagMsg = flag2(this, "message");
7254
+ let isInstanceOf;
7210
7255
  try {
7211
- var isInstanceOf = target instanceof constructor;
7256
+ isInstanceOf = target instanceof constructor;
7212
7257
  } catch (err) {
7213
7258
  if (err instanceof TypeError) {
7214
7259
  flagMsg = flagMsg ? flagMsg + ": " : "";
@@ -7220,7 +7265,7 @@ function assertInstanceOf(constructor, msg) {
7220
7265
  }
7221
7266
  throw err;
7222
7267
  }
7223
- var name = getName(constructor);
7268
+ let name = getName(constructor);
7224
7269
  if (name == null) {
7225
7270
  name = "an unnamed constructor";
7226
7271
  }
@@ -7234,9 +7279,8 @@ __name(assertInstanceOf, "assertInstanceOf");
7234
7279
  Assertion.addMethod("instanceof", assertInstanceOf);
7235
7280
  Assertion.addMethod("instanceOf", assertInstanceOf);
7236
7281
  function assertProperty(name, val, msg) {
7237
- if (msg)
7238
- flag2(this, "message", msg);
7239
- var isNested = flag2(this, "nested"), isOwn = flag2(this, "own"), flagMsg = flag2(this, "message"), obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), nameType = typeof name;
7282
+ if (msg) flag2(this, "message", msg);
7283
+ let isNested = flag2(this, "nested"), isOwn = flag2(this, "own"), flagMsg = flag2(this, "message"), obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), nameType = typeof name;
7240
7284
  flagMsg = flagMsg ? flagMsg + ": " : "";
7241
7285
  if (isNested) {
7242
7286
  if (nameType !== "string") {
@@ -7269,22 +7313,16 @@ function assertProperty(name, val, msg) {
7269
7313
  ssfi
7270
7314
  );
7271
7315
  }
7272
- var isDeep = flag2(this, "deep"), negate = flag2(this, "negate"), pathInfo = isNested ? getPathInfo(obj, name) : null, value = isNested ? pathInfo.value : obj[name], isEql = isDeep ? flag2(this, "eql") : (val1, val2) => val1 === val2;
7273
- var descriptor = "";
7274
- if (isDeep)
7275
- descriptor += "deep ";
7276
- if (isOwn)
7277
- descriptor += "own ";
7278
- if (isNested)
7279
- descriptor += "nested ";
7316
+ let isDeep = flag2(this, "deep"), negate = flag2(this, "negate"), pathInfo = isNested ? getPathInfo(obj, name) : null, value = isNested ? pathInfo.value : obj[name], isEql = isDeep ? flag2(this, "eql") : (val1, val2) => val1 === val2;
7317
+ let descriptor = "";
7318
+ if (isDeep) descriptor += "deep ";
7319
+ if (isOwn) descriptor += "own ";
7320
+ if (isNested) descriptor += "nested ";
7280
7321
  descriptor += "property ";
7281
- var hasProperty2;
7282
- if (isOwn)
7283
- hasProperty2 = Object.prototype.hasOwnProperty.call(obj, name);
7284
- else if (isNested)
7285
- hasProperty2 = pathInfo.exists;
7286
- else
7287
- hasProperty2 = hasProperty(obj, name);
7322
+ let hasProperty2;
7323
+ if (isOwn) hasProperty2 = Object.prototype.hasOwnProperty.call(obj, name);
7324
+ else if (isNested) hasProperty2 = pathInfo.exists;
7325
+ else hasProperty2 = hasProperty(obj, name);
7288
7326
  if (!negate || arguments.length === 1) {
7289
7327
  this.assert(
7290
7328
  hasProperty2,
@@ -7317,11 +7355,10 @@ function assertOwnPropertyDescriptor(name, descriptor, msg) {
7317
7355
  msg = descriptor;
7318
7356
  descriptor = null;
7319
7357
  }
7320
- if (msg)
7321
- flag2(this, "message", msg);
7322
- var obj = flag2(this, "object");
7323
- var actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name);
7324
- var eql = flag2(this, "eql");
7358
+ if (msg) flag2(this, "message", msg);
7359
+ let obj = flag2(this, "object");
7360
+ let actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name);
7361
+ let eql = flag2(this, "eql");
7325
7362
  if (actualDescriptor && descriptor) {
7326
7363
  this.assert(
7327
7364
  eql(descriptor, actualDescriptor),
@@ -7348,9 +7385,8 @@ function assertLengthChain() {
7348
7385
  }
7349
7386
  __name(assertLengthChain, "assertLengthChain");
7350
7387
  function assertLength(n, msg) {
7351
- if (msg)
7352
- flag2(this, "message", msg);
7353
- var obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), descriptor = "length", itemsCount;
7388
+ if (msg) flag2(this, "message", msg);
7389
+ let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), descriptor = "length", itemsCount;
7354
7390
  switch (objType) {
7355
7391
  case "map":
7356
7392
  case "set":
@@ -7373,9 +7409,8 @@ __name(assertLength, "assertLength");
7373
7409
  Assertion.addChainableMethod("length", assertLength, assertLengthChain);
7374
7410
  Assertion.addChainableMethod("lengthOf", assertLength, assertLengthChain);
7375
7411
  function assertMatch(re, msg) {
7376
- if (msg)
7377
- flag2(this, "message", msg);
7378
- var obj = flag2(this, "object");
7412
+ if (msg) flag2(this, "message", msg);
7413
+ let obj = flag2(this, "object");
7379
7414
  this.assert(
7380
7415
  re.exec(obj),
7381
7416
  "expected #{this} to match " + re,
@@ -7386,9 +7421,8 @@ __name(assertMatch, "assertMatch");
7386
7421
  Assertion.addMethod("match", assertMatch);
7387
7422
  Assertion.addMethod("matches", assertMatch);
7388
7423
  Assertion.addMethod("string", function(str, msg) {
7389
- if (msg)
7390
- flag2(this, "message", msg);
7391
- var obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
7424
+ if (msg) flag2(this, "message", msg);
7425
+ let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
7392
7426
  new Assertion(obj, flagMsg, ssfi, true).is.a("string");
7393
7427
  this.assert(
7394
7428
  ~obj.indexOf(str),
@@ -7397,9 +7431,9 @@ Assertion.addMethod("string", function(str, msg) {
7397
7431
  );
7398
7432
  });
7399
7433
  function assertKeys(keys2) {
7400
- var obj = flag2(this, "object"), objType = type(obj), keysType = type(keys2), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), str, deepStr = "", actual, ok = true, flagMsg = flag2(this, "message");
7434
+ let obj = flag2(this, "object"), objType = type(obj), keysType = type(keys2), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), str, deepStr = "", actual, ok = true, flagMsg = flag2(this, "message");
7401
7435
  flagMsg = flagMsg ? flagMsg + ": " : "";
7402
- var mixedArgsMsg = flagMsg + "when testing keys against an object or an array you must give a single Array|Object|String argument or multiple String arguments";
7436
+ let mixedArgsMsg = flagMsg + "when testing keys against an object or an array you must give a single Array|Object|String argument or multiple String arguments";
7403
7437
  if (objType === "Map" || objType === "Set") {
7404
7438
  deepStr = isDeep ? "deeply " : "";
7405
7439
  actual = [];
@@ -7433,7 +7467,7 @@ function assertKeys(keys2) {
7433
7467
  if (!keys2.length) {
7434
7468
  throw new AssertionError(flagMsg + "keys required", void 0, ssfi);
7435
7469
  }
7436
- var len = keys2.length, any = flag2(this, "any"), all = flag2(this, "all"), expected = keys2, isEql = isDeep ? flag2(this, "eql") : (val1, val2) => val1 === val2;
7470
+ let len = keys2.length, any = flag2(this, "any"), all = flag2(this, "all"), expected = keys2, isEql = isDeep ? flag2(this, "eql") : (val1, val2) => val1 === val2;
7437
7471
  if (!any && !all) {
7438
7472
  all = true;
7439
7473
  }
@@ -7458,7 +7492,7 @@ function assertKeys(keys2) {
7458
7492
  keys2 = keys2.map(function(key) {
7459
7493
  return inspect22(key);
7460
7494
  });
7461
- var last = keys2.pop();
7495
+ let last = keys2.pop();
7462
7496
  if (all) {
7463
7497
  str = keys2.join(", ") + ", and " + last;
7464
7498
  }
@@ -7483,9 +7517,8 @@ __name(assertKeys, "assertKeys");
7483
7517
  Assertion.addMethod("keys", assertKeys);
7484
7518
  Assertion.addMethod("key", assertKeys);
7485
7519
  function assertThrows(errorLike, errMsgMatcher, msg) {
7486
- if (msg)
7487
- flag2(this, "message", msg);
7488
- var obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), negate = flag2(this, "negate") || false;
7520
+ if (msg) flag2(this, "message", msg);
7521
+ let obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), negate = flag2(this, "negate") || false;
7489
7522
  new Assertion(obj, flagMsg, ssfi, true).is.a("function");
7490
7523
  if (isRegExp2(errorLike) || typeof errorLike === "string") {
7491
7524
  errMsgMatcher = errorLike;
@@ -7499,12 +7532,12 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
7499
7532
  errorWasThrown = true;
7500
7533
  caughtErr = err;
7501
7534
  }
7502
- var everyArgIsUndefined = errorLike === void 0 && errMsgMatcher === void 0;
7503
- var everyArgIsDefined = Boolean(errorLike && errMsgMatcher);
7504
- var errorLikeFail = false;
7505
- var errMsgMatcherFail = false;
7535
+ let everyArgIsUndefined = errorLike === void 0 && errMsgMatcher === void 0;
7536
+ let everyArgIsDefined = Boolean(errorLike && errMsgMatcher);
7537
+ let errorLikeFail = false;
7538
+ let errMsgMatcherFail = false;
7506
7539
  if (everyArgIsUndefined || !everyArgIsUndefined && !negate) {
7507
- var errorLikeString = "an error";
7540
+ let errorLikeString = "an error";
7508
7541
  if (errorLike instanceof Error) {
7509
7542
  errorLikeString = "#{exp}";
7510
7543
  } else if (errorLike) {
@@ -7531,7 +7564,7 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
7531
7564
  }
7532
7565
  if (errorLike && caughtErr) {
7533
7566
  if (errorLike instanceof Error) {
7534
- var isCompatibleInstance = check_error_exports.compatibleInstance(
7567
+ let isCompatibleInstance = check_error_exports.compatibleInstance(
7535
7568
  caughtErr,
7536
7569
  errorLike
7537
7570
  );
@@ -7549,7 +7582,7 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
7549
7582
  }
7550
7583
  }
7551
7584
  }
7552
- var isCompatibleConstructor = check_error_exports.compatibleConstructor(
7585
+ let isCompatibleConstructor = check_error_exports.compatibleConstructor(
7553
7586
  caughtErr,
7554
7587
  errorLike
7555
7588
  );
@@ -7568,11 +7601,11 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
7568
7601
  }
7569
7602
  }
7570
7603
  if (caughtErr && errMsgMatcher !== void 0 && errMsgMatcher !== null) {
7571
- var placeholder = "including";
7604
+ let placeholder = "including";
7572
7605
  if (isRegExp2(errMsgMatcher)) {
7573
7606
  placeholder = "matching";
7574
7607
  }
7575
- var isCompatibleMessage = check_error_exports.compatibleMessage(
7608
+ let isCompatibleMessage = check_error_exports.compatibleMessage(
7576
7609
  caughtErr,
7577
7610
  errMsgMatcher
7578
7611
  );
@@ -7606,9 +7639,8 @@ Assertion.addMethod("throw", assertThrows);
7606
7639
  Assertion.addMethod("throws", assertThrows);
7607
7640
  Assertion.addMethod("Throw", assertThrows);
7608
7641
  function respondTo(method, msg) {
7609
- if (msg)
7610
- flag2(this, "message", msg);
7611
- var obj = flag2(this, "object"), itself = flag2(this, "itself"), context = "function" === typeof obj && !itself ? obj.prototype[method] : obj[method];
7642
+ if (msg) flag2(this, "message", msg);
7643
+ let obj = flag2(this, "object"), itself = flag2(this, "itself"), context = "function" === typeof obj && !itself ? obj.prototype[method] : obj[method];
7612
7644
  this.assert(
7613
7645
  "function" === typeof context,
7614
7646
  "expected #{this} to respond to " + inspect22(method),
@@ -7622,10 +7654,9 @@ Assertion.addProperty("itself", function() {
7622
7654
  flag2(this, "itself", true);
7623
7655
  });
7624
7656
  function satisfy(matcher, msg) {
7625
- if (msg)
7626
- flag2(this, "message", msg);
7627
- var obj = flag2(this, "object");
7628
- var result = matcher(obj);
7657
+ if (msg) flag2(this, "message", msg);
7658
+ let obj = flag2(this, "object");
7659
+ let result = matcher(obj);
7629
7660
  this.assert(
7630
7661
  result,
7631
7662
  "expected #{this} to satisfy " + objDisplay2(matcher),
@@ -7638,27 +7669,28 @@ __name(satisfy, "satisfy");
7638
7669
  Assertion.addMethod("satisfy", satisfy);
7639
7670
  Assertion.addMethod("satisfies", satisfy);
7640
7671
  function closeTo(expected, delta, msg) {
7641
- if (msg)
7642
- flag2(this, "message", msg);
7643
- var obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
7672
+ if (msg) flag2(this, "message", msg);
7673
+ let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
7644
7674
  new Assertion(obj, flagMsg, ssfi, true).is.numeric;
7645
7675
  let message = "A `delta` value is required for `closeTo`";
7646
- if (delta == void 0)
7676
+ if (delta == void 0) {
7647
7677
  throw new AssertionError(
7648
7678
  flagMsg ? `${flagMsg}: ${message}` : message,
7649
7679
  void 0,
7650
7680
  ssfi
7651
7681
  );
7682
+ }
7652
7683
  new Assertion(delta, flagMsg, ssfi, true).is.numeric;
7653
7684
  message = "A `expected` value is required for `closeTo`";
7654
- if (expected == void 0)
7685
+ if (expected == void 0) {
7655
7686
  throw new AssertionError(
7656
7687
  flagMsg ? `${flagMsg}: ${message}` : message,
7657
7688
  void 0,
7658
7689
  ssfi
7659
7690
  );
7691
+ }
7660
7692
  new Assertion(expected, flagMsg, ssfi, true).is.numeric;
7661
- const abs = /* @__PURE__ */ __name((x) => x < 0n ? -x : x, "abs");
7693
+ const abs = /* @__PURE__ */ __name((x2) => x2 < 0n ? -x2 : x2, "abs");
7662
7694
  const strip = /* @__PURE__ */ __name((number) => parseFloat(parseFloat(number).toPrecision(12)), "strip");
7663
7695
  this.assert(
7664
7696
  strip(abs(obj - expected)) <= delta,
@@ -7673,40 +7705,33 @@ function isSubsetOf(_subset, _superset, cmp, contains, ordered) {
7673
7705
  let superset = Array.from(_superset);
7674
7706
  let subset = Array.from(_subset);
7675
7707
  if (!contains) {
7676
- if (subset.length !== superset.length)
7677
- return false;
7708
+ if (subset.length !== superset.length) return false;
7678
7709
  superset = superset.slice();
7679
7710
  }
7680
7711
  return subset.every(function(elem, idx) {
7681
- if (ordered)
7682
- return cmp ? cmp(elem, superset[idx]) : elem === superset[idx];
7712
+ if (ordered) return cmp ? cmp(elem, superset[idx]) : elem === superset[idx];
7683
7713
  if (!cmp) {
7684
- var matchIdx = superset.indexOf(elem);
7685
- if (matchIdx === -1)
7686
- return false;
7687
- if (!contains)
7688
- superset.splice(matchIdx, 1);
7714
+ let matchIdx = superset.indexOf(elem);
7715
+ if (matchIdx === -1) return false;
7716
+ if (!contains) superset.splice(matchIdx, 1);
7689
7717
  return true;
7690
7718
  }
7691
- return superset.some(function(elem2, matchIdx2) {
7692
- if (!cmp(elem, elem2))
7693
- return false;
7694
- if (!contains)
7695
- superset.splice(matchIdx2, 1);
7719
+ return superset.some(function(elem2, matchIdx) {
7720
+ if (!cmp(elem, elem2)) return false;
7721
+ if (!contains) superset.splice(matchIdx, 1);
7696
7722
  return true;
7697
7723
  });
7698
7724
  });
7699
7725
  }
7700
7726
  __name(isSubsetOf, "isSubsetOf");
7701
7727
  Assertion.addMethod("members", function(subset, msg) {
7702
- if (msg)
7703
- flag2(this, "message", msg);
7704
- var obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
7728
+ if (msg) flag2(this, "message", msg);
7729
+ let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
7705
7730
  new Assertion(obj, flagMsg, ssfi, true).to.be.iterable;
7706
7731
  new Assertion(subset, flagMsg, ssfi, true).to.be.iterable;
7707
- var contains = flag2(this, "contains");
7708
- var ordered = flag2(this, "ordered");
7709
- var subject, failMsg, failNegateMsg;
7732
+ let contains = flag2(this, "contains");
7733
+ let ordered = flag2(this, "ordered");
7734
+ let subject, failMsg, failNegateMsg;
7710
7735
  if (contains) {
7711
7736
  subject = ordered ? "an ordered superset" : "a superset";
7712
7737
  failMsg = "expected #{this} to be " + subject + " of #{exp}";
@@ -7716,7 +7741,7 @@ Assertion.addMethod("members", function(subset, msg) {
7716
7741
  failMsg = "expected #{this} to have the same " + subject + " as #{exp}";
7717
7742
  failNegateMsg = "expected #{this} to not have the same " + subject + " as #{exp}";
7718
7743
  }
7719
- var cmp = flag2(this, "deep") ? flag2(this, "eql") : void 0;
7744
+ let cmp = flag2(this, "deep") ? flag2(this, "eql") : void 0;
7720
7745
  this.assert(
7721
7746
  isSubsetOf(subset, obj, cmp, contains, ordered),
7722
7747
  failMsg,
@@ -7727,9 +7752,8 @@ Assertion.addMethod("members", function(subset, msg) {
7727
7752
  );
7728
7753
  });
7729
7754
  Assertion.addProperty("iterable", function(msg) {
7730
- if (msg)
7731
- flag2(this, "message", msg);
7732
- var obj = flag2(this, "object");
7755
+ if (msg) flag2(this, "message", msg);
7756
+ let obj = flag2(this, "object");
7733
7757
  this.assert(
7734
7758
  obj != void 0 && obj[Symbol.iterator],
7735
7759
  "expected #{this} to be an iterable",
@@ -7738,9 +7762,8 @@ Assertion.addProperty("iterable", function(msg) {
7738
7762
  );
7739
7763
  });
7740
7764
  function oneOf(list, msg) {
7741
- if (msg)
7742
- flag2(this, "message", msg);
7743
- var expected = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), contains = flag2(this, "contains"), isDeep = flag2(this, "deep"), eql = flag2(this, "eql");
7765
+ if (msg) flag2(this, "message", msg);
7766
+ let expected = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), contains = flag2(this, "contains"), isDeep = flag2(this, "deep"), eql = flag2(this, "eql");
7744
7767
  new Assertion(list, flagMsg, ssfi, true).to.be.an("array");
7745
7768
  if (contains) {
7746
7769
  this.assert(
@@ -7777,11 +7800,10 @@ function oneOf(list, msg) {
7777
7800
  __name(oneOf, "oneOf");
7778
7801
  Assertion.addMethod("oneOf", oneOf);
7779
7802
  function assertChanges(subject, prop, msg) {
7780
- if (msg)
7781
- flag2(this, "message", msg);
7782
- var fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
7803
+ if (msg) flag2(this, "message", msg);
7804
+ let fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
7783
7805
  new Assertion(fn2, flagMsg, ssfi, true).is.a("function");
7784
- var initial;
7806
+ let initial;
7785
7807
  if (!prop) {
7786
7808
  new Assertion(subject, flagMsg, ssfi, true).is.a("function");
7787
7809
  initial = subject();
@@ -7790,8 +7812,8 @@ function assertChanges(subject, prop, msg) {
7790
7812
  initial = subject[prop];
7791
7813
  }
7792
7814
  fn2();
7793
- var final = prop === void 0 || prop === null ? subject() : subject[prop];
7794
- var msgObj = prop === void 0 || prop === null ? initial : "." + prop;
7815
+ let final = prop === void 0 || prop === null ? subject() : subject[prop];
7816
+ let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
7795
7817
  flag2(this, "deltaMsgObj", msgObj);
7796
7818
  flag2(this, "initialDeltaValue", initial);
7797
7819
  flag2(this, "finalDeltaValue", final);
@@ -7807,11 +7829,10 @@ __name(assertChanges, "assertChanges");
7807
7829
  Assertion.addMethod("change", assertChanges);
7808
7830
  Assertion.addMethod("changes", assertChanges);
7809
7831
  function assertIncreases(subject, prop, msg) {
7810
- if (msg)
7811
- flag2(this, "message", msg);
7812
- var fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
7832
+ if (msg) flag2(this, "message", msg);
7833
+ let fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
7813
7834
  new Assertion(fn2, flagMsg, ssfi, true).is.a("function");
7814
- var initial;
7835
+ let initial;
7815
7836
  if (!prop) {
7816
7837
  new Assertion(subject, flagMsg, ssfi, true).is.a("function");
7817
7838
  initial = subject();
@@ -7821,8 +7842,8 @@ function assertIncreases(subject, prop, msg) {
7821
7842
  }
7822
7843
  new Assertion(initial, flagMsg, ssfi, true).is.a("number");
7823
7844
  fn2();
7824
- var final = prop === void 0 || prop === null ? subject() : subject[prop];
7825
- var msgObj = prop === void 0 || prop === null ? initial : "." + prop;
7845
+ let final = prop === void 0 || prop === null ? subject() : subject[prop];
7846
+ let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
7826
7847
  flag2(this, "deltaMsgObj", msgObj);
7827
7848
  flag2(this, "initialDeltaValue", initial);
7828
7849
  flag2(this, "finalDeltaValue", final);
@@ -7838,11 +7859,10 @@ __name(assertIncreases, "assertIncreases");
7838
7859
  Assertion.addMethod("increase", assertIncreases);
7839
7860
  Assertion.addMethod("increases", assertIncreases);
7840
7861
  function assertDecreases(subject, prop, msg) {
7841
- if (msg)
7842
- flag2(this, "message", msg);
7843
- var fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
7862
+ if (msg) flag2(this, "message", msg);
7863
+ let fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
7844
7864
  new Assertion(fn2, flagMsg, ssfi, true).is.a("function");
7845
- var initial;
7865
+ let initial;
7846
7866
  if (!prop) {
7847
7867
  new Assertion(subject, flagMsg, ssfi, true).is.a("function");
7848
7868
  initial = subject();
@@ -7852,8 +7872,8 @@ function assertDecreases(subject, prop, msg) {
7852
7872
  }
7853
7873
  new Assertion(initial, flagMsg, ssfi, true).is.a("number");
7854
7874
  fn2();
7855
- var final = prop === void 0 || prop === null ? subject() : subject[prop];
7856
- var msgObj = prop === void 0 || prop === null ? initial : "." + prop;
7875
+ let final = prop === void 0 || prop === null ? subject() : subject[prop];
7876
+ let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
7857
7877
  flag2(this, "deltaMsgObj", msgObj);
7858
7878
  flag2(this, "initialDeltaValue", initial);
7859
7879
  flag2(this, "finalDeltaValue", final);
@@ -7869,14 +7889,13 @@ __name(assertDecreases, "assertDecreases");
7869
7889
  Assertion.addMethod("decrease", assertDecreases);
7870
7890
  Assertion.addMethod("decreases", assertDecreases);
7871
7891
  function assertDelta(delta, msg) {
7872
- if (msg)
7873
- flag2(this, "message", msg);
7874
- var msgObj = flag2(this, "deltaMsgObj");
7875
- var initial = flag2(this, "initialDeltaValue");
7876
- var final = flag2(this, "finalDeltaValue");
7877
- var behavior = flag2(this, "deltaBehavior");
7878
- var realDelta = flag2(this, "realDelta");
7879
- var expression;
7892
+ if (msg) flag2(this, "message", msg);
7893
+ let msgObj = flag2(this, "deltaMsgObj");
7894
+ let initial = flag2(this, "initialDeltaValue");
7895
+ let final = flag2(this, "finalDeltaValue");
7896
+ let behavior = flag2(this, "deltaBehavior");
7897
+ let realDelta = flag2(this, "realDelta");
7898
+ let expression;
7880
7899
  if (behavior === "change") {
7881
7900
  expression = Math.abs(final - initial) === Math.abs(delta);
7882
7901
  } else {
@@ -7891,8 +7910,8 @@ function assertDelta(delta, msg) {
7891
7910
  __name(assertDelta, "assertDelta");
7892
7911
  Assertion.addMethod("by", assertDelta);
7893
7912
  Assertion.addProperty("extensible", function() {
7894
- var obj = flag2(this, "object");
7895
- var isExtensible = obj === Object(obj) && Object.isExtensible(obj);
7913
+ let obj = flag2(this, "object");
7914
+ let isExtensible = obj === Object(obj) && Object.isExtensible(obj);
7896
7915
  this.assert(
7897
7916
  isExtensible,
7898
7917
  "expected #{this} to be extensible",
@@ -7900,8 +7919,8 @@ Assertion.addProperty("extensible", function() {
7900
7919
  );
7901
7920
  });
7902
7921
  Assertion.addProperty("sealed", function() {
7903
- var obj = flag2(this, "object");
7904
- var isSealed = obj === Object(obj) ? Object.isSealed(obj) : true;
7922
+ let obj = flag2(this, "object");
7923
+ let isSealed = obj === Object(obj) ? Object.isSealed(obj) : true;
7905
7924
  this.assert(
7906
7925
  isSealed,
7907
7926
  "expected #{this} to be sealed",
@@ -7909,8 +7928,8 @@ Assertion.addProperty("sealed", function() {
7909
7928
  );
7910
7929
  });
7911
7930
  Assertion.addProperty("frozen", function() {
7912
- var obj = flag2(this, "object");
7913
- var isFrozen = obj === Object(obj) ? Object.isFrozen(obj) : true;
7931
+ let obj = flag2(this, "object");
7932
+ let isFrozen = obj === Object(obj) ? Object.isFrozen(obj) : true;
7914
7933
  this.assert(
7915
7934
  isFrozen,
7916
7935
  "expected #{this} to be frozen",
@@ -7918,7 +7937,7 @@ Assertion.addProperty("frozen", function() {
7918
7937
  );
7919
7938
  });
7920
7939
  Assertion.addProperty("finite", function(_msg) {
7921
- var obj = flag2(this, "object");
7940
+ let obj = flag2(this, "object");
7922
7941
  this.assert(
7923
7942
  typeof obj === "number" && isFinite(obj),
7924
7943
  "expected #{this} to be a finite number",
@@ -7956,8 +7975,8 @@ function compareSubset(expected, actual) {
7956
7975
  }
7957
7976
  }
7958
7977
  return Object.keys(expected).every(function(key) {
7959
- var expectedValue = expected[key];
7960
- var actualValue = actual[key];
7978
+ let expectedValue = expected[key];
7979
+ let actualValue = actual[key];
7961
7980
  if (typeof expectedValue === "object" && expectedValue !== null && actualValue !== null) {
7962
7981
  return compareSubset(expectedValue, actualValue);
7963
7982
  }
@@ -8027,7 +8046,7 @@ function loadShould() {
8027
8046
  get: shouldGetter,
8028
8047
  configurable: true
8029
8048
  });
8030
- var should2 = {};
8049
+ let should2 = {};
8031
8050
  should2.fail = function(actual, expected, message, operator) {
8032
8051
  if (arguments.length < 2) {
8033
8052
  message = actual;
@@ -8070,12 +8089,12 @@ function loadShould() {
8070
8089
  __name(loadShould, "loadShould");
8071
8090
  var should = loadShould;
8072
8091
  var Should = loadShould;
8073
- function assert2(express, errmsg) {
8074
- var test22 = new Assertion(null, null, assert2, true);
8092
+ function assert(express, errmsg) {
8093
+ let test22 = new Assertion(null, null, assert, true);
8075
8094
  test22.assert(express, errmsg, "[ negation message unavailable ]");
8076
8095
  }
8077
- __name(assert2, "assert");
8078
- assert2.fail = function(actual, expected, message, operator) {
8096
+ __name(assert, "assert");
8097
+ assert.fail = function(actual, expected, message, operator) {
8079
8098
  if (arguments.length < 2) {
8080
8099
  message = actual;
8081
8100
  actual = void 0;
@@ -8088,17 +8107,17 @@ assert2.fail = function(actual, expected, message, operator) {
8088
8107
  expected,
8089
8108
  operator
8090
8109
  },
8091
- assert2.fail
8110
+ assert.fail
8092
8111
  );
8093
8112
  };
8094
- assert2.isOk = function(val, msg) {
8095
- new Assertion(val, msg, assert2.isOk, true).is.ok;
8113
+ assert.isOk = function(val, msg) {
8114
+ new Assertion(val, msg, assert.isOk, true).is.ok;
8096
8115
  };
8097
- assert2.isNotOk = function(val, msg) {
8098
- new Assertion(val, msg, assert2.isNotOk, true).is.not.ok;
8116
+ assert.isNotOk = function(val, msg) {
8117
+ new Assertion(val, msg, assert.isNotOk, true).is.not.ok;
8099
8118
  };
8100
- assert2.equal = function(act, exp, msg) {
8101
- var test22 = new Assertion(act, msg, assert2.equal, true);
8119
+ assert.equal = function(act, exp, msg) {
8120
+ let test22 = new Assertion(act, msg, assert.equal, true);
8102
8121
  test22.assert(
8103
8122
  exp == flag(test22, "object"),
8104
8123
  "expected #{this} to equal #{exp}",
@@ -8108,8 +8127,8 @@ assert2.equal = function(act, exp, msg) {
8108
8127
  true
8109
8128
  );
8110
8129
  };
8111
- assert2.notEqual = function(act, exp, msg) {
8112
- var test22 = new Assertion(act, msg, assert2.notEqual, true);
8130
+ assert.notEqual = function(act, exp, msg) {
8131
+ let test22 = new Assertion(act, msg, assert.notEqual, true);
8113
8132
  test22.assert(
8114
8133
  exp != flag(test22, "object"),
8115
8134
  "expected #{this} to not equal #{exp}",
@@ -8119,371 +8138,371 @@ assert2.notEqual = function(act, exp, msg) {
8119
8138
  true
8120
8139
  );
8121
8140
  };
8122
- assert2.strictEqual = function(act, exp, msg) {
8123
- new Assertion(act, msg, assert2.strictEqual, true).to.equal(exp);
8141
+ assert.strictEqual = function(act, exp, msg) {
8142
+ new Assertion(act, msg, assert.strictEqual, true).to.equal(exp);
8124
8143
  };
8125
- assert2.notStrictEqual = function(act, exp, msg) {
8126
- new Assertion(act, msg, assert2.notStrictEqual, true).to.not.equal(exp);
8144
+ assert.notStrictEqual = function(act, exp, msg) {
8145
+ new Assertion(act, msg, assert.notStrictEqual, true).to.not.equal(exp);
8127
8146
  };
8128
- assert2.deepEqual = assert2.deepStrictEqual = function(act, exp, msg) {
8129
- new Assertion(act, msg, assert2.deepEqual, true).to.eql(exp);
8147
+ assert.deepEqual = assert.deepStrictEqual = function(act, exp, msg) {
8148
+ new Assertion(act, msg, assert.deepEqual, true).to.eql(exp);
8130
8149
  };
8131
- assert2.notDeepEqual = function(act, exp, msg) {
8132
- new Assertion(act, msg, assert2.notDeepEqual, true).to.not.eql(exp);
8150
+ assert.notDeepEqual = function(act, exp, msg) {
8151
+ new Assertion(act, msg, assert.notDeepEqual, true).to.not.eql(exp);
8133
8152
  };
8134
- assert2.isAbove = function(val, abv, msg) {
8135
- new Assertion(val, msg, assert2.isAbove, true).to.be.above(abv);
8153
+ assert.isAbove = function(val, abv, msg) {
8154
+ new Assertion(val, msg, assert.isAbove, true).to.be.above(abv);
8136
8155
  };
8137
- assert2.isAtLeast = function(val, atlst, msg) {
8138
- new Assertion(val, msg, assert2.isAtLeast, true).to.be.least(atlst);
8156
+ assert.isAtLeast = function(val, atlst, msg) {
8157
+ new Assertion(val, msg, assert.isAtLeast, true).to.be.least(atlst);
8139
8158
  };
8140
- assert2.isBelow = function(val, blw, msg) {
8141
- new Assertion(val, msg, assert2.isBelow, true).to.be.below(blw);
8159
+ assert.isBelow = function(val, blw, msg) {
8160
+ new Assertion(val, msg, assert.isBelow, true).to.be.below(blw);
8142
8161
  };
8143
- assert2.isAtMost = function(val, atmst, msg) {
8144
- new Assertion(val, msg, assert2.isAtMost, true).to.be.most(atmst);
8162
+ assert.isAtMost = function(val, atmst, msg) {
8163
+ new Assertion(val, msg, assert.isAtMost, true).to.be.most(atmst);
8145
8164
  };
8146
- assert2.isTrue = function(val, msg) {
8147
- new Assertion(val, msg, assert2.isTrue, true).is["true"];
8165
+ assert.isTrue = function(val, msg) {
8166
+ new Assertion(val, msg, assert.isTrue, true).is["true"];
8148
8167
  };
8149
- assert2.isNotTrue = function(val, msg) {
8150
- new Assertion(val, msg, assert2.isNotTrue, true).to.not.equal(true);
8168
+ assert.isNotTrue = function(val, msg) {
8169
+ new Assertion(val, msg, assert.isNotTrue, true).to.not.equal(true);
8151
8170
  };
8152
- assert2.isFalse = function(val, msg) {
8153
- new Assertion(val, msg, assert2.isFalse, true).is["false"];
8171
+ assert.isFalse = function(val, msg) {
8172
+ new Assertion(val, msg, assert.isFalse, true).is["false"];
8154
8173
  };
8155
- assert2.isNotFalse = function(val, msg) {
8156
- new Assertion(val, msg, assert2.isNotFalse, true).to.not.equal(false);
8174
+ assert.isNotFalse = function(val, msg) {
8175
+ new Assertion(val, msg, assert.isNotFalse, true).to.not.equal(false);
8157
8176
  };
8158
- assert2.isNull = function(val, msg) {
8159
- new Assertion(val, msg, assert2.isNull, true).to.equal(null);
8177
+ assert.isNull = function(val, msg) {
8178
+ new Assertion(val, msg, assert.isNull, true).to.equal(null);
8160
8179
  };
8161
- assert2.isNotNull = function(val, msg) {
8162
- new Assertion(val, msg, assert2.isNotNull, true).to.not.equal(null);
8180
+ assert.isNotNull = function(val, msg) {
8181
+ new Assertion(val, msg, assert.isNotNull, true).to.not.equal(null);
8163
8182
  };
8164
- assert2.isNaN = function(val, msg) {
8165
- new Assertion(val, msg, assert2.isNaN, true).to.be.NaN;
8183
+ assert.isNaN = function(val, msg) {
8184
+ new Assertion(val, msg, assert.isNaN, true).to.be.NaN;
8166
8185
  };
8167
- assert2.isNotNaN = function(value, message) {
8168
- new Assertion(value, message, assert2.isNotNaN, true).not.to.be.NaN;
8186
+ assert.isNotNaN = function(value, message) {
8187
+ new Assertion(value, message, assert.isNotNaN, true).not.to.be.NaN;
8169
8188
  };
8170
- assert2.exists = function(val, msg) {
8171
- new Assertion(val, msg, assert2.exists, true).to.exist;
8189
+ assert.exists = function(val, msg) {
8190
+ new Assertion(val, msg, assert.exists, true).to.exist;
8172
8191
  };
8173
- assert2.notExists = function(val, msg) {
8174
- new Assertion(val, msg, assert2.notExists, true).to.not.exist;
8192
+ assert.notExists = function(val, msg) {
8193
+ new Assertion(val, msg, assert.notExists, true).to.not.exist;
8175
8194
  };
8176
- assert2.isUndefined = function(val, msg) {
8177
- new Assertion(val, msg, assert2.isUndefined, true).to.equal(void 0);
8195
+ assert.isUndefined = function(val, msg) {
8196
+ new Assertion(val, msg, assert.isUndefined, true).to.equal(void 0);
8178
8197
  };
8179
- assert2.isDefined = function(val, msg) {
8180
- new Assertion(val, msg, assert2.isDefined, true).to.not.equal(void 0);
8198
+ assert.isDefined = function(val, msg) {
8199
+ new Assertion(val, msg, assert.isDefined, true).to.not.equal(void 0);
8181
8200
  };
8182
- assert2.isCallable = function(value, message) {
8183
- new Assertion(value, message, assert2.isCallable, true).is.callable;
8201
+ assert.isCallable = function(value, message) {
8202
+ new Assertion(value, message, assert.isCallable, true).is.callable;
8184
8203
  };
8185
- assert2.isNotCallable = function(value, message) {
8186
- new Assertion(value, message, assert2.isNotCallable, true).is.not.callable;
8204
+ assert.isNotCallable = function(value, message) {
8205
+ new Assertion(value, message, assert.isNotCallable, true).is.not.callable;
8187
8206
  };
8188
- assert2.isObject = function(val, msg) {
8189
- new Assertion(val, msg, assert2.isObject, true).to.be.a("object");
8207
+ assert.isObject = function(val, msg) {
8208
+ new Assertion(val, msg, assert.isObject, true).to.be.a("object");
8190
8209
  };
8191
- assert2.isNotObject = function(val, msg) {
8192
- new Assertion(val, msg, assert2.isNotObject, true).to.not.be.a("object");
8210
+ assert.isNotObject = function(val, msg) {
8211
+ new Assertion(val, msg, assert.isNotObject, true).to.not.be.a("object");
8193
8212
  };
8194
- assert2.isArray = function(val, msg) {
8195
- new Assertion(val, msg, assert2.isArray, true).to.be.an("array");
8213
+ assert.isArray = function(val, msg) {
8214
+ new Assertion(val, msg, assert.isArray, true).to.be.an("array");
8196
8215
  };
8197
- assert2.isNotArray = function(val, msg) {
8198
- new Assertion(val, msg, assert2.isNotArray, true).to.not.be.an("array");
8216
+ assert.isNotArray = function(val, msg) {
8217
+ new Assertion(val, msg, assert.isNotArray, true).to.not.be.an("array");
8199
8218
  };
8200
- assert2.isString = function(val, msg) {
8201
- new Assertion(val, msg, assert2.isString, true).to.be.a("string");
8219
+ assert.isString = function(val, msg) {
8220
+ new Assertion(val, msg, assert.isString, true).to.be.a("string");
8202
8221
  };
8203
- assert2.isNotString = function(val, msg) {
8204
- new Assertion(val, msg, assert2.isNotString, true).to.not.be.a("string");
8222
+ assert.isNotString = function(val, msg) {
8223
+ new Assertion(val, msg, assert.isNotString, true).to.not.be.a("string");
8205
8224
  };
8206
- assert2.isNumber = function(val, msg) {
8207
- new Assertion(val, msg, assert2.isNumber, true).to.be.a("number");
8225
+ assert.isNumber = function(val, msg) {
8226
+ new Assertion(val, msg, assert.isNumber, true).to.be.a("number");
8208
8227
  };
8209
- assert2.isNotNumber = function(val, msg) {
8210
- new Assertion(val, msg, assert2.isNotNumber, true).to.not.be.a("number");
8228
+ assert.isNotNumber = function(val, msg) {
8229
+ new Assertion(val, msg, assert.isNotNumber, true).to.not.be.a("number");
8211
8230
  };
8212
- assert2.isNumeric = function(val, msg) {
8213
- new Assertion(val, msg, assert2.isNumeric, true).is.numeric;
8231
+ assert.isNumeric = function(val, msg) {
8232
+ new Assertion(val, msg, assert.isNumeric, true).is.numeric;
8214
8233
  };
8215
- assert2.isNotNumeric = function(val, msg) {
8216
- new Assertion(val, msg, assert2.isNotNumeric, true).is.not.numeric;
8234
+ assert.isNotNumeric = function(val, msg) {
8235
+ new Assertion(val, msg, assert.isNotNumeric, true).is.not.numeric;
8217
8236
  };
8218
- assert2.isFinite = function(val, msg) {
8219
- new Assertion(val, msg, assert2.isFinite, true).to.be.finite;
8237
+ assert.isFinite = function(val, msg) {
8238
+ new Assertion(val, msg, assert.isFinite, true).to.be.finite;
8220
8239
  };
8221
- assert2.isBoolean = function(val, msg) {
8222
- new Assertion(val, msg, assert2.isBoolean, true).to.be.a("boolean");
8240
+ assert.isBoolean = function(val, msg) {
8241
+ new Assertion(val, msg, assert.isBoolean, true).to.be.a("boolean");
8223
8242
  };
8224
- assert2.isNotBoolean = function(val, msg) {
8225
- new Assertion(val, msg, assert2.isNotBoolean, true).to.not.be.a("boolean");
8243
+ assert.isNotBoolean = function(val, msg) {
8244
+ new Assertion(val, msg, assert.isNotBoolean, true).to.not.be.a("boolean");
8226
8245
  };
8227
- assert2.typeOf = function(val, type3, msg) {
8228
- new Assertion(val, msg, assert2.typeOf, true).to.be.a(type3);
8246
+ assert.typeOf = function(val, type3, msg) {
8247
+ new Assertion(val, msg, assert.typeOf, true).to.be.a(type3);
8229
8248
  };
8230
- assert2.notTypeOf = function(value, type3, message) {
8231
- new Assertion(value, message, assert2.notTypeOf, true).to.not.be.a(type3);
8249
+ assert.notTypeOf = function(value, type3, message) {
8250
+ new Assertion(value, message, assert.notTypeOf, true).to.not.be.a(type3);
8232
8251
  };
8233
- assert2.instanceOf = function(val, type3, msg) {
8234
- new Assertion(val, msg, assert2.instanceOf, true).to.be.instanceOf(type3);
8252
+ assert.instanceOf = function(val, type3, msg) {
8253
+ new Assertion(val, msg, assert.instanceOf, true).to.be.instanceOf(type3);
8235
8254
  };
8236
- assert2.notInstanceOf = function(val, type3, msg) {
8237
- new Assertion(val, msg, assert2.notInstanceOf, true).to.not.be.instanceOf(
8255
+ assert.notInstanceOf = function(val, type3, msg) {
8256
+ new Assertion(val, msg, assert.notInstanceOf, true).to.not.be.instanceOf(
8238
8257
  type3
8239
8258
  );
8240
8259
  };
8241
- assert2.include = function(exp, inc, msg) {
8242
- new Assertion(exp, msg, assert2.include, true).include(inc);
8260
+ assert.include = function(exp, inc, msg) {
8261
+ new Assertion(exp, msg, assert.include, true).include(inc);
8243
8262
  };
8244
- assert2.notInclude = function(exp, inc, msg) {
8245
- new Assertion(exp, msg, assert2.notInclude, true).not.include(inc);
8263
+ assert.notInclude = function(exp, inc, msg) {
8264
+ new Assertion(exp, msg, assert.notInclude, true).not.include(inc);
8246
8265
  };
8247
- assert2.deepInclude = function(exp, inc, msg) {
8248
- new Assertion(exp, msg, assert2.deepInclude, true).deep.include(inc);
8266
+ assert.deepInclude = function(exp, inc, msg) {
8267
+ new Assertion(exp, msg, assert.deepInclude, true).deep.include(inc);
8249
8268
  };
8250
- assert2.notDeepInclude = function(exp, inc, msg) {
8251
- new Assertion(exp, msg, assert2.notDeepInclude, true).not.deep.include(inc);
8269
+ assert.notDeepInclude = function(exp, inc, msg) {
8270
+ new Assertion(exp, msg, assert.notDeepInclude, true).not.deep.include(inc);
8252
8271
  };
8253
- assert2.nestedInclude = function(exp, inc, msg) {
8254
- new Assertion(exp, msg, assert2.nestedInclude, true).nested.include(inc);
8272
+ assert.nestedInclude = function(exp, inc, msg) {
8273
+ new Assertion(exp, msg, assert.nestedInclude, true).nested.include(inc);
8255
8274
  };
8256
- assert2.notNestedInclude = function(exp, inc, msg) {
8257
- new Assertion(exp, msg, assert2.notNestedInclude, true).not.nested.include(
8275
+ assert.notNestedInclude = function(exp, inc, msg) {
8276
+ new Assertion(exp, msg, assert.notNestedInclude, true).not.nested.include(
8258
8277
  inc
8259
8278
  );
8260
8279
  };
8261
- assert2.deepNestedInclude = function(exp, inc, msg) {
8262
- new Assertion(exp, msg, assert2.deepNestedInclude, true).deep.nested.include(
8280
+ assert.deepNestedInclude = function(exp, inc, msg) {
8281
+ new Assertion(exp, msg, assert.deepNestedInclude, true).deep.nested.include(
8263
8282
  inc
8264
8283
  );
8265
8284
  };
8266
- assert2.notDeepNestedInclude = function(exp, inc, msg) {
8285
+ assert.notDeepNestedInclude = function(exp, inc, msg) {
8267
8286
  new Assertion(
8268
8287
  exp,
8269
8288
  msg,
8270
- assert2.notDeepNestedInclude,
8289
+ assert.notDeepNestedInclude,
8271
8290
  true
8272
8291
  ).not.deep.nested.include(inc);
8273
8292
  };
8274
- assert2.ownInclude = function(exp, inc, msg) {
8275
- new Assertion(exp, msg, assert2.ownInclude, true).own.include(inc);
8293
+ assert.ownInclude = function(exp, inc, msg) {
8294
+ new Assertion(exp, msg, assert.ownInclude, true).own.include(inc);
8276
8295
  };
8277
- assert2.notOwnInclude = function(exp, inc, msg) {
8278
- new Assertion(exp, msg, assert2.notOwnInclude, true).not.own.include(inc);
8296
+ assert.notOwnInclude = function(exp, inc, msg) {
8297
+ new Assertion(exp, msg, assert.notOwnInclude, true).not.own.include(inc);
8279
8298
  };
8280
- assert2.deepOwnInclude = function(exp, inc, msg) {
8281
- new Assertion(exp, msg, assert2.deepOwnInclude, true).deep.own.include(inc);
8299
+ assert.deepOwnInclude = function(exp, inc, msg) {
8300
+ new Assertion(exp, msg, assert.deepOwnInclude, true).deep.own.include(inc);
8282
8301
  };
8283
- assert2.notDeepOwnInclude = function(exp, inc, msg) {
8284
- new Assertion(exp, msg, assert2.notDeepOwnInclude, true).not.deep.own.include(
8302
+ assert.notDeepOwnInclude = function(exp, inc, msg) {
8303
+ new Assertion(exp, msg, assert.notDeepOwnInclude, true).not.deep.own.include(
8285
8304
  inc
8286
8305
  );
8287
8306
  };
8288
- assert2.match = function(exp, re, msg) {
8289
- new Assertion(exp, msg, assert2.match, true).to.match(re);
8307
+ assert.match = function(exp, re, msg) {
8308
+ new Assertion(exp, msg, assert.match, true).to.match(re);
8290
8309
  };
8291
- assert2.notMatch = function(exp, re, msg) {
8292
- new Assertion(exp, msg, assert2.notMatch, true).to.not.match(re);
8310
+ assert.notMatch = function(exp, re, msg) {
8311
+ new Assertion(exp, msg, assert.notMatch, true).to.not.match(re);
8293
8312
  };
8294
- assert2.property = function(obj, prop, msg) {
8295
- new Assertion(obj, msg, assert2.property, true).to.have.property(prop);
8313
+ assert.property = function(obj, prop, msg) {
8314
+ new Assertion(obj, msg, assert.property, true).to.have.property(prop);
8296
8315
  };
8297
- assert2.notProperty = function(obj, prop, msg) {
8298
- new Assertion(obj, msg, assert2.notProperty, true).to.not.have.property(prop);
8316
+ assert.notProperty = function(obj, prop, msg) {
8317
+ new Assertion(obj, msg, assert.notProperty, true).to.not.have.property(prop);
8299
8318
  };
8300
- assert2.propertyVal = function(obj, prop, val, msg) {
8301
- new Assertion(obj, msg, assert2.propertyVal, true).to.have.property(prop, val);
8319
+ assert.propertyVal = function(obj, prop, val, msg) {
8320
+ new Assertion(obj, msg, assert.propertyVal, true).to.have.property(prop, val);
8302
8321
  };
8303
- assert2.notPropertyVal = function(obj, prop, val, msg) {
8304
- new Assertion(obj, msg, assert2.notPropertyVal, true).to.not.have.property(
8322
+ assert.notPropertyVal = function(obj, prop, val, msg) {
8323
+ new Assertion(obj, msg, assert.notPropertyVal, true).to.not.have.property(
8305
8324
  prop,
8306
8325
  val
8307
8326
  );
8308
8327
  };
8309
- assert2.deepPropertyVal = function(obj, prop, val, msg) {
8310
- new Assertion(obj, msg, assert2.deepPropertyVal, true).to.have.deep.property(
8328
+ assert.deepPropertyVal = function(obj, prop, val, msg) {
8329
+ new Assertion(obj, msg, assert.deepPropertyVal, true).to.have.deep.property(
8311
8330
  prop,
8312
8331
  val
8313
8332
  );
8314
8333
  };
8315
- assert2.notDeepPropertyVal = function(obj, prop, val, msg) {
8334
+ assert.notDeepPropertyVal = function(obj, prop, val, msg) {
8316
8335
  new Assertion(
8317
8336
  obj,
8318
8337
  msg,
8319
- assert2.notDeepPropertyVal,
8338
+ assert.notDeepPropertyVal,
8320
8339
  true
8321
8340
  ).to.not.have.deep.property(prop, val);
8322
8341
  };
8323
- assert2.ownProperty = function(obj, prop, msg) {
8324
- new Assertion(obj, msg, assert2.ownProperty, true).to.have.own.property(prop);
8342
+ assert.ownProperty = function(obj, prop, msg) {
8343
+ new Assertion(obj, msg, assert.ownProperty, true).to.have.own.property(prop);
8325
8344
  };
8326
- assert2.notOwnProperty = function(obj, prop, msg) {
8327
- new Assertion(obj, msg, assert2.notOwnProperty, true).to.not.have.own.property(
8345
+ assert.notOwnProperty = function(obj, prop, msg) {
8346
+ new Assertion(obj, msg, assert.notOwnProperty, true).to.not.have.own.property(
8328
8347
  prop
8329
8348
  );
8330
8349
  };
8331
- assert2.ownPropertyVal = function(obj, prop, value, msg) {
8332
- new Assertion(obj, msg, assert2.ownPropertyVal, true).to.have.own.property(
8350
+ assert.ownPropertyVal = function(obj, prop, value, msg) {
8351
+ new Assertion(obj, msg, assert.ownPropertyVal, true).to.have.own.property(
8333
8352
  prop,
8334
8353
  value
8335
8354
  );
8336
8355
  };
8337
- assert2.notOwnPropertyVal = function(obj, prop, value, msg) {
8356
+ assert.notOwnPropertyVal = function(obj, prop, value, msg) {
8338
8357
  new Assertion(
8339
8358
  obj,
8340
8359
  msg,
8341
- assert2.notOwnPropertyVal,
8360
+ assert.notOwnPropertyVal,
8342
8361
  true
8343
8362
  ).to.not.have.own.property(prop, value);
8344
8363
  };
8345
- assert2.deepOwnPropertyVal = function(obj, prop, value, msg) {
8364
+ assert.deepOwnPropertyVal = function(obj, prop, value, msg) {
8346
8365
  new Assertion(
8347
8366
  obj,
8348
8367
  msg,
8349
- assert2.deepOwnPropertyVal,
8368
+ assert.deepOwnPropertyVal,
8350
8369
  true
8351
8370
  ).to.have.deep.own.property(prop, value);
8352
8371
  };
8353
- assert2.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
8372
+ assert.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
8354
8373
  new Assertion(
8355
8374
  obj,
8356
8375
  msg,
8357
- assert2.notDeepOwnPropertyVal,
8376
+ assert.notDeepOwnPropertyVal,
8358
8377
  true
8359
8378
  ).to.not.have.deep.own.property(prop, value);
8360
8379
  };
8361
- assert2.nestedProperty = function(obj, prop, msg) {
8362
- new Assertion(obj, msg, assert2.nestedProperty, true).to.have.nested.property(
8380
+ assert.nestedProperty = function(obj, prop, msg) {
8381
+ new Assertion(obj, msg, assert.nestedProperty, true).to.have.nested.property(
8363
8382
  prop
8364
8383
  );
8365
8384
  };
8366
- assert2.notNestedProperty = function(obj, prop, msg) {
8385
+ assert.notNestedProperty = function(obj, prop, msg) {
8367
8386
  new Assertion(
8368
8387
  obj,
8369
8388
  msg,
8370
- assert2.notNestedProperty,
8389
+ assert.notNestedProperty,
8371
8390
  true
8372
8391
  ).to.not.have.nested.property(prop);
8373
8392
  };
8374
- assert2.nestedPropertyVal = function(obj, prop, val, msg) {
8393
+ assert.nestedPropertyVal = function(obj, prop, val, msg) {
8375
8394
  new Assertion(
8376
8395
  obj,
8377
8396
  msg,
8378
- assert2.nestedPropertyVal,
8397
+ assert.nestedPropertyVal,
8379
8398
  true
8380
8399
  ).to.have.nested.property(prop, val);
8381
8400
  };
8382
- assert2.notNestedPropertyVal = function(obj, prop, val, msg) {
8401
+ assert.notNestedPropertyVal = function(obj, prop, val, msg) {
8383
8402
  new Assertion(
8384
8403
  obj,
8385
8404
  msg,
8386
- assert2.notNestedPropertyVal,
8405
+ assert.notNestedPropertyVal,
8387
8406
  true
8388
8407
  ).to.not.have.nested.property(prop, val);
8389
8408
  };
8390
- assert2.deepNestedPropertyVal = function(obj, prop, val, msg) {
8409
+ assert.deepNestedPropertyVal = function(obj, prop, val, msg) {
8391
8410
  new Assertion(
8392
8411
  obj,
8393
8412
  msg,
8394
- assert2.deepNestedPropertyVal,
8413
+ assert.deepNestedPropertyVal,
8395
8414
  true
8396
8415
  ).to.have.deep.nested.property(prop, val);
8397
8416
  };
8398
- assert2.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
8417
+ assert.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
8399
8418
  new Assertion(
8400
8419
  obj,
8401
8420
  msg,
8402
- assert2.notDeepNestedPropertyVal,
8421
+ assert.notDeepNestedPropertyVal,
8403
8422
  true
8404
8423
  ).to.not.have.deep.nested.property(prop, val);
8405
8424
  };
8406
- assert2.lengthOf = function(exp, len, msg) {
8407
- new Assertion(exp, msg, assert2.lengthOf, true).to.have.lengthOf(len);
8425
+ assert.lengthOf = function(exp, len, msg) {
8426
+ new Assertion(exp, msg, assert.lengthOf, true).to.have.lengthOf(len);
8408
8427
  };
8409
- assert2.hasAnyKeys = function(obj, keys2, msg) {
8410
- new Assertion(obj, msg, assert2.hasAnyKeys, true).to.have.any.keys(keys2);
8428
+ assert.hasAnyKeys = function(obj, keys2, msg) {
8429
+ new Assertion(obj, msg, assert.hasAnyKeys, true).to.have.any.keys(keys2);
8411
8430
  };
8412
- assert2.hasAllKeys = function(obj, keys2, msg) {
8413
- new Assertion(obj, msg, assert2.hasAllKeys, true).to.have.all.keys(keys2);
8431
+ assert.hasAllKeys = function(obj, keys2, msg) {
8432
+ new Assertion(obj, msg, assert.hasAllKeys, true).to.have.all.keys(keys2);
8414
8433
  };
8415
- assert2.containsAllKeys = function(obj, keys2, msg) {
8416
- new Assertion(obj, msg, assert2.containsAllKeys, true).to.contain.all.keys(
8434
+ assert.containsAllKeys = function(obj, keys2, msg) {
8435
+ new Assertion(obj, msg, assert.containsAllKeys, true).to.contain.all.keys(
8417
8436
  keys2
8418
8437
  );
8419
8438
  };
8420
- assert2.doesNotHaveAnyKeys = function(obj, keys2, msg) {
8421
- new Assertion(obj, msg, assert2.doesNotHaveAnyKeys, true).to.not.have.any.keys(
8439
+ assert.doesNotHaveAnyKeys = function(obj, keys2, msg) {
8440
+ new Assertion(obj, msg, assert.doesNotHaveAnyKeys, true).to.not.have.any.keys(
8422
8441
  keys2
8423
8442
  );
8424
8443
  };
8425
- assert2.doesNotHaveAllKeys = function(obj, keys2, msg) {
8426
- new Assertion(obj, msg, assert2.doesNotHaveAllKeys, true).to.not.have.all.keys(
8444
+ assert.doesNotHaveAllKeys = function(obj, keys2, msg) {
8445
+ new Assertion(obj, msg, assert.doesNotHaveAllKeys, true).to.not.have.all.keys(
8427
8446
  keys2
8428
8447
  );
8429
8448
  };
8430
- assert2.hasAnyDeepKeys = function(obj, keys2, msg) {
8431
- new Assertion(obj, msg, assert2.hasAnyDeepKeys, true).to.have.any.deep.keys(
8449
+ assert.hasAnyDeepKeys = function(obj, keys2, msg) {
8450
+ new Assertion(obj, msg, assert.hasAnyDeepKeys, true).to.have.any.deep.keys(
8432
8451
  keys2
8433
8452
  );
8434
8453
  };
8435
- assert2.hasAllDeepKeys = function(obj, keys2, msg) {
8436
- new Assertion(obj, msg, assert2.hasAllDeepKeys, true).to.have.all.deep.keys(
8454
+ assert.hasAllDeepKeys = function(obj, keys2, msg) {
8455
+ new Assertion(obj, msg, assert.hasAllDeepKeys, true).to.have.all.deep.keys(
8437
8456
  keys2
8438
8457
  );
8439
8458
  };
8440
- assert2.containsAllDeepKeys = function(obj, keys2, msg) {
8459
+ assert.containsAllDeepKeys = function(obj, keys2, msg) {
8441
8460
  new Assertion(
8442
8461
  obj,
8443
8462
  msg,
8444
- assert2.containsAllDeepKeys,
8463
+ assert.containsAllDeepKeys,
8445
8464
  true
8446
8465
  ).to.contain.all.deep.keys(keys2);
8447
8466
  };
8448
- assert2.doesNotHaveAnyDeepKeys = function(obj, keys2, msg) {
8467
+ assert.doesNotHaveAnyDeepKeys = function(obj, keys2, msg) {
8449
8468
  new Assertion(
8450
8469
  obj,
8451
8470
  msg,
8452
- assert2.doesNotHaveAnyDeepKeys,
8471
+ assert.doesNotHaveAnyDeepKeys,
8453
8472
  true
8454
8473
  ).to.not.have.any.deep.keys(keys2);
8455
8474
  };
8456
- assert2.doesNotHaveAllDeepKeys = function(obj, keys2, msg) {
8475
+ assert.doesNotHaveAllDeepKeys = function(obj, keys2, msg) {
8457
8476
  new Assertion(
8458
8477
  obj,
8459
8478
  msg,
8460
- assert2.doesNotHaveAllDeepKeys,
8479
+ assert.doesNotHaveAllDeepKeys,
8461
8480
  true
8462
8481
  ).to.not.have.all.deep.keys(keys2);
8463
8482
  };
8464
- assert2.throws = function(fn2, errorLike, errMsgMatcher, msg) {
8483
+ assert.throws = function(fn2, errorLike, errMsgMatcher, msg) {
8465
8484
  if ("string" === typeof errorLike || errorLike instanceof RegExp) {
8466
8485
  errMsgMatcher = errorLike;
8467
8486
  errorLike = null;
8468
8487
  }
8469
- var assertErr = new Assertion(fn2, msg, assert2.throws, true).to.throw(
8488
+ let assertErr = new Assertion(fn2, msg, assert.throws, true).to.throw(
8470
8489
  errorLike,
8471
8490
  errMsgMatcher
8472
8491
  );
8473
8492
  return flag(assertErr, "object");
8474
8493
  };
8475
- assert2.doesNotThrow = function(fn2, errorLike, errMsgMatcher, message) {
8494
+ assert.doesNotThrow = function(fn2, errorLike, errMsgMatcher, message) {
8476
8495
  if ("string" === typeof errorLike || errorLike instanceof RegExp) {
8477
8496
  errMsgMatcher = errorLike;
8478
8497
  errorLike = null;
8479
8498
  }
8480
- new Assertion(fn2, message, assert2.doesNotThrow, true).to.not.throw(
8499
+ new Assertion(fn2, message, assert.doesNotThrow, true).to.not.throw(
8481
8500
  errorLike,
8482
8501
  errMsgMatcher
8483
8502
  );
8484
8503
  };
8485
- assert2.operator = function(val, operator, val2, msg) {
8486
- var ok;
8504
+ assert.operator = function(val, operator, val2, msg) {
8505
+ let ok;
8487
8506
  switch (operator) {
8488
8507
  case "==":
8489
8508
  ok = val == val2;
@@ -8514,315 +8533,315 @@ assert2.operator = function(val, operator, val2, msg) {
8514
8533
  throw new AssertionError(
8515
8534
  msg + 'Invalid operator "' + operator + '"',
8516
8535
  void 0,
8517
- assert2.operator
8536
+ assert.operator
8518
8537
  );
8519
8538
  }
8520
- var test22 = new Assertion(ok, msg, assert2.operator, true);
8539
+ let test22 = new Assertion(ok, msg, assert.operator, true);
8521
8540
  test22.assert(
8522
8541
  true === flag(test22, "object"),
8523
8542
  "expected " + inspect22(val) + " to be " + operator + " " + inspect22(val2),
8524
8543
  "expected " + inspect22(val) + " to not be " + operator + " " + inspect22(val2)
8525
8544
  );
8526
8545
  };
8527
- assert2.closeTo = function(act, exp, delta, msg) {
8528
- new Assertion(act, msg, assert2.closeTo, true).to.be.closeTo(exp, delta);
8546
+ assert.closeTo = function(act, exp, delta, msg) {
8547
+ new Assertion(act, msg, assert.closeTo, true).to.be.closeTo(exp, delta);
8529
8548
  };
8530
- assert2.approximately = function(act, exp, delta, msg) {
8531
- new Assertion(act, msg, assert2.approximately, true).to.be.approximately(
8549
+ assert.approximately = function(act, exp, delta, msg) {
8550
+ new Assertion(act, msg, assert.approximately, true).to.be.approximately(
8532
8551
  exp,
8533
8552
  delta
8534
8553
  );
8535
8554
  };
8536
- assert2.sameMembers = function(set1, set22, msg) {
8537
- new Assertion(set1, msg, assert2.sameMembers, true).to.have.same.members(set22);
8555
+ assert.sameMembers = function(set1, set22, msg) {
8556
+ new Assertion(set1, msg, assert.sameMembers, true).to.have.same.members(set22);
8538
8557
  };
8539
- assert2.notSameMembers = function(set1, set22, msg) {
8558
+ assert.notSameMembers = function(set1, set22, msg) {
8540
8559
  new Assertion(
8541
8560
  set1,
8542
8561
  msg,
8543
- assert2.notSameMembers,
8562
+ assert.notSameMembers,
8544
8563
  true
8545
8564
  ).to.not.have.same.members(set22);
8546
8565
  };
8547
- assert2.sameDeepMembers = function(set1, set22, msg) {
8566
+ assert.sameDeepMembers = function(set1, set22, msg) {
8548
8567
  new Assertion(
8549
8568
  set1,
8550
8569
  msg,
8551
- assert2.sameDeepMembers,
8570
+ assert.sameDeepMembers,
8552
8571
  true
8553
8572
  ).to.have.same.deep.members(set22);
8554
8573
  };
8555
- assert2.notSameDeepMembers = function(set1, set22, msg) {
8574
+ assert.notSameDeepMembers = function(set1, set22, msg) {
8556
8575
  new Assertion(
8557
8576
  set1,
8558
8577
  msg,
8559
- assert2.notSameDeepMembers,
8578
+ assert.notSameDeepMembers,
8560
8579
  true
8561
8580
  ).to.not.have.same.deep.members(set22);
8562
8581
  };
8563
- assert2.sameOrderedMembers = function(set1, set22, msg) {
8582
+ assert.sameOrderedMembers = function(set1, set22, msg) {
8564
8583
  new Assertion(
8565
8584
  set1,
8566
8585
  msg,
8567
- assert2.sameOrderedMembers,
8586
+ assert.sameOrderedMembers,
8568
8587
  true
8569
8588
  ).to.have.same.ordered.members(set22);
8570
8589
  };
8571
- assert2.notSameOrderedMembers = function(set1, set22, msg) {
8590
+ assert.notSameOrderedMembers = function(set1, set22, msg) {
8572
8591
  new Assertion(
8573
8592
  set1,
8574
8593
  msg,
8575
- assert2.notSameOrderedMembers,
8594
+ assert.notSameOrderedMembers,
8576
8595
  true
8577
8596
  ).to.not.have.same.ordered.members(set22);
8578
8597
  };
8579
- assert2.sameDeepOrderedMembers = function(set1, set22, msg) {
8598
+ assert.sameDeepOrderedMembers = function(set1, set22, msg) {
8580
8599
  new Assertion(
8581
8600
  set1,
8582
8601
  msg,
8583
- assert2.sameDeepOrderedMembers,
8602
+ assert.sameDeepOrderedMembers,
8584
8603
  true
8585
8604
  ).to.have.same.deep.ordered.members(set22);
8586
8605
  };
8587
- assert2.notSameDeepOrderedMembers = function(set1, set22, msg) {
8606
+ assert.notSameDeepOrderedMembers = function(set1, set22, msg) {
8588
8607
  new Assertion(
8589
8608
  set1,
8590
8609
  msg,
8591
- assert2.notSameDeepOrderedMembers,
8610
+ assert.notSameDeepOrderedMembers,
8592
8611
  true
8593
8612
  ).to.not.have.same.deep.ordered.members(set22);
8594
8613
  };
8595
- assert2.includeMembers = function(superset, subset, msg) {
8596
- new Assertion(superset, msg, assert2.includeMembers, true).to.include.members(
8614
+ assert.includeMembers = function(superset, subset, msg) {
8615
+ new Assertion(superset, msg, assert.includeMembers, true).to.include.members(
8597
8616
  subset
8598
8617
  );
8599
8618
  };
8600
- assert2.notIncludeMembers = function(superset, subset, msg) {
8619
+ assert.notIncludeMembers = function(superset, subset, msg) {
8601
8620
  new Assertion(
8602
8621
  superset,
8603
8622
  msg,
8604
- assert2.notIncludeMembers,
8623
+ assert.notIncludeMembers,
8605
8624
  true
8606
8625
  ).to.not.include.members(subset);
8607
8626
  };
8608
- assert2.includeDeepMembers = function(superset, subset, msg) {
8627
+ assert.includeDeepMembers = function(superset, subset, msg) {
8609
8628
  new Assertion(
8610
8629
  superset,
8611
8630
  msg,
8612
- assert2.includeDeepMembers,
8631
+ assert.includeDeepMembers,
8613
8632
  true
8614
8633
  ).to.include.deep.members(subset);
8615
8634
  };
8616
- assert2.notIncludeDeepMembers = function(superset, subset, msg) {
8635
+ assert.notIncludeDeepMembers = function(superset, subset, msg) {
8617
8636
  new Assertion(
8618
8637
  superset,
8619
8638
  msg,
8620
- assert2.notIncludeDeepMembers,
8639
+ assert.notIncludeDeepMembers,
8621
8640
  true
8622
8641
  ).to.not.include.deep.members(subset);
8623
8642
  };
8624
- assert2.includeOrderedMembers = function(superset, subset, msg) {
8643
+ assert.includeOrderedMembers = function(superset, subset, msg) {
8625
8644
  new Assertion(
8626
8645
  superset,
8627
8646
  msg,
8628
- assert2.includeOrderedMembers,
8647
+ assert.includeOrderedMembers,
8629
8648
  true
8630
8649
  ).to.include.ordered.members(subset);
8631
8650
  };
8632
- assert2.notIncludeOrderedMembers = function(superset, subset, msg) {
8651
+ assert.notIncludeOrderedMembers = function(superset, subset, msg) {
8633
8652
  new Assertion(
8634
8653
  superset,
8635
8654
  msg,
8636
- assert2.notIncludeOrderedMembers,
8655
+ assert.notIncludeOrderedMembers,
8637
8656
  true
8638
8657
  ).to.not.include.ordered.members(subset);
8639
8658
  };
8640
- assert2.includeDeepOrderedMembers = function(superset, subset, msg) {
8659
+ assert.includeDeepOrderedMembers = function(superset, subset, msg) {
8641
8660
  new Assertion(
8642
8661
  superset,
8643
8662
  msg,
8644
- assert2.includeDeepOrderedMembers,
8663
+ assert.includeDeepOrderedMembers,
8645
8664
  true
8646
8665
  ).to.include.deep.ordered.members(subset);
8647
8666
  };
8648
- assert2.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
8667
+ assert.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
8649
8668
  new Assertion(
8650
8669
  superset,
8651
8670
  msg,
8652
- assert2.notIncludeDeepOrderedMembers,
8671
+ assert.notIncludeDeepOrderedMembers,
8653
8672
  true
8654
8673
  ).to.not.include.deep.ordered.members(subset);
8655
8674
  };
8656
- assert2.oneOf = function(inList, list, msg) {
8657
- new Assertion(inList, msg, assert2.oneOf, true).to.be.oneOf(list);
8675
+ assert.oneOf = function(inList, list, msg) {
8676
+ new Assertion(inList, msg, assert.oneOf, true).to.be.oneOf(list);
8658
8677
  };
8659
- assert2.isIterable = function(obj, msg) {
8678
+ assert.isIterable = function(obj, msg) {
8660
8679
  if (obj == void 0 || !obj[Symbol.iterator]) {
8661
8680
  msg = msg ? `${msg} expected ${inspect22(obj)} to be an iterable` : `expected ${inspect22(obj)} to be an iterable`;
8662
- throw new AssertionError(msg, void 0, assert2.isIterable);
8681
+ throw new AssertionError(msg, void 0, assert.isIterable);
8663
8682
  }
8664
8683
  };
8665
- assert2.changes = function(fn2, obj, prop, msg) {
8684
+ assert.changes = function(fn2, obj, prop, msg) {
8666
8685
  if (arguments.length === 3 && typeof obj === "function") {
8667
8686
  msg = prop;
8668
8687
  prop = null;
8669
8688
  }
8670
- new Assertion(fn2, msg, assert2.changes, true).to.change(obj, prop);
8689
+ new Assertion(fn2, msg, assert.changes, true).to.change(obj, prop);
8671
8690
  };
8672
- assert2.changesBy = function(fn2, obj, prop, delta, msg) {
8691
+ assert.changesBy = function(fn2, obj, prop, delta, msg) {
8673
8692
  if (arguments.length === 4 && typeof obj === "function") {
8674
- var tmpMsg = delta;
8693
+ let tmpMsg = delta;
8675
8694
  delta = prop;
8676
8695
  msg = tmpMsg;
8677
8696
  } else if (arguments.length === 3) {
8678
8697
  delta = prop;
8679
8698
  prop = null;
8680
8699
  }
8681
- new Assertion(fn2, msg, assert2.changesBy, true).to.change(obj, prop).by(delta);
8700
+ new Assertion(fn2, msg, assert.changesBy, true).to.change(obj, prop).by(delta);
8682
8701
  };
8683
- assert2.doesNotChange = function(fn2, obj, prop, msg) {
8702
+ assert.doesNotChange = function(fn2, obj, prop, msg) {
8684
8703
  if (arguments.length === 3 && typeof obj === "function") {
8685
8704
  msg = prop;
8686
8705
  prop = null;
8687
8706
  }
8688
- return new Assertion(fn2, msg, assert2.doesNotChange, true).to.not.change(
8707
+ return new Assertion(fn2, msg, assert.doesNotChange, true).to.not.change(
8689
8708
  obj,
8690
8709
  prop
8691
8710
  );
8692
8711
  };
8693
- assert2.changesButNotBy = function(fn2, obj, prop, delta, msg) {
8712
+ assert.changesButNotBy = function(fn2, obj, prop, delta, msg) {
8694
8713
  if (arguments.length === 4 && typeof obj === "function") {
8695
- var tmpMsg = delta;
8714
+ let tmpMsg = delta;
8696
8715
  delta = prop;
8697
8716
  msg = tmpMsg;
8698
8717
  } else if (arguments.length === 3) {
8699
8718
  delta = prop;
8700
8719
  prop = null;
8701
8720
  }
8702
- new Assertion(fn2, msg, assert2.changesButNotBy, true).to.change(obj, prop).but.not.by(delta);
8721
+ new Assertion(fn2, msg, assert.changesButNotBy, true).to.change(obj, prop).but.not.by(delta);
8703
8722
  };
8704
- assert2.increases = function(fn2, obj, prop, msg) {
8723
+ assert.increases = function(fn2, obj, prop, msg) {
8705
8724
  if (arguments.length === 3 && typeof obj === "function") {
8706
8725
  msg = prop;
8707
8726
  prop = null;
8708
8727
  }
8709
- return new Assertion(fn2, msg, assert2.increases, true).to.increase(obj, prop);
8728
+ return new Assertion(fn2, msg, assert.increases, true).to.increase(obj, prop);
8710
8729
  };
8711
- assert2.increasesBy = function(fn2, obj, prop, delta, msg) {
8730
+ assert.increasesBy = function(fn2, obj, prop, delta, msg) {
8712
8731
  if (arguments.length === 4 && typeof obj === "function") {
8713
- var tmpMsg = delta;
8732
+ let tmpMsg = delta;
8714
8733
  delta = prop;
8715
8734
  msg = tmpMsg;
8716
8735
  } else if (arguments.length === 3) {
8717
8736
  delta = prop;
8718
8737
  prop = null;
8719
8738
  }
8720
- new Assertion(fn2, msg, assert2.increasesBy, true).to.increase(obj, prop).by(delta);
8739
+ new Assertion(fn2, msg, assert.increasesBy, true).to.increase(obj, prop).by(delta);
8721
8740
  };
8722
- assert2.doesNotIncrease = function(fn2, obj, prop, msg) {
8741
+ assert.doesNotIncrease = function(fn2, obj, prop, msg) {
8723
8742
  if (arguments.length === 3 && typeof obj === "function") {
8724
8743
  msg = prop;
8725
8744
  prop = null;
8726
8745
  }
8727
- return new Assertion(fn2, msg, assert2.doesNotIncrease, true).to.not.increase(
8746
+ return new Assertion(fn2, msg, assert.doesNotIncrease, true).to.not.increase(
8728
8747
  obj,
8729
8748
  prop
8730
8749
  );
8731
8750
  };
8732
- assert2.increasesButNotBy = function(fn2, obj, prop, delta, msg) {
8751
+ assert.increasesButNotBy = function(fn2, obj, prop, delta, msg) {
8733
8752
  if (arguments.length === 4 && typeof obj === "function") {
8734
- var tmpMsg = delta;
8753
+ let tmpMsg = delta;
8735
8754
  delta = prop;
8736
8755
  msg = tmpMsg;
8737
8756
  } else if (arguments.length === 3) {
8738
8757
  delta = prop;
8739
8758
  prop = null;
8740
8759
  }
8741
- new Assertion(fn2, msg, assert2.increasesButNotBy, true).to.increase(obj, prop).but.not.by(delta);
8760
+ new Assertion(fn2, msg, assert.increasesButNotBy, true).to.increase(obj, prop).but.not.by(delta);
8742
8761
  };
8743
- assert2.decreases = function(fn2, obj, prop, msg) {
8762
+ assert.decreases = function(fn2, obj, prop, msg) {
8744
8763
  if (arguments.length === 3 && typeof obj === "function") {
8745
8764
  msg = prop;
8746
8765
  prop = null;
8747
8766
  }
8748
- return new Assertion(fn2, msg, assert2.decreases, true).to.decrease(obj, prop);
8767
+ return new Assertion(fn2, msg, assert.decreases, true).to.decrease(obj, prop);
8749
8768
  };
8750
- assert2.decreasesBy = function(fn2, obj, prop, delta, msg) {
8769
+ assert.decreasesBy = function(fn2, obj, prop, delta, msg) {
8751
8770
  if (arguments.length === 4 && typeof obj === "function") {
8752
- var tmpMsg = delta;
8771
+ let tmpMsg = delta;
8753
8772
  delta = prop;
8754
8773
  msg = tmpMsg;
8755
8774
  } else if (arguments.length === 3) {
8756
8775
  delta = prop;
8757
8776
  prop = null;
8758
8777
  }
8759
- new Assertion(fn2, msg, assert2.decreasesBy, true).to.decrease(obj, prop).by(delta);
8778
+ new Assertion(fn2, msg, assert.decreasesBy, true).to.decrease(obj, prop).by(delta);
8760
8779
  };
8761
- assert2.doesNotDecrease = function(fn2, obj, prop, msg) {
8780
+ assert.doesNotDecrease = function(fn2, obj, prop, msg) {
8762
8781
  if (arguments.length === 3 && typeof obj === "function") {
8763
8782
  msg = prop;
8764
8783
  prop = null;
8765
8784
  }
8766
- return new Assertion(fn2, msg, assert2.doesNotDecrease, true).to.not.decrease(
8785
+ return new Assertion(fn2, msg, assert.doesNotDecrease, true).to.not.decrease(
8767
8786
  obj,
8768
8787
  prop
8769
8788
  );
8770
8789
  };
8771
- assert2.doesNotDecreaseBy = function(fn2, obj, prop, delta, msg) {
8790
+ assert.doesNotDecreaseBy = function(fn2, obj, prop, delta, msg) {
8772
8791
  if (arguments.length === 4 && typeof obj === "function") {
8773
- var tmpMsg = delta;
8792
+ let tmpMsg = delta;
8774
8793
  delta = prop;
8775
8794
  msg = tmpMsg;
8776
8795
  } else if (arguments.length === 3) {
8777
8796
  delta = prop;
8778
8797
  prop = null;
8779
8798
  }
8780
- return new Assertion(fn2, msg, assert2.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta);
8799
+ return new Assertion(fn2, msg, assert.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta);
8781
8800
  };
8782
- assert2.decreasesButNotBy = function(fn2, obj, prop, delta, msg) {
8801
+ assert.decreasesButNotBy = function(fn2, obj, prop, delta, msg) {
8783
8802
  if (arguments.length === 4 && typeof obj === "function") {
8784
- var tmpMsg = delta;
8803
+ let tmpMsg = delta;
8785
8804
  delta = prop;
8786
8805
  msg = tmpMsg;
8787
8806
  } else if (arguments.length === 3) {
8788
8807
  delta = prop;
8789
8808
  prop = null;
8790
8809
  }
8791
- new Assertion(fn2, msg, assert2.decreasesButNotBy, true).to.decrease(obj, prop).but.not.by(delta);
8810
+ new Assertion(fn2, msg, assert.decreasesButNotBy, true).to.decrease(obj, prop).but.not.by(delta);
8792
8811
  };
8793
- assert2.ifError = function(val) {
8812
+ assert.ifError = function(val) {
8794
8813
  if (val) {
8795
8814
  throw val;
8796
8815
  }
8797
8816
  };
8798
- assert2.isExtensible = function(obj, msg) {
8799
- new Assertion(obj, msg, assert2.isExtensible, true).to.be.extensible;
8817
+ assert.isExtensible = function(obj, msg) {
8818
+ new Assertion(obj, msg, assert.isExtensible, true).to.be.extensible;
8800
8819
  };
8801
- assert2.isNotExtensible = function(obj, msg) {
8802
- new Assertion(obj, msg, assert2.isNotExtensible, true).to.not.be.extensible;
8820
+ assert.isNotExtensible = function(obj, msg) {
8821
+ new Assertion(obj, msg, assert.isNotExtensible, true).to.not.be.extensible;
8803
8822
  };
8804
- assert2.isSealed = function(obj, msg) {
8805
- new Assertion(obj, msg, assert2.isSealed, true).to.be.sealed;
8823
+ assert.isSealed = function(obj, msg) {
8824
+ new Assertion(obj, msg, assert.isSealed, true).to.be.sealed;
8806
8825
  };
8807
- assert2.isNotSealed = function(obj, msg) {
8808
- new Assertion(obj, msg, assert2.isNotSealed, true).to.not.be.sealed;
8826
+ assert.isNotSealed = function(obj, msg) {
8827
+ new Assertion(obj, msg, assert.isNotSealed, true).to.not.be.sealed;
8809
8828
  };
8810
- assert2.isFrozen = function(obj, msg) {
8811
- new Assertion(obj, msg, assert2.isFrozen, true).to.be.frozen;
8829
+ assert.isFrozen = function(obj, msg) {
8830
+ new Assertion(obj, msg, assert.isFrozen, true).to.be.frozen;
8812
8831
  };
8813
- assert2.isNotFrozen = function(obj, msg) {
8814
- new Assertion(obj, msg, assert2.isNotFrozen, true).to.not.be.frozen;
8832
+ assert.isNotFrozen = function(obj, msg) {
8833
+ new Assertion(obj, msg, assert.isNotFrozen, true).to.not.be.frozen;
8815
8834
  };
8816
- assert2.isEmpty = function(val, msg) {
8817
- new Assertion(val, msg, assert2.isEmpty, true).to.be.empty;
8835
+ assert.isEmpty = function(val, msg) {
8836
+ new Assertion(val, msg, assert.isEmpty, true).to.be.empty;
8818
8837
  };
8819
- assert2.isNotEmpty = function(val, msg) {
8820
- new Assertion(val, msg, assert2.isNotEmpty, true).to.not.be.empty;
8838
+ assert.isNotEmpty = function(val, msg) {
8839
+ new Assertion(val, msg, assert.isNotEmpty, true).to.not.be.empty;
8821
8840
  };
8822
- assert2.containsSubset = function(val, exp, msg) {
8841
+ assert.containsSubset = function(val, exp, msg) {
8823
8842
  new Assertion(val, msg).to.containSubset(exp);
8824
8843
  };
8825
- assert2.doesNotContainSubset = function(val, exp, msg) {
8844
+ assert.doesNotContainSubset = function(val, exp, msg) {
8826
8845
  new Assertion(val, msg).to.not.containSubset(exp);
8827
8846
  };
8828
8847
  var aliases = [
@@ -8843,7 +8862,7 @@ var aliases = [
8843
8862
  ["containsSubset", "containSubset"]
8844
8863
  ];
8845
8864
  for (const [name, as] of aliases) {
8846
- assert2[as] = assert2[name];
8865
+ assert[as] = assert[name];
8847
8866
  }
8848
8867
  var used = [];
8849
8868
  function use(fn2) {
@@ -8853,7 +8872,7 @@ function use(fn2) {
8853
8872
  util: utils_exports,
8854
8873
  config,
8855
8874
  expect,
8856
- assert: assert2,
8875
+ assert,
8857
8876
  Assertion,
8858
8877
  ...should_exports
8859
8878
  };
@@ -8999,70 +9018,70 @@ function addCustomEqualityTesters(newTesters) {
8999
9018
  function getCustomEqualityTesters() {
9000
9019
  return globalThis[JEST_MATCHERS_OBJECT].customEqualityTesters;
9001
9020
  }
9002
- function equals(a3, b, customTesters, strictCheck) {
9021
+ function equals(a3, b2, customTesters, strictCheck) {
9003
9022
  customTesters = customTesters || [];
9004
- return eq(a3, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
9023
+ return eq(a3, b2, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
9005
9024
  }
9006
9025
  function isAsymmetric(obj) {
9007
9026
  return !!obj && typeof obj === "object" && "asymmetricMatch" in obj && isA("Function", obj.asymmetricMatch);
9008
9027
  }
9009
- function asymmetricMatch(a3, b) {
9028
+ function asymmetricMatch(a3, b2) {
9010
9029
  const asymmetricA = isAsymmetric(a3);
9011
- const asymmetricB = isAsymmetric(b);
9030
+ const asymmetricB = isAsymmetric(b2);
9012
9031
  if (asymmetricA && asymmetricB) {
9013
9032
  return void 0;
9014
9033
  }
9015
9034
  if (asymmetricA) {
9016
- return a3.asymmetricMatch(b);
9035
+ return a3.asymmetricMatch(b2);
9017
9036
  }
9018
9037
  if (asymmetricB) {
9019
- return b.asymmetricMatch(a3);
9038
+ return b2.asymmetricMatch(a3);
9020
9039
  }
9021
9040
  }
9022
- function eq(a3, b, aStack, bStack, customTesters, hasKey2) {
9041
+ function eq(a3, b2, aStack, bStack, customTesters, hasKey2) {
9023
9042
  let result = true;
9024
- const asymmetricResult = asymmetricMatch(a3, b);
9043
+ const asymmetricResult = asymmetricMatch(a3, b2);
9025
9044
  if (asymmetricResult !== void 0) {
9026
9045
  return asymmetricResult;
9027
9046
  }
9028
9047
  const testerContext = { equals };
9029
9048
  for (let i = 0; i < customTesters.length; i++) {
9030
- const customTesterResult = customTesters[i].call(testerContext, a3, b, customTesters);
9049
+ const customTesterResult = customTesters[i].call(testerContext, a3, b2, customTesters);
9031
9050
  if (customTesterResult !== void 0) {
9032
9051
  return customTesterResult;
9033
9052
  }
9034
9053
  }
9035
- if (typeof URL === "function" && a3 instanceof URL && b instanceof URL) {
9036
- return a3.href === b.href;
9054
+ if (typeof URL === "function" && a3 instanceof URL && b2 instanceof URL) {
9055
+ return a3.href === b2.href;
9037
9056
  }
9038
- if (Object.is(a3, b)) {
9057
+ if (Object.is(a3, b2)) {
9039
9058
  return true;
9040
9059
  }
9041
- if (a3 === null || b === null) {
9042
- return a3 === b;
9060
+ if (a3 === null || b2 === null) {
9061
+ return a3 === b2;
9043
9062
  }
9044
9063
  const className = Object.prototype.toString.call(a3);
9045
- if (className !== Object.prototype.toString.call(b)) {
9064
+ if (className !== Object.prototype.toString.call(b2)) {
9046
9065
  return false;
9047
9066
  }
9048
9067
  switch (className) {
9049
9068
  case "[object Boolean]":
9050
9069
  case "[object String]":
9051
9070
  case "[object Number]":
9052
- if (typeof a3 !== typeof b) {
9071
+ if (typeof a3 !== typeof b2) {
9053
9072
  return false;
9054
- } else if (typeof a3 !== "object" && typeof b !== "object") {
9055
- return Object.is(a3, b);
9073
+ } else if (typeof a3 !== "object" && typeof b2 !== "object") {
9074
+ return Object.is(a3, b2);
9056
9075
  } else {
9057
- return Object.is(a3.valueOf(), b.valueOf());
9076
+ return Object.is(a3.valueOf(), b2.valueOf());
9058
9077
  }
9059
9078
  case "[object Date]": {
9060
9079
  const numA = +a3;
9061
- const numB = +b;
9080
+ const numB = +b2;
9062
9081
  return numA === numB || Number.isNaN(numA) && Number.isNaN(numB);
9063
9082
  }
9064
9083
  case "[object RegExp]":
9065
- return a3.source === b.source && a3.flags === b.flags;
9084
+ return a3.source === b2.source && a3.flags === b2.flags;
9066
9085
  case "[object Temporal.Instant]":
9067
9086
  case "[object Temporal.ZonedDateTime]":
9068
9087
  case "[object Temporal.PlainDateTime]":
@@ -9070,32 +9089,32 @@ function eq(a3, b, aStack, bStack, customTesters, hasKey2) {
9070
9089
  case "[object Temporal.PlainTime]":
9071
9090
  case "[object Temporal.PlainYearMonth]":
9072
9091
  case "[object Temporal.PlainMonthDay]":
9073
- return a3.equals(b);
9092
+ return a3.equals(b2);
9074
9093
  case "[object Temporal.Duration]":
9075
- return a3.toString() === b.toString();
9094
+ return a3.toString() === b2.toString();
9076
9095
  }
9077
- if (typeof a3 !== "object" || typeof b !== "object") {
9096
+ if (typeof a3 !== "object" || typeof b2 !== "object") {
9078
9097
  return false;
9079
9098
  }
9080
- if (isDomNode(a3) && isDomNode(b)) {
9081
- return a3.isEqualNode(b);
9099
+ if (isDomNode(a3) && isDomNode(b2)) {
9100
+ return a3.isEqualNode(b2);
9082
9101
  }
9083
9102
  let length = aStack.length;
9084
9103
  while (length--) {
9085
9104
  if (aStack[length] === a3) {
9086
- return bStack[length] === b;
9087
- } else if (bStack[length] === b) {
9105
+ return bStack[length] === b2;
9106
+ } else if (bStack[length] === b2) {
9088
9107
  return false;
9089
9108
  }
9090
9109
  }
9091
9110
  aStack.push(a3);
9092
- bStack.push(b);
9093
- if (className === "[object Array]" && a3.length !== b.length) {
9111
+ bStack.push(b2);
9112
+ if (className === "[object Array]" && a3.length !== b2.length) {
9094
9113
  return false;
9095
9114
  }
9096
- if (a3 instanceof Error && b instanceof Error) {
9115
+ if (a3 instanceof Error && b2 instanceof Error) {
9097
9116
  try {
9098
- return isErrorEqual(a3, b, aStack, bStack, customTesters, hasKey2);
9117
+ return isErrorEqual(a3, b2, aStack, bStack, customTesters, hasKey2);
9099
9118
  } finally {
9100
9119
  aStack.pop();
9101
9120
  bStack.pop();
@@ -9104,12 +9123,12 @@ function eq(a3, b, aStack, bStack, customTesters, hasKey2) {
9104
9123
  const aKeys = keys(a3, hasKey2);
9105
9124
  let key;
9106
9125
  let size = aKeys.length;
9107
- if (keys(b, hasKey2).length !== size) {
9126
+ if (keys(b2, hasKey2).length !== size) {
9108
9127
  return false;
9109
9128
  }
9110
9129
  while (size--) {
9111
9130
  key = aKeys[size];
9112
- result = hasKey2(b, key) && eq(a3[key], b[key], aStack, bStack, customTesters, hasKey2);
9131
+ result = hasKey2(b2, key) && eq(a3[key], b2[key], aStack, bStack, customTesters, hasKey2);
9113
9132
  if (!result) {
9114
9133
  return false;
9115
9134
  }
@@ -9118,15 +9137,15 @@ function eq(a3, b, aStack, bStack, customTesters, hasKey2) {
9118
9137
  bStack.pop();
9119
9138
  return result;
9120
9139
  }
9121
- function isErrorEqual(a3, b, aStack, bStack, customTesters, hasKey2) {
9122
- let result = Object.getPrototypeOf(a3) === Object.getPrototypeOf(b) && a3.name === b.name && a3.message === b.message;
9123
- if (typeof b.cause !== "undefined") {
9124
- result && (result = eq(a3.cause, b.cause, aStack, bStack, customTesters, hasKey2));
9140
+ function isErrorEqual(a3, b2, aStack, bStack, customTesters, hasKey2) {
9141
+ let result = Object.getPrototypeOf(a3) === Object.getPrototypeOf(b2) && a3.name === b2.name && a3.message === b2.message;
9142
+ if (typeof b2.cause !== "undefined") {
9143
+ result && (result = eq(a3.cause, b2.cause, aStack, bStack, customTesters, hasKey2));
9125
9144
  }
9126
- if (a3 instanceof AggregateError && b instanceof AggregateError) {
9127
- result && (result = eq(a3.errors, b.errors, aStack, bStack, customTesters, hasKey2));
9145
+ if (a3 instanceof AggregateError && b2 instanceof AggregateError) {
9146
+ result && (result = eq(a3.errors, b2.errors, aStack, bStack, customTesters, hasKey2));
9128
9147
  }
9129
- result && (result = eq({ ...a3 }, { ...b }, aStack, bStack, customTesters, hasKey2));
9148
+ result && (result = eq({ ...a3 }, { ...b2 }, aStack, bStack, customTesters, hasKey2));
9130
9149
  return result;
9131
9150
  }
9132
9151
  function keys(obj, hasKey2) {
@@ -9180,34 +9199,34 @@ var IteratorSymbol = Symbol.iterator;
9180
9199
  function hasIterator(object2) {
9181
9200
  return !!(object2 != null && object2[IteratorSymbol]);
9182
9201
  }
9183
- function iterableEquality(a3, b, customTesters = [], aStack = [], bStack = []) {
9184
- if (typeof a3 !== "object" || typeof b !== "object" || Array.isArray(a3) || Array.isArray(b) || !hasIterator(a3) || !hasIterator(b)) {
9202
+ function iterableEquality(a3, b2, customTesters = [], aStack = [], bStack = []) {
9203
+ if (typeof a3 !== "object" || typeof b2 !== "object" || Array.isArray(a3) || Array.isArray(b2) || !hasIterator(a3) || !hasIterator(b2)) {
9185
9204
  return void 0;
9186
9205
  }
9187
- if (a3.constructor !== b.constructor) {
9206
+ if (a3.constructor !== b2.constructor) {
9188
9207
  return false;
9189
9208
  }
9190
9209
  let length = aStack.length;
9191
9210
  while (length--) {
9192
9211
  if (aStack[length] === a3) {
9193
- return bStack[length] === b;
9212
+ return bStack[length] === b2;
9194
9213
  }
9195
9214
  }
9196
9215
  aStack.push(a3);
9197
- bStack.push(b);
9216
+ bStack.push(b2);
9198
9217
  const filteredCustomTesters = [...customTesters.filter((t) => t !== iterableEquality), iterableEqualityWithStack];
9199
- function iterableEqualityWithStack(a4, b2) {
9200
- return iterableEquality(a4, b2, [...customTesters], [...aStack], [...bStack]);
9218
+ function iterableEqualityWithStack(a4, b3) {
9219
+ return iterableEquality(a4, b3, [...customTesters], [...aStack], [...bStack]);
9201
9220
  }
9202
9221
  if (a3.size !== void 0) {
9203
- if (a3.size !== b.size) {
9222
+ if (a3.size !== b2.size) {
9204
9223
  return false;
9205
9224
  } else if (isA("Set", a3) || isImmutableUnorderedSet(a3)) {
9206
9225
  let allFound = true;
9207
9226
  for (const aValue of a3) {
9208
- if (!b.has(aValue)) {
9227
+ if (!b2.has(aValue)) {
9209
9228
  let has = false;
9210
- for (const bValue of b) {
9229
+ for (const bValue of b2) {
9211
9230
  const isEqual = equals(aValue, bValue, filteredCustomTesters);
9212
9231
  if (isEqual === true) {
9213
9232
  has = true;
@@ -9225,9 +9244,9 @@ function iterableEquality(a3, b, customTesters = [], aStack = [], bStack = []) {
9225
9244
  } else if (isA("Map", a3) || isImmutableUnorderedKeyed(a3)) {
9226
9245
  let allFound = true;
9227
9246
  for (const aEntry of a3) {
9228
- if (!b.has(aEntry[0]) || !equals(aEntry[1], b.get(aEntry[0]), filteredCustomTesters)) {
9247
+ if (!b2.has(aEntry[0]) || !equals(aEntry[1], b2.get(aEntry[0]), filteredCustomTesters)) {
9229
9248
  let has = false;
9230
- for (const bEntry of b) {
9249
+ for (const bEntry of b2) {
9231
9250
  const matchedKey = equals(aEntry[0], bEntry[0], filteredCustomTesters);
9232
9251
  let matchedValue = false;
9233
9252
  if (matchedKey === true) {
@@ -9248,7 +9267,7 @@ function iterableEquality(a3, b, customTesters = [], aStack = [], bStack = []) {
9248
9267
  return allFound;
9249
9268
  }
9250
9269
  }
9251
- const bIterator = b[IteratorSymbol]();
9270
+ const bIterator = b2[IteratorSymbol]();
9252
9271
  for (const aValue of a3) {
9253
9272
  const nextB = bIterator.next();
9254
9273
  if (nextB.done || !equals(aValue, nextB.value, filteredCustomTesters)) {
@@ -9260,7 +9279,7 @@ function iterableEquality(a3, b, customTesters = [], aStack = [], bStack = []) {
9260
9279
  }
9261
9280
  if (!isImmutableList(a3) && !isImmutableOrderedKeyed(a3) && !isImmutableOrderedSet(a3) && !isImmutableRecord(a3)) {
9262
9281
  const aEntries = Object.entries(a3);
9263
- const bEntries = Object.entries(b);
9282
+ const bEntries = Object.entries(b2);
9264
9283
  if (!equals(aEntries, bEntries, filteredCustomTesters)) {
9265
9284
  return false;
9266
9285
  }
@@ -9299,22 +9318,22 @@ function subsetEquality(object2, subset, customTesters = []) {
9299
9318
  };
9300
9319
  return subsetEqualityWithContext()(object2, subset);
9301
9320
  }
9302
- function typeEquality(a3, b) {
9303
- if (a3 == null || b == null || a3.constructor === b.constructor) {
9321
+ function typeEquality(a3, b2) {
9322
+ if (a3 == null || b2 == null || a3.constructor === b2.constructor) {
9304
9323
  return void 0;
9305
9324
  }
9306
9325
  return false;
9307
9326
  }
9308
- function arrayBufferEquality(a3, b) {
9327
+ function arrayBufferEquality(a3, b2) {
9309
9328
  let dataViewA = a3;
9310
- let dataViewB = b;
9311
- if (!(a3 instanceof DataView && b instanceof DataView)) {
9312
- if (!(a3 instanceof ArrayBuffer) || !(b instanceof ArrayBuffer)) {
9329
+ let dataViewB = b2;
9330
+ if (!(a3 instanceof DataView && b2 instanceof DataView)) {
9331
+ if (!(a3 instanceof ArrayBuffer) || !(b2 instanceof ArrayBuffer)) {
9313
9332
  return void 0;
9314
9333
  }
9315
9334
  try {
9316
9335
  dataViewA = new DataView(a3);
9317
- dataViewB = new DataView(b);
9336
+ dataViewB = new DataView(b2);
9318
9337
  } catch {
9319
9338
  return void 0;
9320
9339
  }
@@ -9329,14 +9348,14 @@ function arrayBufferEquality(a3, b) {
9329
9348
  }
9330
9349
  return true;
9331
9350
  }
9332
- function sparseArrayEquality(a3, b, customTesters = []) {
9333
- if (!Array.isArray(a3) || !Array.isArray(b)) {
9351
+ function sparseArrayEquality(a3, b2, customTesters = []) {
9352
+ if (!Array.isArray(a3) || !Array.isArray(b2)) {
9334
9353
  return void 0;
9335
9354
  }
9336
9355
  const aKeys = Object.keys(a3);
9337
- const bKeys = Object.keys(b);
9356
+ const bKeys = Object.keys(b2);
9338
9357
  const filteredCustomTesters = customTesters.filter((t) => t !== sparseArrayEquality);
9339
- return equals(a3, b, filteredCustomTesters, true) && equals(aKeys, bKeys);
9358
+ return equals(a3, b2, filteredCustomTesters, true) && equals(aKeys, bKeys);
9340
9359
  }
9341
9360
  function generateToBeMessage(deepEqualityName, expected = "#{this}", actual = "#{exp}") {
9342
9361
  const toBeMessage = `expected ${expected} to be ${actual} // Object.is equality`;
@@ -10028,7 +10047,7 @@ var JestChaiExpect = (chai2, utils) => {
10028
10047
  return this.assert(pass, `expected #{this} to be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`, `expected #{this} to not be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`, received, expected, false);
10029
10048
  });
10030
10049
  function assertIsMock(assertion) {
10031
- if (!isMockFunction2(assertion._obj)) {
10050
+ if (!isMockFunction(assertion._obj)) {
10032
10051
  throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
10033
10052
  }
10034
10053
  }
@@ -10068,8 +10087,8 @@ var JestChaiExpect = (chai2, utils) => {
10068
10087
  throw new AssertionError2(msg);
10069
10088
  }
10070
10089
  });
10071
- function equalsArgumentArray(a3, b) {
10072
- return a3.length === b.length && a3.every((aItem, i) => equals(aItem, b[i], [...customTesters, iterableEquality]));
10090
+ function equalsArgumentArray(a3, b2) {
10091
+ return a3.length === b2.length && a3.every((aItem, i) => equals(aItem, b2[i], [...customTesters, iterableEquality]));
10073
10092
  }
10074
10093
  def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
10075
10094
  const spy = getSpy(this);
@@ -10130,14 +10149,14 @@ var JestChaiExpect = (chai2, utils) => {
10130
10149
  }
10131
10150
  def(["toHaveBeenCalledBefore"], function(resultSpy, failIfNoFirstInvocation = true) {
10132
10151
  const expectSpy = getSpy(this);
10133
- if (!isMockFunction2(resultSpy)) {
10152
+ if (!isMockFunction(resultSpy)) {
10134
10153
  throw new TypeError(`${utils.inspect(resultSpy)} is not a spy or a call to a spy`);
10135
10154
  }
10136
10155
  this.assert(isSpyCalledBeforeAnotherSpy(expectSpy, resultSpy, failIfNoFirstInvocation), `expected "${expectSpy.getMockName()}" to have been called before "${resultSpy.getMockName()}"`, `expected "${expectSpy.getMockName()}" to not have been called before "${resultSpy.getMockName()}"`, resultSpy, expectSpy);
10137
10156
  });
10138
10157
  def(["toHaveBeenCalledAfter"], function(resultSpy, failIfNoFirstInvocation = true) {
10139
10158
  const expectSpy = getSpy(this);
10140
- if (!isMockFunction2(resultSpy)) {
10159
+ if (!isMockFunction(resultSpy)) {
10141
10160
  throw new TypeError(`${utils.inspect(resultSpy)} is not a spy or a call to a spy`);
10142
10161
  }
10143
10162
  this.assert(isSpyCalledBeforeAnotherSpy(resultSpy, expectSpy, failIfNoFirstInvocation), `expected "${expectSpy.getMockName()}" to have been called after "${resultSpy.getMockName()}"`, `expected "${expectSpy.getMockName()}" to not have been called after "${resultSpy.getMockName()}"`, resultSpy, expectSpy);
@@ -10371,15 +10390,15 @@ var JestChaiExpect = (chai2, utils) => {
10371
10390
  });
10372
10391
  };
10373
10392
  function ordinalOf(i) {
10374
- const j = i % 10;
10375
- const k = i % 100;
10376
- if (j === 1 && k !== 11) {
10393
+ const j2 = i % 10;
10394
+ const k2 = i % 100;
10395
+ if (j2 === 1 && k2 !== 11) {
10377
10396
  return `${i}st`;
10378
10397
  }
10379
- if (j === 2 && k !== 12) {
10398
+ if (j2 === 2 && k2 !== 12) {
10380
10399
  return `${i}nd`;
10381
10400
  }
10382
- if (j === 3 && k !== 13) {
10401
+ if (j2 === 3 && k2 !== 13) {
10383
10402
  return `${i}rd`;
10384
10403
  }
10385
10404
  return `${i}th`;
@@ -10747,81 +10766,70 @@ function parseSingleV8Stack(raw) {
10747
10766
  };
10748
10767
  }
10749
10768
 
10750
- // ../../node_modules/.pnpm/strip-literal@3.0.0/node_modules/strip-literal/dist/index.mjs
10769
+ // ../../node_modules/.pnpm/strip-literal@3.1.0/node_modules/strip-literal/dist/index.mjs
10751
10770
  var import_js_tokens = __toESM(require_js_tokens(), 1);
10752
- function stripLiteralJsTokens(code, options) {
10753
- const FILL = " ";
10754
- const FILL_COMMENT = " ";
10755
- let result = "";
10756
- const tokens = [];
10757
- for (const token of (0, import_js_tokens.default)(code, { jsx: false })) {
10758
- tokens.push(token);
10759
- if (token.type === "SingleLineComment") {
10760
- result += FILL_COMMENT.repeat(token.value.length);
10761
- continue;
10762
- }
10763
- if (token.type === "MultiLineComment") {
10764
- result += token.value.replace(/[^\n]/g, FILL_COMMENT);
10765
- continue;
10771
+ var FILL_COMMENT = " ";
10772
+ function stripLiteralFromToken(token, fillChar, filter) {
10773
+ if (token.type === "SingleLineComment") {
10774
+ return FILL_COMMENT.repeat(token.value.length);
10775
+ }
10776
+ if (token.type === "MultiLineComment") {
10777
+ return token.value.replace(/[^\n]/g, FILL_COMMENT);
10778
+ }
10779
+ if (token.type === "StringLiteral") {
10780
+ if (!token.closed) {
10781
+ return token.value;
10766
10782
  }
10767
- if (token.type === "StringLiteral") {
10768
- if (!token.closed) {
10769
- result += token.value;
10770
- continue;
10771
- }
10772
- const body = token.value.slice(1, -1);
10773
- {
10774
- result += token.value[0] + FILL.repeat(body.length) + token.value[token.value.length - 1];
10775
- continue;
10776
- }
10783
+ const body = token.value.slice(1, -1);
10784
+ if (filter(body)) {
10785
+ return token.value[0] + fillChar.repeat(body.length) + token.value[token.value.length - 1];
10777
10786
  }
10778
- if (token.type === "NoSubstitutionTemplate") {
10779
- const body = token.value.slice(1, -1);
10780
- {
10781
- result += `\`${body.replace(/[^\n]/g, FILL)}\``;
10782
- continue;
10783
- }
10787
+ }
10788
+ if (token.type === "NoSubstitutionTemplate") {
10789
+ const body = token.value.slice(1, -1);
10790
+ if (filter(body)) {
10791
+ return `\`${body.replace(/[^\n]/g, fillChar)}\``;
10784
10792
  }
10785
- if (token.type === "RegularExpressionLiteral") {
10786
- const body = token.value;
10787
- {
10788
- result += body.replace(/\/(.*)\/(\w?)$/g, (_, $1, $2) => `/${FILL.repeat($1.length)}/${$2}`);
10789
- continue;
10790
- }
10793
+ }
10794
+ if (token.type === "RegularExpressionLiteral") {
10795
+ const body = token.value;
10796
+ if (filter(body)) {
10797
+ return body.replace(/\/(.*)\/(\w?)$/g, (_, $1, $2) => `/${fillChar.repeat($1.length)}/${$2}`);
10791
10798
  }
10792
- if (token.type === "TemplateHead") {
10793
- const body = token.value.slice(1, -2);
10794
- {
10795
- result += `\`${body.replace(/[^\n]/g, FILL)}\${`;
10796
- continue;
10797
- }
10799
+ }
10800
+ if (token.type === "TemplateHead") {
10801
+ const body = token.value.slice(1, -2);
10802
+ if (filter(body)) {
10803
+ return `\`${body.replace(/[^\n]/g, fillChar)}\${`;
10798
10804
  }
10799
- if (token.type === "TemplateTail") {
10800
- const body = token.value.slice(0, -2);
10801
- {
10802
- result += `}${body.replace(/[^\n]/g, FILL)}\``;
10803
- continue;
10804
- }
10805
+ }
10806
+ if (token.type === "TemplateTail") {
10807
+ const body = token.value.slice(0, -2);
10808
+ if (filter(body)) {
10809
+ return `}${body.replace(/[^\n]/g, fillChar)}\``;
10805
10810
  }
10806
- if (token.type === "TemplateMiddle") {
10807
- const body = token.value.slice(1, -2);
10808
- {
10809
- result += `}${body.replace(/[^\n]/g, FILL)}\${`;
10810
- continue;
10811
- }
10811
+ }
10812
+ if (token.type === "TemplateMiddle") {
10813
+ const body = token.value.slice(1, -2);
10814
+ if (filter(body)) {
10815
+ return `}${body.replace(/[^\n]/g, fillChar)}\${`;
10812
10816
  }
10813
- result += token.value;
10814
10817
  }
10818
+ return token.value;
10819
+ }
10820
+ function optionsWithDefaults(options) {
10815
10821
  return {
10816
- result,
10817
- tokens
10822
+ fillChar: " ",
10823
+ filter: (() => true)
10818
10824
  };
10819
10825
  }
10820
10826
  function stripLiteral(code, options) {
10821
- return stripLiteralDetailed(code).result;
10822
- }
10823
- function stripLiteralDetailed(code, options) {
10824
- return stripLiteralJsTokens(code);
10827
+ let result = "";
10828
+ const _options = optionsWithDefaults();
10829
+ for (const token of (0, import_js_tokens.default)(code, { jsx: false })) {
10830
+ result += stripLiteralFromToken(token, _options.fillChar, _options.filter);
10831
+ }
10832
+ return result;
10825
10833
  }
10826
10834
 
10827
10835
  // ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
@@ -11247,7 +11255,7 @@ var it = test3;
11247
11255
  var runner;
11248
11256
  var defaultSuite;
11249
11257
  var currentTestFilepath;
11250
- function assert3(condition, message) {
11258
+ function assert2(condition, message) {
11251
11259
  if (!condition) {
11252
11260
  throw new Error(`Vitest failed to find ${message}. This is a bug in Vitest. Please, open an issue with reproduction.`);
11253
11261
  }
@@ -11256,12 +11264,12 @@ function getTestFilepath() {
11256
11264
  return currentTestFilepath;
11257
11265
  }
11258
11266
  function getRunner() {
11259
- assert3(runner, "the runner");
11267
+ assert2(runner, "the runner");
11260
11268
  return runner;
11261
11269
  }
11262
11270
  function getCurrentSuite() {
11263
11271
  const currentSuite = collectorContext.currentSuite || defaultSuite;
11264
- assert3(currentSuite, "the current suite");
11272
+ assert2(currentSuite, "the current suite");
11265
11273
  return currentSuite;
11266
11274
  }
11267
11275
  function createSuiteHooks() {
@@ -11649,8 +11657,8 @@ function formatTemplateString(cases, args) {
11649
11657
  const res = [];
11650
11658
  for (let i = 0; i < Math.floor(args.length / header.length); i++) {
11651
11659
  const oneCase = {};
11652
- for (let j = 0; j < header.length; j++) {
11653
- oneCase[header[j]] = args[i * header.length + j];
11660
+ for (let j2 = 0; j2 < header.length; j2++) {
11661
+ oneCase[header[j2]] = args[i * header.length + j2];
11654
11662
  }
11655
11663
  res.push(oneCase);
11656
11664
  }
@@ -11903,25 +11911,25 @@ function encodeUint8Array(bytes) {
11903
11911
  for (let i = 0; i < len; i += 3) {
11904
11912
  if (len === i + 1) {
11905
11913
  const a3 = (bytes[i] & 252) >> 2;
11906
- const b = (bytes[i] & 3) << 4;
11914
+ const b2 = (bytes[i] & 3) << 4;
11907
11915
  base64 += table[a3];
11908
- base64 += table[b];
11916
+ base64 += table[b2];
11909
11917
  base64 += "==";
11910
11918
  } else if (len === i + 2) {
11911
11919
  const a3 = (bytes[i] & 252) >> 2;
11912
- const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
11920
+ const b2 = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
11913
11921
  const c = (bytes[i + 1] & 15) << 2;
11914
11922
  base64 += table[a3];
11915
- base64 += table[b];
11923
+ base64 += table[b2];
11916
11924
  base64 += table[c];
11917
11925
  base64 += "=";
11918
11926
  } else {
11919
11927
  const a3 = (bytes[i] & 252) >> 2;
11920
- const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
11928
+ const b2 = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
11921
11929
  const c = (bytes[i + 1] & 15) << 2 | (bytes[i + 2] & 192) >> 6;
11922
11930
  const d = bytes[i + 2] & 63;
11923
11931
  base64 += table[a3];
11924
- base64 += table[b];
11932
+ base64 += table[b2];
11925
11933
  base64 += table[c];
11926
11934
  base64 += table[d];
11927
11935
  }
@@ -11986,7 +11994,7 @@ function createTestHook(name, handler) {
11986
11994
  };
11987
11995
  }
11988
11996
 
11989
- // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.21_@vitest+ui@3.2.4_jiti@2.6.0_jsdom_57244f75a0f6ad2fb70ec052bfd7aeae/node_modules/vitest/dist/chunks/utils.XdZDrNZV.js
11997
+ // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.23_@vitest+ui@3.2.4_jiti@2.6.1_jsdom_dd8907bbeba1b9babb528cd8e0e32ee8/node_modules/vitest/dist/chunks/utils.XdZDrNZV.js
11990
11998
  var NAME_WORKER_STATE = "__vitest_worker__";
11991
11999
  function getWorkerState() {
11992
12000
  const workerState = globalThis[NAME_WORKER_STATE];
@@ -12034,10 +12042,10 @@ async function waitForImportsToResolve() {
12034
12042
  await waitForImportsToResolve();
12035
12043
  }
12036
12044
 
12037
- // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.21_@vitest+ui@3.2.4_jiti@2.6.0_jsdom_57244f75a0f6ad2fb70ec052bfd7aeae/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
12045
+ // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.23_@vitest+ui@3.2.4_jiti@2.6.1_jsdom_dd8907bbeba1b9babb528cd8e0e32ee8/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
12038
12046
  var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
12039
- function getDefaultExportFromCjs3(x) {
12040
- return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
12047
+ function getDefaultExportFromCjs3(x2) {
12048
+ return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
12041
12049
  }
12042
12050
 
12043
12051
  // ../../node_modules/.pnpm/@vitest+snapshot@3.2.4/node_modules/@vitest/snapshot/dist/index.js
@@ -12136,8 +12144,8 @@ function decode(mappings) {
12136
12144
  function sort(line) {
12137
12145
  line.sort(sortComparator$1);
12138
12146
  }
12139
- function sortComparator$1(a3, b) {
12140
- return a3[0] - b[0];
12147
+ function sortComparator$1(a3, b2) {
12148
+ return a3[0] - b2[0];
12141
12149
  }
12142
12150
  var schemeRegex = /^[\w+.-]+:\/\//;
12143
12151
  var urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
@@ -12351,8 +12359,8 @@ function nextUnsortedSegmentLine(mappings, start) {
12351
12359
  return mappings.length;
12352
12360
  }
12353
12361
  function isSorted(line) {
12354
- for (let j = 1; j < line.length; j++) {
12355
- if (line[j][COLUMN] < line[j - 1][COLUMN]) {
12362
+ for (let j2 = 1; j2 < line.length; j2++) {
12363
+ if (line[j2][COLUMN] < line[j2 - 1][COLUMN]) {
12356
12364
  return false;
12357
12365
  }
12358
12366
  }
@@ -12363,8 +12371,8 @@ function sortSegments(line, owned) {
12363
12371
  line = line.slice();
12364
12372
  return line.sort(sortComparator);
12365
12373
  }
12366
- function sortComparator(a3, b) {
12367
- return a3[COLUMN] - b[COLUMN];
12374
+ function sortComparator(a3, b2) {
12375
+ return a3[COLUMN] - b2[COLUMN];
12368
12376
  }
12369
12377
  var found = false;
12370
12378
  function binarySearch(haystack, needle, low, high) {
@@ -12497,8 +12505,8 @@ function traceSegmentInternal(segments, memo, line, column, bias) {
12497
12505
  return -1;
12498
12506
  return index2;
12499
12507
  }
12500
- function notNullish2(v) {
12501
- return v != null;
12508
+ function notNullish2(v2) {
12509
+ return v2 != null;
12502
12510
  }
12503
12511
  function isPrimitive3(value) {
12504
12512
  return value === null || typeof value !== "function" && typeof value !== "object";
@@ -12713,7 +12721,7 @@ function parseErrorStacktrace(e, options = {}) {
12713
12721
  }
12714
12722
  }
12715
12723
  if (options.frameFilter) {
12716
- stackFrames = stackFrames.filter((f3) => options.frameFilter(e, f3) !== false);
12724
+ stackFrames = stackFrames.filter((f4) => options.frameFilter(e, f4) !== false);
12717
12725
  }
12718
12726
  e.stacks = stackFrames;
12719
12727
  return stackFrames;
@@ -12723,8 +12731,8 @@ try {
12723
12731
  if (Array.isArray(getPromiseDetails(Promise.resolve()))) ;
12724
12732
  } catch (notNode) {
12725
12733
  }
12726
- function getDefaultExportFromCjs4(x) {
12727
- return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
12734
+ function getDefaultExportFromCjs4(x2) {
12735
+ return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
12728
12736
  }
12729
12737
  var reservedWords2 = {
12730
12738
  keyword: [
@@ -12778,7 +12786,7 @@ var reservedWords2 = {
12778
12786
  };
12779
12787
  new Set(reservedWords2.keyword);
12780
12788
  new Set(reservedWords2.strict);
12781
- var f2 = {
12789
+ var f3 = {
12782
12790
  reset: [0, 0],
12783
12791
  bold: [1, 22, "\x1B[22m\x1B[1m"],
12784
12792
  dim: [2, 22, "\x1B[22m\x1B[2m"],
@@ -12821,7 +12829,7 @@ var f2 = {
12821
12829
  bgCyanBright: [106, 49],
12822
12830
  bgWhiteBright: [107, 49]
12823
12831
  };
12824
- var h2 = Object.entries(f2);
12832
+ var h3 = Object.entries(f3);
12825
12833
  function a2(n) {
12826
12834
  return String(n);
12827
12835
  }
@@ -12833,27 +12841,27 @@ function C2(n = false) {
12833
12841
  }
12834
12842
  function p2(n = false) {
12835
12843
  let e = C2(n), i = (r2, t, c, o) => {
12836
- let l = "", s2 = 0;
12844
+ let l2 = "", s2 = 0;
12837
12845
  do
12838
- l += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
12846
+ l2 += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
12839
12847
  while (~o);
12840
- return l + r2.substring(s2);
12848
+ return l2 + r2.substring(s2);
12841
12849
  }, g = (r2, t, c = r2) => {
12842
- let o = (l) => {
12843
- let s2 = String(l), b = s2.indexOf(t, r2.length);
12844
- return ~b ? r2 + i(s2, t, c, b) + t : r2 + s2 + t;
12850
+ let o = (l2) => {
12851
+ let s2 = String(l2), b2 = s2.indexOf(t, r2.length);
12852
+ return ~b2 ? r2 + i(s2, t, c, b2) + t : r2 + s2 + t;
12845
12853
  };
12846
12854
  return o.open = r2, o.close = t, o;
12847
- }, u2 = {
12855
+ }, u3 = {
12848
12856
  isColorSupported: e
12849
12857
  }, d = (r2) => `\x1B[${r2}m`;
12850
- for (let [r2, t] of h2)
12851
- u2[r2] = e ? g(
12858
+ for (let [r2, t] of h3)
12859
+ u3[r2] = e ? g(
12852
12860
  d(t[0]),
12853
12861
  d(t[1]),
12854
12862
  t[2]
12855
12863
  ) : a2;
12856
- return u2;
12864
+ return u3;
12857
12865
  }
12858
12866
  p2();
12859
12867
  var lineSplitRE = /\r?\n/;
@@ -13038,7 +13046,7 @@ var hasRequiredNaturalCompare;
13038
13046
  function requireNaturalCompare() {
13039
13047
  if (hasRequiredNaturalCompare) return naturalCompare$1.exports;
13040
13048
  hasRequiredNaturalCompare = 1;
13041
- var naturalCompare2 = function(a3, b) {
13049
+ var naturalCompare2 = function(a3, b2) {
13042
13050
  var i, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
13043
13051
  function getCode(str, pos, code) {
13044
13052
  if (code) {
@@ -13048,12 +13056,12 @@ function requireNaturalCompare() {
13048
13056
  code = alphabet && alphabet.indexOf(str.charAt(pos));
13049
13057
  return code > -1 ? code + 76 : (code = str.charCodeAt(pos) || 0, code < 45 || code > 127) ? code : code < 46 ? 65 : code < 48 ? code - 1 : code < 58 ? code + 18 : code < 65 ? code - 11 : code < 91 ? code + 11 : code < 97 ? code - 37 : code < 123 ? code + 5 : code - 63;
13050
13058
  }
13051
- if ((a3 += "") != (b += "")) for (; codeB; ) {
13059
+ if ((a3 += "") != (b2 += "")) for (; codeB; ) {
13052
13060
  codeA = getCode(a3, posA++);
13053
- codeB = getCode(b, posB++);
13061
+ codeB = getCode(b2, posB++);
13054
13062
  if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
13055
13063
  codeA = getCode(a3, posA, posA);
13056
- codeB = getCode(b, posB, posA = i);
13064
+ codeB = getCode(b2, posB, posA = i);
13057
13065
  posB = i;
13058
13066
  }
13059
13067
  if (codeA != codeB) return codeA < codeB ? -1 : 1;
@@ -13244,14 +13252,14 @@ var CounterMap = class extends DefaultMap {
13244
13252
  return this._total;
13245
13253
  }
13246
13254
  let total = 0;
13247
- for (const x of this.values()) {
13248
- total += x;
13255
+ for (const x2 of this.values()) {
13256
+ total += x2;
13249
13257
  }
13250
13258
  return total;
13251
13259
  }
13252
13260
  };
13253
- function isSameStackPosition(x, y) {
13254
- return x.file === y.file && x.column === y.column && x.line === y.line;
13261
+ function isSameStackPosition(x2, y2) {
13262
+ return x2.file === y2.file && x2.column === y2.column && x2.line === y2.line;
13255
13263
  }
13256
13264
  var SnapshotState = class _SnapshotState {
13257
13265
  _counters = new CounterMap();
@@ -13664,11 +13672,11 @@ var SnapshotClient = class {
13664
13672
  }
13665
13673
  };
13666
13674
 
13667
- // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.21_@vitest+ui@3.2.4_jiti@2.6.0_jsdom_57244f75a0f6ad2fb70ec052bfd7aeae/node_modules/vitest/dist/chunks/date.Bq6ZW5rf.js
13675
+ // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.23_@vitest+ui@3.2.4_jiti@2.6.1_jsdom_dd8907bbeba1b9babb528cd8e0e32ee8/node_modules/vitest/dist/chunks/date.Bq6ZW5rf.js
13668
13676
  var RealDate = Date;
13669
13677
  var now2 = null;
13670
13678
  var MockDate = class _MockDate extends RealDate {
13671
- constructor(y, m2, d, h3, M, s2, ms) {
13679
+ constructor(y2, m2, d, h4, M2, s2, ms) {
13672
13680
  super();
13673
13681
  let date;
13674
13682
  switch (arguments.length) {
@@ -13677,15 +13685,15 @@ var MockDate = class _MockDate extends RealDate {
13677
13685
  else date = new RealDate();
13678
13686
  break;
13679
13687
  case 1:
13680
- date = new RealDate(y);
13688
+ date = new RealDate(y2);
13681
13689
  break;
13682
13690
  default:
13683
13691
  d = typeof d === "undefined" ? 1 : d;
13684
- h3 = h3 || 0;
13685
- M = M || 0;
13692
+ h4 = h4 || 0;
13693
+ M2 = M2 || 0;
13686
13694
  s2 = s2 || 0;
13687
13695
  ms = ms || 0;
13688
- date = new RealDate(y, m2, d, h3, M, s2, ms);
13696
+ date = new RealDate(y2, m2, d, h4, M2, s2, ms);
13689
13697
  break;
13690
13698
  }
13691
13699
  Object.setPrototypeOf(date, _MockDate.prototype);
@@ -13712,7 +13720,7 @@ function resetDate() {
13712
13720
  globalThis.Date = RealDate;
13713
13721
  }
13714
13722
 
13715
- // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.21_@vitest+ui@3.2.4_jiti@2.6.0_jsdom_57244f75a0f6ad2fb70ec052bfd7aeae/node_modules/vitest/dist/chunks/vi.bdSIJ99Y.js
13723
+ // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.23_@vitest+ui@3.2.4_jiti@2.6.1_jsdom_dd8907bbeba1b9babb528cd8e0e32ee8/node_modules/vitest/dist/chunks/vi.bdSIJ99Y.js
13716
13724
  var unsupported = [
13717
13725
  "matchSnapshot",
13718
13726
  "toMatchSnapshot",
@@ -14083,11 +14091,11 @@ function createExpect(test5) {
14083
14091
  const expect2 = (value, message) => {
14084
14092
  const { assertionCalls } = getState(expect2);
14085
14093
  setState({ assertionCalls: assertionCalls + 1 }, expect2);
14086
- const assert4 = expect(value, message);
14094
+ const assert3 = expect(value, message);
14087
14095
  const _test2 = test5 || getCurrentTest();
14088
14096
  if (_test2)
14089
- return assert4.withTest(_test2);
14090
- else return assert4;
14097
+ return assert3.withTest(_test2);
14098
+ else return assert3;
14091
14099
  };
14092
14100
  Object.assign(expect2, expect);
14093
14101
  Object.assign(expect2, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
@@ -14114,7 +14122,7 @@ function createExpect(test5) {
14114
14122
  };
14115
14123
  expect2.poll = createExpectPoll(expect2);
14116
14124
  expect2.unreachable = (message) => {
14117
- assert2.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
14125
+ assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
14118
14126
  };
14119
14127
  function assertions(expected) {
14120
14128
  const errorGen = () => new Error(`expected number of assertions to be ${expected}, but got ${expect2.getState().assertionCalls}`);
@@ -14233,10 +14241,10 @@ function requireCalledInOrder() {
14233
14241
  }
14234
14242
  return callMap[spy.id] < spy.callCount;
14235
14243
  }
14236
- function checkAdjacentCalls(callMap, spy, index2, spies2) {
14244
+ function checkAdjacentCalls(callMap, spy, index2, spies) {
14237
14245
  var calledBeforeNext = true;
14238
- if (index2 !== spies2.length - 1) {
14239
- calledBeforeNext = spy.calledBefore(spies2[index2 + 1]);
14246
+ if (index2 !== spies.length - 1) {
14247
+ calledBeforeNext = spy.calledBefore(spies[index2 + 1]);
14240
14248
  }
14241
14249
  if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
14242
14250
  callMap[spy.id] += 1;
@@ -14244,9 +14252,9 @@ function requireCalledInOrder() {
14244
14252
  }
14245
14253
  return false;
14246
14254
  }
14247
- function calledInOrder(spies2) {
14255
+ function calledInOrder(spies) {
14248
14256
  var callMap = {};
14249
- var _spies = arguments.length > 1 ? arguments : spies2;
14257
+ var _spies = arguments.length > 1 ? arguments : spies;
14250
14258
  return every2(_spies, checkAdjacentCalls.bind(null, callMap));
14251
14259
  }
14252
14260
  calledInOrder_1 = calledInOrder;
@@ -14343,15 +14351,15 @@ function requireOrderByFirstCall() {
14343
14351
  hasRequiredOrderByFirstCall = 1;
14344
14352
  var sort2 = requireArray().sort;
14345
14353
  var slice = requireArray().slice;
14346
- function comparator(a3, b) {
14354
+ function comparator(a3, b2) {
14347
14355
  var aCall = a3.getCall(0);
14348
- var bCall = b.getCall(0);
14356
+ var bCall = b2.getCall(0);
14349
14357
  var aId = aCall && aCall.callId || -1;
14350
14358
  var bId = bCall && bCall.callId || -1;
14351
14359
  return aId < bId ? -1 : 1;
14352
14360
  }
14353
- function orderByFirstCall(spies2) {
14354
- return sort2(slice(spies2), comparator);
14361
+ function orderByFirstCall(spies) {
14362
+ return sort2(slice(spies), comparator);
14355
14363
  }
14356
14364
  orderByFirstCall_1 = orderByFirstCall;
14357
14365
  return orderByFirstCall_1;
@@ -14678,11 +14686,11 @@ function requireFakeTimersSrc() {
14678
14686
  return 0;
14679
14687
  }
14680
14688
  const strings = str.split(":");
14681
- const l = strings.length;
14682
- let i = l;
14689
+ const l2 = strings.length;
14690
+ let i = l2;
14683
14691
  let ms = 0;
14684
14692
  let parsed;
14685
- if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
14693
+ if (l2 > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
14686
14694
  throw new Error(
14687
14695
  "tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits"
14688
14696
  );
@@ -14692,7 +14700,7 @@ function requireFakeTimersSrc() {
14692
14700
  if (parsed >= 60) {
14693
14701
  throw new Error(`Invalid time ${str}`);
14694
14702
  }
14695
- ms += parsed * Math.pow(60, l - i - 1);
14703
+ ms += parsed * Math.pow(60, l2 - i - 1);
14696
14704
  }
14697
14705
  return ms * 1e3;
14698
14706
  }
@@ -14931,29 +14939,29 @@ ${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
14931
14939
  }
14932
14940
  return timer.id;
14933
14941
  }
14934
- function compareTimers(a3, b) {
14935
- if (a3.callAt < b.callAt) {
14942
+ function compareTimers(a3, b2) {
14943
+ if (a3.callAt < b2.callAt) {
14936
14944
  return -1;
14937
14945
  }
14938
- if (a3.callAt > b.callAt) {
14946
+ if (a3.callAt > b2.callAt) {
14939
14947
  return 1;
14940
14948
  }
14941
- if (a3.immediate && !b.immediate) {
14949
+ if (a3.immediate && !b2.immediate) {
14942
14950
  return -1;
14943
14951
  }
14944
- if (!a3.immediate && b.immediate) {
14952
+ if (!a3.immediate && b2.immediate) {
14945
14953
  return 1;
14946
14954
  }
14947
- if (a3.createdAt < b.createdAt) {
14955
+ if (a3.createdAt < b2.createdAt) {
14948
14956
  return -1;
14949
14957
  }
14950
- if (a3.createdAt > b.createdAt) {
14958
+ if (a3.createdAt > b2.createdAt) {
14951
14959
  return 1;
14952
14960
  }
14953
- if (a3.id < b.id) {
14961
+ if (a3.id < b2.id) {
14954
14962
  return -1;
14955
14963
  }
14956
- if (a3.id > b.id) {
14964
+ if (a3.id > b2.id) {
14957
14965
  return 1;
14958
14966
  }
14959
14967
  }
@@ -15064,10 +15072,10 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
15064
15072
  }
15065
15073
  }
15066
15074
  function uninstall(clock, config2) {
15067
- let method, i, l;
15075
+ let method, i, l2;
15068
15076
  const installedHrTime = "_hrtime";
15069
15077
  const installedNextTick = "_nextTick";
15070
- for (i = 0, l = clock.methods.length; i < l; i++) {
15078
+ for (i = 0, l2 = clock.methods.length; i < l2; i++) {
15071
15079
  method = clock.methods[i];
15072
15080
  if (method === "hrtime" && _global.process) {
15073
15081
  _global.process.hrtime = clock[installedHrTime];
@@ -15098,14 +15106,14 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
15098
15106
  }
15099
15107
  }
15100
15108
  if (clock.timersModuleMethods !== void 0) {
15101
- for (let j = 0; j < clock.timersModuleMethods.length; j++) {
15102
- const entry = clock.timersModuleMethods[j];
15109
+ for (let j2 = 0; j2 < clock.timersModuleMethods.length; j2++) {
15110
+ const entry = clock.timersModuleMethods[j2];
15103
15111
  timersModule[entry.methodName] = entry.original;
15104
15112
  }
15105
15113
  }
15106
15114
  if (clock.timersPromisesModuleMethods !== void 0) {
15107
- for (let j = 0; j < clock.timersPromisesModuleMethods.length; j++) {
15108
- const entry = clock.timersPromisesModuleMethods[j];
15115
+ for (let j2 = 0; j2 < clock.timersPromisesModuleMethods.length; j2++) {
15116
+ const entry = clock.timersPromisesModuleMethods[j2];
15109
15117
  timersPromisesModule[entry.methodName] = entry.original;
15110
15118
  }
15111
15119
  }
@@ -15610,7 +15618,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
15610
15618
  });
15611
15619
  };
15612
15620
  }
15613
- clock.reset = function reset2() {
15621
+ clock.reset = function reset() {
15614
15622
  nanos = 0;
15615
15623
  clock.timers = {};
15616
15624
  clock.jobs = [];
@@ -15681,7 +15689,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
15681
15689
  `non-existent timers and/or objects cannot be faked: '${timer}'`
15682
15690
  );
15683
15691
  }
15684
- let i, l;
15692
+ let i, l2;
15685
15693
  const clock = createClock(config2.now, config2.loopLimit);
15686
15694
  clock.shouldClearNativeTimers = config2.shouldClearNativeTimers;
15687
15695
  clock.uninstall = function() {
@@ -15732,7 +15740,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
15732
15740
  if (_global === globalObject && timersPromisesModule) {
15733
15741
  clock.timersPromisesModuleMethods = [];
15734
15742
  }
15735
- for (i = 0, l = clock.methods.length; i < l; i++) {
15743
+ for (i = 0, l2 = clock.methods.length; i < l2; i++) {
15736
15744
  const nameOfMethodToReplace = clock.methods[i];
15737
15745
  if (!isPresent[nameOfMethodToReplace]) {
15738
15746
  handleMissingTimer(nameOfMethodToReplace);
@@ -16317,7 +16325,7 @@ function createVitest() {
16317
16325
  return item;
16318
16326
  },
16319
16327
  isMockFunction(fn2) {
16320
- return isMockFunction2(fn2);
16328
+ return isMockFunction(fn2);
16321
16329
  },
16322
16330
  clearAllMocks() {
16323
16331
  [...mocks].reverse().forEach((spy) => spy.mockClear());
@@ -16398,7 +16406,7 @@ function getImporter(name) {
16398
16406
  return stack?.file || "";
16399
16407
  }
16400
16408
 
16401
- // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.21_@vitest+ui@3.2.4_jiti@2.6.0_jsdom_57244f75a0f6ad2fb70ec052bfd7aeae/node_modules/vitest/dist/chunks/benchmark.CYdenmiT.js
16409
+ // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.23_@vitest+ui@3.2.4_jiti@2.6.1_jsdom_dd8907bbeba1b9babb528cd8e0e32ee8/node_modules/vitest/dist/chunks/benchmark.CYdenmiT.js
16402
16410
  var benchFns = /* @__PURE__ */ new WeakMap();
16403
16411
  var benchOptsMap = /* @__PURE__ */ new WeakMap();
16404
16412
  var bench = createBenchmark(function(name, fn2 = noop, options = {}) {
@@ -16424,12 +16432,12 @@ function formatName2(name) {
16424
16432
  return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
16425
16433
  }
16426
16434
 
16427
- // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.21_@vitest+ui@3.2.4_jiti@2.6.0_jsdom_57244f75a0f6ad2fb70ec052bfd7aeae/node_modules/vitest/dist/chunks/index.CdQS2e2Q.js
16435
+ // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.23_@vitest+ui@3.2.4_jiti@2.6.1_jsdom_dd8907bbeba1b9babb528cd8e0e32ee8/node_modules/vitest/dist/chunks/index.CdQS2e2Q.js
16428
16436
  __toESM(require_dist(), 1);
16429
16437
  var assertType = function assertType2() {
16430
16438
  };
16431
16439
 
16432
- // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.21_@vitest+ui@3.2.4_jiti@2.6.0_jsdom_57244f75a0f6ad2fb70ec052bfd7aeae/node_modules/vitest/dist/index.js
16440
+ // ../../node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.23_@vitest+ui@3.2.4_jiti@2.6.1_jsdom_dd8907bbeba1b9babb528cd8e0e32ee8/node_modules/vitest/dist/index.js
16433
16441
  var import_expect_type2 = __toESM(require_dist(), 1);
16434
16442
  var export_expectTypeOf = import_expect_type2.expectTypeOf;
16435
16443
  /*! Bundled license information:
@@ -16472,7 +16480,7 @@ var export_expectTypeOf = import_expect_type2.expectTypeOf;
16472
16480
  * LICENSE file in the root directory of this source tree.
16473
16481
  *)
16474
16482
 
16475
- chai/chai.js:
16483
+ chai/index.js:
16476
16484
  (*!
16477
16485
  * Chai - flag utility
16478
16486
  * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
@@ -16724,6 +16732,6 @@ chai/chai.js:
16724
16732
  *)
16725
16733
  */
16726
16734
 
16727
- export { afterAll, afterEach, assert2 as assert, assertType, beforeAll, beforeEach, bench, chai_exports as chai, createExpect, describe, globalExpect as expect, export_expectTypeOf as expectTypeOf, inject, it, onTestFailed, onTestFinished, should, suite, test3 as test, vi, vitest };
16728
- //# sourceMappingURL=dist-E463LOAZ.js.map
16729
- //# sourceMappingURL=dist-E463LOAZ.js.map
16735
+ export { afterAll, afterEach, assert, assertType, beforeAll, beforeEach, bench, chai_exports as chai, createExpect, describe, globalExpect as expect, export_expectTypeOf as expectTypeOf, inject, it, onTestFailed, onTestFinished, should, suite, test3 as test, vi, vitest };
16736
+ //# sourceMappingURL=dist-OWYZEOJK.js.map
16737
+ //# sourceMappingURL=dist-OWYZEOJK.js.map