tutuca 0.9.43 → 0.9.45

package/dist/tutuca-cli.js

@@ -17,6 +17,3296 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// node_modules/chai/index.js
+function isErrorInstance(obj) {
+  return obj instanceof Error || Object.prototype.toString.call(obj) === "[object Error]";
+}
+function isRegExp(obj) {
+  return Object.prototype.toString.call(obj) === "[object RegExp]";
+}
+function compatibleInstance(thrown, errorLike) {
+  return isErrorInstance(errorLike) && thrown === errorLike;
+}
+function compatibleConstructor(thrown, errorLike) {
+  if (isErrorInstance(errorLike)) {
+    return thrown.constructor === errorLike.constructor || thrown instanceof errorLike.constructor;
+  } else if ((typeof errorLike === "object" || typeof errorLike === "function") && errorLike.prototype) {
+    return thrown.constructor === errorLike || thrown instanceof errorLike;
+  }
+  return false;
+}
+function compatibleMessage(thrown, errMatcher) {
+  const comparisonString = typeof thrown === "string" ? thrown : thrown.message;
+  if (isRegExp(errMatcher)) {
+    return errMatcher.test(comparisonString);
+  } else if (typeof errMatcher === "string") {
+    return comparisonString.indexOf(errMatcher) !== -1;
+  }
+  return false;
+}
+function getConstructorName(errorLike) {
+  let constructorName = errorLike;
+  if (isErrorInstance(errorLike)) {
+    constructorName = errorLike.constructor.name;
+  } else if (typeof errorLike === "function") {
+    constructorName = errorLike.name;
+    if (constructorName === "") {
+      const newConstructorName = new errorLike().name;
+      constructorName = newConstructorName || constructorName;
+    }
+  }
+  return constructorName;
+}
+function getMessage(errorLike) {
+  let msg = "";
+  if (errorLike && errorLike.message) {
+    msg = errorLike.message;
+  } else if (typeof errorLike === "string") {
+    msg = errorLike;
+  }
+  return msg;
+}
+function flag(obj, key, value) {
+  let flags = obj.__flags || (obj.__flags = /* @__PURE__ */ Object.create(null));
+  if (arguments.length === 3) {
+    flags[key] = value;
+  } else {
+    return flags[key];
+  }
+}
+function test(obj, args) {
+  let negate = flag(obj, "negate"), expr = args[0];
+  return negate ? !expr : expr;
+}
+function type(obj) {
+  if (typeof obj === "undefined") {
+    return "undefined";
+  }
+  if (obj === null) {
+    return "null";
+  }
+  const stringTag = obj[Symbol.toStringTag];
+  if (typeof stringTag === "string") {
+    return stringTag;
+  }
+  const type3 = Object.prototype.toString.call(obj).slice(8, -1);
+  return type3;
+}
+function expectTypes(obj, types) {
+  let flagMsg = flag(obj, "message");
+  let ssfi = flag(obj, "ssfi");
+  flagMsg = flagMsg ? flagMsg + ": " : "";
+  obj = flag(obj, "object");
+  types = types.map(function(t) {
+    return t.toLowerCase();
+  });
+  types.sort();
+  let str = types.map(function(t, index) {
+    let art = ~["a", "e", "i", "o", "u"].indexOf(t.charAt(0)) ? "an" : "a";
+    let or = types.length > 1 && index === types.length - 1 ? "or " : "";
+    return or + art + " " + t;
+  }).join(", ");
+  let objType = type(obj).toLowerCase();
+  if (!types.some(function(expected) {
+    return objType === expected;
+  })) {
+    throw new AssertionError(flagMsg + "object tested must be " + str + ", but " + objType + " given", undefined, ssfi);
+  }
+}
+function getActual(obj, args) {
+  return args.length > 4 ? args[4] : obj._obj;
+}
+function colorise(value, styleType) {
+  const color = ansiColors[styles[styleType]] || ansiColors[styleType] || "";
+  if (!color) {
+    return String(value);
+  }
+  return `\x1B[${color[0]}m${String(value)}\x1B[${color[1]}m`;
+}
+function normaliseOptions({
+  showHidden = false,
+  depth = 2,
+  colors = false,
+  customInspect = true,
+  showProxy = false,
+  maxArrayLength = Infinity,
+  breakLength = Infinity,
+  seen = [],
+  truncate: truncate2 = Infinity,
+  stylize = String
+} = {}, inspect3) {
+  const options = {
+    showHidden: Boolean(showHidden),
+    depth: Number(depth),
+    colors: Boolean(colors),
+    customInspect: Boolean(customInspect),
+    showProxy: Boolean(showProxy),
+    maxArrayLength: Number(maxArrayLength),
+    breakLength: Number(breakLength),
+    truncate: Number(truncate2),
+    seen,
+    inspect: inspect3,
+    stylize
+  };
+  if (options.colors) {
+    options.stylize = colorise;
+  }
+  return options;
+}
+function isHighSurrogate(char) {
+  return char >= "\uD800" && char <= "\uDBFF";
+}
+function truncate(string, length, tail = truncator) {
+  string = String(string);
+  const tailLength = tail.length;
+  const stringLength = string.length;
+  if (tailLength > length && stringLength > tailLength) {
+    return tail;
+  }
+  if (stringLength > length && stringLength > tailLength) {
+    let end = length - tailLength;
+    if (end > 0 && isHighSurrogate(string[end - 1])) {
+      end = end - 1;
+    }
+    return `${string.slice(0, end)}${tail}`;
+  }
+  return string;
+}
+function inspectList(list, options, inspectItem, separator = ", ") {
+  inspectItem = inspectItem || options.inspect;
+  const size = list.length;
+  if (size === 0)
+    return "";
+  const originalLength = options.truncate;
+  let output = "";
+  let peek = "";
+  let truncated = "";
+  for (let i = 0;i < size; i += 1) {
+    const last = i + 1 === list.length;
+    const secondToLast = i + 2 === list.length;
+    truncated = `${truncator}(${list.length - i})`;
+    const value = list[i];
+    options.truncate = originalLength - output.length - (last ? 0 : separator.length);
+    const string = peek || inspectItem(value, options) + (last ? "" : separator);
+    const nextLength = output.length + string.length;
+    const truncatedLength = nextLength + truncated.length;
+    if (last && nextLength > originalLength && output.length + truncated.length <= originalLength) {
+      break;
+    }
+    if (!last && !secondToLast && truncatedLength > originalLength) {
+      break;
+    }
+    peek = last ? "" : inspectItem(list[i + 1], options) + (secondToLast ? "" : separator);
+    if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) {
+      break;
+    }
+    output += string;
+    if (!last && !secondToLast && nextLength + peek.length >= originalLength) {
+      truncated = `${truncator}(${list.length - i - 1})`;
+      break;
+    }
+    truncated = "";
+  }
+  return `${output}${truncated}`;
+}
+function quoteComplexKey(key) {
+  if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) {
+    return key;
+  }
+  return JSON.stringify(key).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+}
+function inspectProperty([key, value], options) {
+  options.truncate -= 2;
+  if (typeof key === "string") {
+    key = quoteComplexKey(key);
+  } else if (typeof key !== "number") {
+    key = `[${options.inspect(key, options)}]`;
+  }
+  options.truncate -= key.length;
+  value = options.inspect(value, options);
+  return `${key}: ${value}`;
+}
+function inspectArray(array, options) {
+  const nonIndexProperties = Object.keys(array).slice(array.length);
+  if (!array.length && !nonIndexProperties.length)
+    return "[]";
+  options.truncate -= 4;
+  const listContents = inspectList(array, options);
+  options.truncate -= listContents.length;
+  let propertyContents = "";
+  if (nonIndexProperties.length) {
+    propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty);
+  }
+  return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+}
+function inspectTypedArray(array, options) {
+  const name = getArrayName(array);
+  options.truncate -= name.length + 4;
+  const nonIndexProperties = Object.keys(array).slice(array.length);
+  if (!array.length && !nonIndexProperties.length)
+    return `${name}[]`;
+  let output = "";
+  for (let i = 0;i < array.length; i++) {
+    const string = `${options.stylize(truncate(array[i], options.truncate), "number")}${i === array.length - 1 ? "" : ", "}`;
+    options.truncate -= string.length;
+    if (array[i] !== array.length && options.truncate <= 3) {
+      output += `${truncator}(${array.length - array[i] + 1})`;
+      break;
+    }
+    output += string;
+  }
+  let propertyContents = "";
+  if (nonIndexProperties.length) {
+    propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty);
+  }
+  return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+}
+function inspectDate(dateObject, options) {
+  const stringRepresentation = dateObject.toJSON();
+  if (stringRepresentation === null) {
+    return "Invalid Date";
+  }
+  const split = stringRepresentation.split("T");
+  const date = split[0];
+  return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, "date");
+}
+function inspectFunction(func, options) {
+  const functionType = func[Symbol.toStringTag] || "Function";
+  const name = func.name;
+  if (!name) {
+    return options.stylize(`[${functionType}]`, "special");
+  }
+  return options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, "special");
+}
+function inspectMapEntry([key, value], options) {
+  options.truncate -= 4;
+  key = options.inspect(key, options);
+  options.truncate -= key.length;
+  value = options.inspect(value, options);
+  return `${key} => ${value}`;
+}
+function mapToEntries(map) {
+  const entries = [];
+  map.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+}
+function inspectMap(map, options) {
+  if (map.size === 0)
+    return "Map{}";
+  options.truncate -= 7;
+  return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`;
+}
+function inspectNumber(number, options) {
+  if (isNaN(number)) {
+    return options.stylize("NaN", "number");
+  }
+  if (number === Infinity) {
+    return options.stylize("Infinity", "number");
+  }
+  if (number === -Infinity) {
+    return options.stylize("-Infinity", "number");
+  }
+  if (number === 0) {
+    return options.stylize(1 / number === Infinity ? "+0" : "-0", "number");
+  }
+  return options.stylize(truncate(String(number), options.truncate), "number");
+}
+function inspectBigInt(number, options) {
+  let nums = truncate(number.toString(), options.truncate - 1);
+  if (nums !== truncator)
+    nums += "n";
+  return options.stylize(nums, "bigint");
+}
+function inspectRegExp(value, options) {
+  const flags = value.toString().split("/")[2];
+  const sourceLength = options.truncate - (2 + flags.length);
+  const source = value.source;
+  return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, "regexp");
+}
+function arrayFromSet(set2) {
+  const values = [];
+  set2.forEach((value) => {
+    values.push(value);
+  });
+  return values;
+}
+function inspectSet(set2, options) {
+  if (set2.size === 0)
+    return "Set{}";
+  options.truncate -= 7;
+  return `Set{ ${inspectList(arrayFromSet(set2), options)} }`;
+}
+function escape(char) {
+  return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-unicodeLength)}`;
+}
+function inspectString(string, options) {
+  if (stringEscapeChars.test(string)) {
+    string = string.replace(stringEscapeChars, escape);
+  }
+  return options.stylize(`'${truncate(string, options.truncate - 2)}'`, "string");
+}
+function inspectSymbol(value) {
+  if ("description" in Symbol.prototype) {
+    return value.description ? `Symbol(${value.description})` : "Symbol()";
+  }
+  return value.toString();
+}
+function inspectObject(object, options) {
+  const properties = Object.getOwnPropertyNames(object);
+  const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [];
+  if (properties.length === 0 && symbols.length === 0) {
+    return "{}";
+  }
+  options.truncate -= 4;
+  options.seen = options.seen || [];
+  if (options.seen.includes(object)) {
+    return "[Circular]";
+  }
+  options.seen.push(object);
+  const propertyContents = inspectList(properties.map((key) => [key, object[key]]), options, inspectProperty);
+  const symbolContents = inspectList(symbols.map((key) => [key, object[key]]), options, inspectProperty);
+  options.seen.pop();
+  let sep = "";
+  if (propertyContents && symbolContents) {
+    sep = ", ";
+  }
+  return `{ ${propertyContents}${sep}${symbolContents} }`;
+}
+function inspectClass(value, options) {
+  let name = "";
+  if (toStringTag && toStringTag in value) {
+    name = value[toStringTag];
+  }
+  name = name || value.constructor.name;
+  if (!name || name === "_class") {
+    name = "<Anonymous Class>";
+  }
+  options.truncate -= name.length;
+  return `${name}${inspectObject(value, options)}`;
+}
+function inspectArguments(args, options) {
+  if (args.length === 0)
+    return "Arguments[]";
+  options.truncate -= 13;
+  return `Arguments[ ${inspectList(args, options)} ]`;
+}
+function inspectObject2(error, options) {
+  const properties = Object.getOwnPropertyNames(error).filter((key) => errorKeys.indexOf(key) === -1);
+  const name = error.name;
+  options.truncate -= name.length;
+  let message = "";
+  if (typeof error.message === "string") {
+    message = truncate(error.message, options.truncate);
+  } else {
+    properties.unshift("message");
+  }
+  message = message ? `: ${message}` : "";
+  options.truncate -= message.length + 5;
+  options.seen = options.seen || [];
+  if (options.seen.includes(error)) {
+    return "[Circular]";
+  }
+  options.seen.push(error);
+  const propertyContents = inspectList(properties.map((key) => [key, error[key]]), options, inspectProperty);
+  return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ""}`;
+}
+function inspectAttribute([key, value], options) {
+  options.truncate -= 3;
+  if (!value) {
+    return `${options.stylize(String(key), "yellow")}`;
+  }
+  return `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}`;
+}
+function inspectNodeCollection(collection, options) {
+  return inspectList(collection, options, inspectNode, `
+`);
+}
+function inspectNode(node, options) {
+  switch (node.nodeType) {
+    case 1:
+      return inspectHTML(node, options);
+    case 3:
+      return options.inspect(node.data, options);
+    default:
+      return options.inspect(node, options);
+  }
+}
+function inspectHTML(element, options) {
+  const properties = element.getAttributeNames();
+  const name = element.tagName.toLowerCase();
+  const head = options.stylize(`<${name}`, "special");
+  const headClose = options.stylize(`>`, "special");
+  const tail = options.stylize(`</${name}>`, "special");
+  options.truncate -= name.length * 2 + 5;
+  let propertyContents = "";
+  if (properties.length > 0) {
+    propertyContents += " ";
+    propertyContents += inspectList(properties.map((key) => [key, element.getAttribute(key)]), options, inspectAttribute, " ");
+  }
+  options.truncate -= propertyContents.length;
+  const truncate2 = options.truncate;
+  let children = inspectNodeCollection(element.children, options);
+  if (children && children.length > truncate2) {
+    children = `${truncator}(${element.children.length})`;
+  }
+  return `${head}${propertyContents}${headClose}${children}${tail}`;
+}
+function inspect(value, opts = {}) {
+  const options = normaliseOptions(opts, inspect);
+  const { customInspect } = options;
+  let type3 = value === null ? "null" : typeof value;
+  if (type3 === "object") {
+    type3 = toString.call(value).slice(8, -1);
+  }
+  if (type3 in baseTypesMap) {
+    return baseTypesMap[type3](value, options);
+  }
+  if (customInspect && value) {
+    const output = inspectCustom(value, options, type3, inspect);
+    if (output) {
+      if (typeof output === "string")
+        return output;
+      return inspect(output, options);
+    }
+  }
+  const proto = value ? Object.getPrototypeOf(value) : false;
+  if (proto === Object.prototype || proto === null) {
+    return inspectObject(value, options);
+  }
+  if (value && typeof HTMLElement === "function" && value instanceof HTMLElement) {
+    return inspectHTML(value, options);
+  }
+  if ("constructor" in value) {
+    if (value.constructor !== Object) {
+      return inspectClass(value, options);
+    }
+    return inspectObject(value, options);
+  }
+  if (value === Object(value)) {
+    return inspectObject(value, options);
+  }
+  return options.stylize(String(value), type3);
+}
+function inspect2(obj, showHidden, depth, colors) {
+  let options = {
+    colors,
+    depth: typeof depth === "undefined" ? 2 : depth,
+    showHidden,
+    truncate: config.truncateThreshold ? config.truncateThreshold : Infinity
+  };
+  return inspect(obj, options);
+}
+function objDisplay(obj) {
+  let str = inspect2(obj), type3 = Object.prototype.toString.call(obj);
+  if (config.truncateThreshold && str.length >= config.truncateThreshold) {
+    if (type3 === "[object Function]") {
+      return !obj.name || obj.name === "" ? "[Function]" : "[Function: " + obj.name + "]";
+    } else if (type3 === "[object Array]") {
+      return "[ Array(" + obj.length + ") ]";
+    } else if (type3 === "[object Object]") {
+      let keys = Object.keys(obj), kstr = keys.length > 2 ? keys.splice(0, 2).join(", ") + ", ..." : keys.join(", ");
+      return "{ Object (" + kstr + ") }";
+    } else {
+      return str;
+    }
+  } else {
+    return str;
+  }
+}
+function getMessage2(obj, args) {
+  let negate = flag(obj, "negate");
+  let val = flag(obj, "object");
+  let expected = args[3];
+  let actual = getActual(obj, args);
+  let msg = negate ? args[2] : args[1];
+  let flagMsg = flag(obj, "message");
+  if (typeof msg === "function")
+    msg = msg();
+  msg = msg || "";
+  msg = msg.replace(/#\{this\}/g, function() {
+    return objDisplay(val);
+  }).replace(/#\{act\}/g, function() {
+    return objDisplay(actual);
+  }).replace(/#\{exp\}/g, function() {
+    return objDisplay(expected);
+  });
+  return flagMsg ? flagMsg + ": " + msg : msg;
+}
+function transferFlags(assertion, object, includeAll) {
+  let flags = assertion.__flags || (assertion.__flags = /* @__PURE__ */ Object.create(null));
+  if (!object.__flags) {
+    object.__flags = /* @__PURE__ */ Object.create(null);
+  }
+  includeAll = arguments.length === 3 ? includeAll : true;
+  for (let flag3 in flags) {
+    if (includeAll || flag3 !== "object" && flag3 !== "ssfi" && flag3 !== "lockSsfi" && flag3 != "message") {
+      object.__flags[flag3] = flags[flag3];
+    }
+  }
+}
+function type2(obj) {
+  if (typeof obj === "undefined") {
+    return "undefined";
+  }
+  if (obj === null) {
+    return "null";
+  }
+  const stringTag = obj[Symbol.toStringTag];
+  if (typeof stringTag === "string") {
+    return stringTag;
+  }
+  const sliceStart = 8;
+  const sliceEnd = -1;
+  return Object.prototype.toString.call(obj).slice(sliceStart, sliceEnd);
+}
+function FakeMap() {
+  this._key = "chai/deep-eql__" + Math.random() + Date.now();
+}
+function memoizeCompare(leftHandOperand, rightHandOperand, memoizeMap) {
+  if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {
+    return null;
+  }
+  var leftHandMap = memoizeMap.get(leftHandOperand);
+  if (leftHandMap) {
+    var result = leftHandMap.get(rightHandOperand);
+    if (typeof result === "boolean") {
+      return result;
+    }
+  }
+  return null;
+}
+function memoizeSet(leftHandOperand, rightHandOperand, memoizeMap, result) {
+  if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {
+    return;
+  }
+  var leftHandMap = memoizeMap.get(leftHandOperand);
+  if (leftHandMap) {
+    leftHandMap.set(rightHandOperand, result);
+  } else {
+    leftHandMap = new MemoizeMap;
+    leftHandMap.set(rightHandOperand, result);
+    memoizeMap.set(leftHandOperand, leftHandMap);
+  }
+}
+function deepEqual(leftHandOperand, rightHandOperand, options) {
+  if (options && options.comparator) {
+    return extensiveDeepEqual(leftHandOperand, rightHandOperand, options);
+  }
+  var simpleResult = simpleEqual(leftHandOperand, rightHandOperand);
+  if (simpleResult !== null) {
+    return simpleResult;
+  }
+  return extensiveDeepEqual(leftHandOperand, rightHandOperand, options);
+}
+function simpleEqual(leftHandOperand, rightHandOperand) {
+  if (leftHandOperand === rightHandOperand) {
+    return leftHandOperand !== 0 || 1 / leftHandOperand === 1 / rightHandOperand;
+  }
+  if (leftHandOperand !== leftHandOperand && rightHandOperand !== rightHandOperand) {
+    return true;
+  }
+  if (isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {
+    return false;
+  }
+  return null;
+}
+function extensiveDeepEqual(leftHandOperand, rightHandOperand, options) {
+  options = options || {};
+  options.memoize = options.memoize === false ? false : options.memoize || new MemoizeMap;
+  var comparator = options && options.comparator;
+  var memoizeResultLeft = memoizeCompare(leftHandOperand, rightHandOperand, options.memoize);
+  if (memoizeResultLeft !== null) {
+    return memoizeResultLeft;
+  }
+  var memoizeResultRight = memoizeCompare(rightHandOperand, leftHandOperand, options.memoize);
+  if (memoizeResultRight !== null) {
+    return memoizeResultRight;
+  }
+  if (comparator) {
+    var comparatorResult = comparator(leftHandOperand, rightHandOperand);
+    if (comparatorResult === false || comparatorResult === true) {
+      memoizeSet(leftHandOperand, rightHandOperand, options.memoize, comparatorResult);
+      return comparatorResult;
+    }
+    var simpleResult = simpleEqual(leftHandOperand, rightHandOperand);
+    if (simpleResult !== null) {
+      return simpleResult;
+    }
+  }
+  var leftHandType = type2(leftHandOperand);
+  if (leftHandType !== type2(rightHandOperand)) {
+    memoizeSet(leftHandOperand, rightHandOperand, options.memoize, false);
+    return false;
+  }
+  memoizeSet(leftHandOperand, rightHandOperand, options.memoize, true);
+  var result = extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options);
+  memoizeSet(leftHandOperand, rightHandOperand, options.memoize, result);
+  return result;
+}
+function extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options) {
+  switch (leftHandType) {
+    case "String":
+    case "Number":
+    case "Boolean":
+    case "Date":
+      return deepEqual(leftHandOperand.valueOf(), rightHandOperand.valueOf());
+    case "Promise":
+    case "Symbol":
+    case "function":
+    case "WeakMap":
+    case "WeakSet":
+      return leftHandOperand === rightHandOperand;
+    case "Error":
+      return keysEqual(leftHandOperand, rightHandOperand, ["name", "message", "code"], options);
+    case "Arguments":
+    case "Int8Array":
+    case "Uint8Array":
+    case "Uint8ClampedArray":
+    case "Int16Array":
+    case "Uint16Array":
+    case "Int32Array":
+    case "Uint32Array":
+    case "Float32Array":
+    case "Float64Array":
+    case "Array":
+      return iterableEqual(leftHandOperand, rightHandOperand, options);
+    case "RegExp":
+      return regexpEqual(leftHandOperand, rightHandOperand);
+    case "Generator":
+      return generatorEqual(leftHandOperand, rightHandOperand, options);
+    case "DataView":
+      return iterableEqual(new Uint8Array(leftHandOperand.buffer), new Uint8Array(rightHandOperand.buffer), options);
+    case "ArrayBuffer":
+      return iterableEqual(new Uint8Array(leftHandOperand), new Uint8Array(rightHandOperand), options);
+    case "Set":
+      return entriesEqual(leftHandOperand, rightHandOperand, options);
+    case "Map":
+      return entriesEqual(leftHandOperand, rightHandOperand, options);
+    case "Temporal.PlainDate":
+    case "Temporal.PlainTime":
+    case "Temporal.PlainDateTime":
+    case "Temporal.Instant":
+    case "Temporal.ZonedDateTime":
+    case "Temporal.PlainYearMonth":
+    case "Temporal.PlainMonthDay":
+      return leftHandOperand.equals(rightHandOperand);
+    case "Temporal.Duration":
+      return leftHandOperand.total("nanoseconds") === rightHandOperand.total("nanoseconds");
+    case "Temporal.TimeZone":
+    case "Temporal.Calendar":
+      return leftHandOperand.toString() === rightHandOperand.toString();
+    default:
+      return objectEqual(leftHandOperand, rightHandOperand, options);
+  }
+}
+function regexpEqual(leftHandOperand, rightHandOperand) {
+  return leftHandOperand.toString() === rightHandOperand.toString();
+}
+function entriesEqual(leftHandOperand, rightHandOperand, options) {
+  try {
+    if (leftHandOperand.size !== rightHandOperand.size) {
+      return false;
+    }
+    if (leftHandOperand.size === 0) {
+      return true;
+    }
+  } catch (sizeError) {
+    return false;
+  }
+  var leftHandItems = [];
+  var rightHandItems = [];
+  leftHandOperand.forEach(/* @__PURE__ */ __name(function gatherEntries(key, value) {
+    leftHandItems.push([key, value]);
+  }, "gatherEntries"));
+  rightHandOperand.forEach(/* @__PURE__ */ __name(function gatherEntries(key, value) {
+    rightHandItems.push([key, value]);
+  }, "gatherEntries"));
+  return iterableEqual(leftHandItems.sort(), rightHandItems.sort(), options);
+}
+function iterableEqual(leftHandOperand, rightHandOperand, options) {
+  var length = leftHandOperand.length;
+  if (length !== rightHandOperand.length) {
+    return false;
+  }
+  if (length === 0) {
+    return true;
+  }
+  var index = -1;
+  while (++index < length) {
+    if (deepEqual(leftHandOperand[index], rightHandOperand[index], options) === false) {
+      return false;
+    }
+  }
+  return true;
+}
+function generatorEqual(leftHandOperand, rightHandOperand, options) {
+  return iterableEqual(getGeneratorEntries(leftHandOperand), getGeneratorEntries(rightHandOperand), options);
+}
+function hasIteratorFunction(target) {
+  return typeof Symbol !== "undefined" && typeof target === "object" && typeof Symbol.iterator !== "undefined" && typeof target[Symbol.iterator] === "function";
+}
+function getIteratorEntries(target) {
+  if (hasIteratorFunction(target)) {
+    try {
+      return getGeneratorEntries(target[Symbol.iterator]());
+    } catch (iteratorError) {
+      return [];
+    }
+  }
+  return [];
+}
+function getGeneratorEntries(generator) {
+  var generatorResult = generator.next();
+  var accumulator = [generatorResult.value];
+  while (generatorResult.done === false) {
+    generatorResult = generator.next();
+    accumulator.push(generatorResult.value);
+  }
+  return accumulator;
+}
+function getEnumerableKeys(target) {
+  var keys = [];
+  for (var key in target) {
+    keys.push(key);
+  }
+  return keys;
+}
+function getEnumerableSymbols(target) {
+  var keys = [];
+  var allKeys = Object.getOwnPropertySymbols(target);
+  for (var i = 0;i < allKeys.length; i += 1) {
+    var key = allKeys[i];
+    if (Object.getOwnPropertyDescriptor(target, key).enumerable) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+function keysEqual(leftHandOperand, rightHandOperand, keys, options) {
+  var length = keys.length;
+  if (length === 0) {
+    return true;
+  }
+  for (var i = 0;i < length; i += 1) {
+    if (deepEqual(leftHandOperand[keys[i]], rightHandOperand[keys[i]], options) === false) {
+      return false;
+    }
+  }
+  return true;
+}
+function objectEqual(leftHandOperand, rightHandOperand, options) {
+  var leftHandKeys = getEnumerableKeys(leftHandOperand);
+  var rightHandKeys = getEnumerableKeys(rightHandOperand);
+  var leftHandSymbols = getEnumerableSymbols(leftHandOperand);
+  var rightHandSymbols = getEnumerableSymbols(rightHandOperand);
+  leftHandKeys = leftHandKeys.concat(leftHandSymbols);
+  rightHandKeys = rightHandKeys.concat(rightHandSymbols);
+  if (leftHandKeys.length && leftHandKeys.length === rightHandKeys.length) {
+    if (iterableEqual(mapSymbols(leftHandKeys).sort(), mapSymbols(rightHandKeys).sort()) === false) {
+      return false;
+    }
+    return keysEqual(leftHandOperand, rightHandOperand, leftHandKeys, options);
+  }
+  var leftHandEntries = getIteratorEntries(leftHandOperand);
+  var rightHandEntries = getIteratorEntries(rightHandOperand);
+  if (leftHandEntries.length && leftHandEntries.length === rightHandEntries.length) {
+    leftHandEntries.sort();
+    rightHandEntries.sort();
+    return iterableEqual(leftHandEntries, rightHandEntries, options);
+  }
+  if (leftHandKeys.length === 0 && leftHandEntries.length === 0 && rightHandKeys.length === 0 && rightHandEntries.length === 0) {
+    return true;
+  }
+  return false;
+}
+function isPrimitive(value) {
+  return value === null || typeof value !== "object";
+}
+function mapSymbols(arr) {
+  return arr.map(/* @__PURE__ */ __name(function mapSymbol(entry) {
+    if (typeof entry === "symbol") {
+      return entry.toString();
+    }
+    return entry;
+  }, "mapSymbol"));
+}
+function hasProperty(obj, name) {
+  if (typeof obj === "undefined" || obj === null) {
+    return false;
+  }
+  return name in Object(obj);
+}
+function parsePath(path) {
+  const str = path.replace(/([^\\])\[/g, "$1.[");
+  const parts = str.match(/(\\\.|[^.]+?)+/g);
+  return parts.map((value) => {
+    if (value === "constructor" || value === "__proto__" || value === "prototype") {
+      return {};
+    }
+    const regexp = /^\[(\d+)\]$/;
+    const mArr = regexp.exec(value);
+    let parsed = null;
+    if (mArr) {
+      parsed = { i: parseFloat(mArr[1]) };
+    } else {
+      parsed = { p: value.replace(/\\([.[\]])/g, "$1") };
+    }
+    return parsed;
+  });
+}
+function internalGetPathValue(obj, parsed, pathDepth) {
+  let temporaryValue = obj;
+  let res = null;
+  pathDepth = typeof pathDepth === "undefined" ? parsed.length : pathDepth;
+  for (let i = 0;i < pathDepth; i++) {
+    const part = parsed[i];
+    if (temporaryValue) {
+      if (typeof part.p === "undefined") {
+        temporaryValue = temporaryValue[part.i];
+      } else {
+        temporaryValue = temporaryValue[part.p];
+      }
+      if (i === pathDepth - 1) {
+        res = temporaryValue;
+      }
+    }
+  }
+  return res;
+}
+function getPathInfo(obj, path) {
+  const parsed = parsePath(path);
+  const last = parsed[parsed.length - 1];
+  const info = {
+    parent: parsed.length > 1 ? internalGetPathValue(obj, parsed, parsed.length - 1) : obj,
+    name: last.p || last.i,
+    value: internalGetPathValue(obj, parsed)
+  };
+  info.exists = hasProperty(info.parent, info.name);
+  return info;
+}
+function isProxyEnabled() {
+  return config.useProxy && typeof Proxy !== "undefined" && typeof Reflect !== "undefined";
+}
+function addProperty(ctx, name, getter) {
+  getter = getter === undefined ? function() {} : getter;
+  Object.defineProperty(ctx, name, {
+    get: /* @__PURE__ */ __name(function propertyGetter() {
+      if (!isProxyEnabled() && !flag(this, "lockSsfi")) {
+        flag(this, "ssfi", propertyGetter);
+      }
+      let result = getter.call(this);
+      if (result !== undefined)
+        return result;
+      let newAssertion = new Assertion;
+      transferFlags(this, newAssertion);
+      return newAssertion;
+    }, "propertyGetter"),
+    configurable: true
+  });
+  events.dispatchEvent(new PluginEvent("addProperty", name, getter));
+}
+function addLengthGuard(fn, assertionName, isChainable) {
+  if (!fnLengthDesc.configurable)
+    return fn;
+  Object.defineProperty(fn, "length", {
+    get: /* @__PURE__ */ __name(function() {
+      if (isChainable) {
+        throw Error("Invalid Chai property: " + assertionName + '.length. Due to a compatibility issue, "length" cannot directly follow "' + assertionName + '". Use "' + assertionName + '.lengthOf" instead.');
+      }
+      throw Error("Invalid Chai property: " + assertionName + '.length. See docs for proper usage of "' + assertionName + '".');
+    }, "get")
+  });
+  return fn;
+}
+function getProperties(object) {
+  let result = Object.getOwnPropertyNames(object);
+  function addProperty2(property) {
+    if (result.indexOf(property) === -1) {
+      result.push(property);
+    }
+  }
+  __name(addProperty2, "addProperty");
+  let proto = Object.getPrototypeOf(object);
+  while (proto !== null) {
+    Object.getOwnPropertyNames(proto).forEach(addProperty2);
+    proto = Object.getPrototypeOf(proto);
+  }
+  return result;
+}
+function proxify(obj, nonChainableMethodName) {
+  if (!isProxyEnabled())
+    return obj;
+  return new Proxy(obj, {
+    get: /* @__PURE__ */ __name(function proxyGetter(target, property) {
+      if (typeof property === "string" && config.proxyExcludedKeys.indexOf(property) === -1 && !Reflect.has(target, property)) {
+        if (nonChainableMethodName) {
+          throw Error("Invalid Chai property: " + nonChainableMethodName + "." + property + '. See docs for proper usage of "' + nonChainableMethodName + '".');
+        }
+        let suggestion = null;
+        let suggestionDistance = 4;
+        getProperties(target).forEach(function(prop) {
+          if (!Object.prototype.hasOwnProperty(prop) && builtins.indexOf(prop) === -1) {
+            let dist = stringDistanceCapped(property, prop, suggestionDistance);
+            if (dist < suggestionDistance) {
+              suggestion = prop;
+              suggestionDistance = dist;
+            }
+          }
+        });
+        if (suggestion !== null) {
+          throw Error("Invalid Chai property: " + property + '. Did you mean "' + suggestion + '"?');
+        } else {
+          throw Error("Invalid Chai property: " + property);
+        }
+      }
+      if (builtins.indexOf(property) === -1 && !flag(target, "lockSsfi")) {
+        flag(target, "ssfi", proxyGetter);
+      }
+      return Reflect.get(target, property);
+    }, "proxyGetter")
+  });
+}
+function stringDistanceCapped(strA, strB, cap) {
+  if (Math.abs(strA.length - strB.length) >= cap) {
+    return cap;
+  }
+  let memo = [];
+  for (let i = 0;i <= strA.length; i++) {
+    memo[i] = Array(strB.length + 1).fill(0);
+    memo[i][0] = i;
+  }
+  for (let j = 0;j < strB.length; j++) {
+    memo[0][j] = j;
+  }
+  for (let i = 1;i <= strA.length; i++) {
+    let ch = strA.charCodeAt(i - 1);
+    for (let j = 1;j <= strB.length; j++) {
+      if (Math.abs(i - j) >= cap) {
+        memo[i][j] = cap;
+        continue;
+      }
+      memo[i][j] = Math.min(memo[i - 1][j] + 1, memo[i][j - 1] + 1, memo[i - 1][j - 1] + (ch === strB.charCodeAt(j - 1) ? 0 : 1));
+    }
+  }
+  return memo[strA.length][strB.length];
+}
+function addMethod(ctx, name, method) {
+  let methodWrapper = /* @__PURE__ */ __name(function() {
+    if (!flag(this, "lockSsfi")) {
+      flag(this, "ssfi", methodWrapper);
+    }
+    let result = method.apply(this, arguments);
+    if (result !== undefined)
+      return result;
+    let newAssertion = new Assertion;
+    transferFlags(this, newAssertion);
+    return newAssertion;
+  }, "methodWrapper");
+  addLengthGuard(methodWrapper, name, false);
+  ctx[name] = proxify(methodWrapper, name);
+  events.dispatchEvent(new PluginEvent("addMethod", name, method));
+}
+function overwriteProperty(ctx, name, getter) {
+  let _get = Object.getOwnPropertyDescriptor(ctx, name), _super = /* @__PURE__ */ __name(function() {}, "_super");
+  if (_get && typeof _get.get === "function")
+    _super = _get.get;
+  Object.defineProperty(ctx, name, {
+    get: /* @__PURE__ */ __name(function overwritingPropertyGetter() {
+      if (!isProxyEnabled() && !flag(this, "lockSsfi")) {
+        flag(this, "ssfi", overwritingPropertyGetter);
+      }
+      let origLockSsfi = flag(this, "lockSsfi");
+      flag(this, "lockSsfi", true);
+      let result = getter(_super).call(this);
+      flag(this, "lockSsfi", origLockSsfi);
+      if (result !== undefined) {
+        return result;
+      }
+      let newAssertion = new Assertion;
+      transferFlags(this, newAssertion);
+      return newAssertion;
+    }, "overwritingPropertyGetter"),
+    configurable: true
+  });
+}
+function overwriteMethod(ctx, name, method) {
+  let _method = ctx[name], _super = /* @__PURE__ */ __name(function() {
+    throw new Error(name + " is not a function");
+  }, "_super");
+  if (_method && typeof _method === "function")
+    _super = _method;
+  let overwritingMethodWrapper = /* @__PURE__ */ __name(function() {
+    if (!flag(this, "lockSsfi")) {
+      flag(this, "ssfi", overwritingMethodWrapper);
+    }
+    let origLockSsfi = flag(this, "lockSsfi");
+    flag(this, "lockSsfi", true);
+    let result = method(_super).apply(this, arguments);
+    flag(this, "lockSsfi", origLockSsfi);
+    if (result !== undefined) {
+      return result;
+    }
+    let newAssertion = new Assertion;
+    transferFlags(this, newAssertion);
+    return newAssertion;
+  }, "overwritingMethodWrapper");
+  addLengthGuard(overwritingMethodWrapper, name, false);
+  ctx[name] = proxify(overwritingMethodWrapper, name);
+}
+function addChainableMethod(ctx, name, method, chainingBehavior) {
+  if (typeof chainingBehavior !== "function") {
+    chainingBehavior = /* @__PURE__ */ __name(function() {}, "chainingBehavior");
+  }
+  let chainableBehavior = {
+    method,
+    chainingBehavior
+  };
+  if (!ctx.__methods) {
+    ctx.__methods = {};
+  }
+  ctx.__methods[name] = chainableBehavior;
+  Object.defineProperty(ctx, name, {
+    get: /* @__PURE__ */ __name(function chainableMethodGetter() {
+      chainableBehavior.chainingBehavior.call(this);
+      let chainableMethodWrapper = /* @__PURE__ */ __name(function() {
+        if (!flag(this, "lockSsfi")) {
+          flag(this, "ssfi", chainableMethodWrapper);
+        }
+        let result = chainableBehavior.method.apply(this, arguments);
+        if (result !== undefined) {
+          return result;
+        }
+        let newAssertion = new Assertion;
+        transferFlags(this, newAssertion);
+        return newAssertion;
+      }, "chainableMethodWrapper");
+      addLengthGuard(chainableMethodWrapper, name, true);
+      if (canSetPrototype) {
+        let prototype = Object.create(this);
+        prototype.call = call;
+        prototype.apply = apply;
+        Object.setPrototypeOf(chainableMethodWrapper, prototype);
+      } else {
+        let asserterNames = Object.getOwnPropertyNames(ctx);
+        asserterNames.forEach(function(asserterName) {
+          if (excludeNames.indexOf(asserterName) !== -1) {
+            return;
+          }
+          let pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
+          Object.defineProperty(chainableMethodWrapper, asserterName, pd);
+        });
+      }
+      transferFlags(this, chainableMethodWrapper);
+      return proxify(chainableMethodWrapper);
+    }, "chainableMethodGetter"),
+    configurable: true
+  });
+  events.dispatchEvent(new PluginAddChainableMethodEvent("addChainableMethod", name, method, chainingBehavior));
+}
+function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
+  let chainableBehavior = ctx.__methods[name];
+  let _chainingBehavior = chainableBehavior.chainingBehavior;
+  chainableBehavior.chainingBehavior = /* @__PURE__ */ __name(function overwritingChainableMethodGetter() {
+    let result = chainingBehavior(_chainingBehavior).call(this);
+    if (result !== undefined) {
+      return result;
+    }
+    let newAssertion = new Assertion;
+    transferFlags(this, newAssertion);
+    return newAssertion;
+  }, "overwritingChainableMethodGetter");
+  let _method = chainableBehavior.method;
+  chainableBehavior.method = /* @__PURE__ */ __name(function overwritingChainableMethodWrapper() {
+    let result = method(_method).apply(this, arguments);
+    if (result !== undefined) {
+      return result;
+    }
+    let newAssertion = new Assertion;
+    transferFlags(this, newAssertion);
+    return newAssertion;
+  }, "overwritingChainableMethodWrapper");
+}
+function compareByInspect(a, b) {
+  return inspect2(a) < inspect2(b) ? -1 : 1;
+}
+function getOwnEnumerablePropertySymbols(obj) {
+  if (typeof Object.getOwnPropertySymbols !== "function")
+    return [];
+  return Object.getOwnPropertySymbols(obj).filter(function(sym) {
+    return Object.getOwnPropertyDescriptor(obj, sym).enumerable;
+  });
+}
+function getOwnEnumerableProperties(obj) {
+  return Object.keys(obj).concat(getOwnEnumerablePropertySymbols(obj));
+}
+function isObjectType(obj) {
+  let objectType = type(obj);
+  let objectTypes = ["Array", "Object", "Function"];
+  return objectTypes.indexOf(objectType) !== -1;
+}
+function getOperator(obj, args) {
+  let operator = flag(obj, "operator");
+  let negate = flag(obj, "negate");
+  let expected = args[3];
+  let msg = negate ? args[2] : args[1];
+  if (operator) {
+    return operator;
+  }
+  if (typeof msg === "function")
+    msg = msg();
+  msg = msg || "";
+  if (!msg) {
+    return;
+  }
+  if (/\shave\s/.test(msg)) {
+    return;
+  }
+  let isObject = isObjectType(expected);
+  if (/\snot\s/.test(msg)) {
+    return isObject ? "notDeepStrictEqual" : "notStrictEqual";
+  }
+  return isObject ? "deepStrictEqual" : "strictEqual";
+}
+function getName(fn) {
+  return fn.name;
+}
+function isRegExp2(obj) {
+  return Object.prototype.toString.call(obj) === "[object RegExp]";
+}
+function isNumeric(obj) {
+  return ["Number", "BigInt"].includes(type(obj));
+}
+function an(type3, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  type3 = type3.toLowerCase();
+  let obj = flag2(this, "object"), article = ~["a", "e", "i", "o", "u"].indexOf(type3.charAt(0)) ? "an " : "a ";
+  const detectedType = type(obj).toLowerCase();
+  if (functionTypes["function"].includes(type3)) {
+    this.assert(functionTypes[type3].includes(detectedType), "expected #{this} to be " + article + type3, "expected #{this} not to be " + article + type3);
+  } else {
+    this.assert(type3 === detectedType, "expected #{this} to be " + article + type3, "expected #{this} not to be " + article + type3);
+  }
+}
+function SameValueZero(a, b) {
+  return isNaN2(a) && isNaN2(b) || a === b;
+}
+function includeChainingBehavior() {
+  flag2(this, "contains", true);
+}
+function include(val, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), negate = flag2(this, "negate"), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), descriptor = isDeep ? "deep " : "", isEql = isDeep ? flag2(this, "eql") : SameValueZero;
+  flagMsg = flagMsg ? flagMsg + ": " : "";
+  let included = false;
+  switch (objType) {
+    case "string":
+      included = obj.indexOf(val) !== -1;
+      break;
+    case "weakset":
+      if (isDeep) {
+        throw new AssertionError(flagMsg + "unable to use .deep.include with WeakSet", undefined, ssfi);
+      }
+      included = obj.has(val);
+      break;
+    case "map":
+      obj.forEach(function(item) {
+        included = included || isEql(item, val);
+      });
+      break;
+    case "set":
+      if (isDeep) {
+        obj.forEach(function(item) {
+          included = included || isEql(item, val);
+        });
+      } else {
+        included = obj.has(val);
+      }
+      break;
+    case "array":
+      if (isDeep) {
+        included = obj.some(function(item) {
+          return isEql(item, val);
+        });
+      } else {
+        included = obj.indexOf(val) !== -1;
+      }
+      break;
+    default: {
+      if (val !== Object(val)) {
+        throw new AssertionError(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(), undefined, ssfi);
+      }
+      let props = Object.keys(val);
+      let firstErr = null;
+      let numErrs = 0;
+      props.forEach(function(prop) {
+        let propAssertion = new Assertion(obj);
+        transferFlags(this, propAssertion, true);
+        flag2(propAssertion, "lockSsfi", true);
+        if (!negate || props.length === 1) {
+          propAssertion.property(prop, val[prop]);
+          return;
+        }
+        try {
+          propAssertion.property(prop, val[prop]);
+        } catch (err) {
+          if (!check_error_exports.compatibleConstructor(err, AssertionError)) {
+            throw err;
+          }
+          if (firstErr === null)
+            firstErr = err;
+          numErrs++;
+        }
+      }, this);
+      if (negate && props.length > 1 && numErrs === props.length) {
+        throw firstErr;
+      }
+      return;
+    }
+  }
+  this.assert(included, "expected #{this} to " + descriptor + "include " + inspect2(val), "expected #{this} to not " + descriptor + "include " + inspect2(val));
+}
+function assertExist() {
+  let val = flag2(this, "object");
+  this.assert(val !== null && val !== undefined, "expected #{this} to exist", "expected #{this} to not exist");
+}
+function checkArguments() {
+  let obj = flag2(this, "object"), type3 = type(obj);
+  this.assert(type3 === "Arguments", "expected #{this} to be arguments but got " + type3, "expected #{this} to not be arguments");
+}
+function assertEqual(val, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let obj = flag2(this, "object");
+  if (flag2(this, "deep")) {
+    let prevLockSsfi = flag2(this, "lockSsfi");
+    flag2(this, "lockSsfi", true);
+    this.eql(val);
+    flag2(this, "lockSsfi", prevLockSsfi);
+  } else {
+    this.assert(val === obj, "expected #{this} to equal #{exp}", "expected #{this} to not equal #{exp}", val, this._obj, true);
+  }
+}
+function assertEql(obj, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let eql = flag2(this, "eql");
+  this.assert(eql(obj, flag2(this, "object")), "expected #{this} to deeply equal #{exp}", "expected #{this} to not deeply equal #{exp}", obj, this._obj, true);
+}
+function assertAbove(n, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  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();
+  if (doLength && objType !== "map" && objType !== "set") {
+    new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
+  }
+  if (!doLength && objType === "date" && nType !== "date") {
+    throw new AssertionError(msgPrefix + "the argument to above must be a date", undefined, ssfi);
+  } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
+    throw new AssertionError(msgPrefix + "the argument to above must be a number", undefined, ssfi);
+  } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
+    let printObj = objType === "string" ? "'" + obj + "'" : obj;
+    throw new AssertionError(msgPrefix + "expected " + printObj + " to be a number or a date", undefined, ssfi);
+  }
+  if (doLength) {
+    let descriptor = "length", itemsCount;
+    if (objType === "map" || objType === "set") {
+      descriptor = "size";
+      itemsCount = obj.size;
+    } else {
+      itemsCount = obj.length;
+    }
+    this.assert(itemsCount > n, "expected #{this} to have a " + descriptor + " above #{exp} but got #{act}", "expected #{this} to not have a " + descriptor + " above #{exp}", n, itemsCount);
+  } else {
+    this.assert(obj > n, "expected #{this} to be above #{exp}", "expected #{this} to be at most #{exp}", n);
+  }
+}
+function assertLeast(n, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  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;
+  if (doLength && objType !== "map" && objType !== "set") {
+    new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
+  }
+  if (!doLength && objType === "date" && nType !== "date") {
+    errorMessage = msgPrefix + "the argument to least must be a date";
+  } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
+    errorMessage = msgPrefix + "the argument to least must be a number";
+  } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
+    let printObj = objType === "string" ? "'" + obj + "'" : obj;
+    errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
+  } else {
+    shouldThrow = false;
+  }
+  if (shouldThrow) {
+    throw new AssertionError(errorMessage, undefined, ssfi);
+  }
+  if (doLength) {
+    let descriptor = "length", itemsCount;
+    if (objType === "map" || objType === "set") {
+      descriptor = "size";
+      itemsCount = obj.size;
+    } else {
+      itemsCount = obj.length;
+    }
+    this.assert(itemsCount >= n, "expected #{this} to have a " + descriptor + " at least #{exp} but got #{act}", "expected #{this} to have a " + descriptor + " below #{exp}", n, itemsCount);
+  } else {
+    this.assert(obj >= n, "expected #{this} to be at least #{exp}", "expected #{this} to be below #{exp}", n);
+  }
+}
+function assertBelow(n, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  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;
+  if (doLength && objType !== "map" && objType !== "set") {
+    new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
+  }
+  if (!doLength && objType === "date" && nType !== "date") {
+    errorMessage = msgPrefix + "the argument to below must be a date";
+  } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
+    errorMessage = msgPrefix + "the argument to below must be a number";
+  } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
+    let printObj = objType === "string" ? "'" + obj + "'" : obj;
+    errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
+  } else {
+    shouldThrow = false;
+  }
+  if (shouldThrow) {
+    throw new AssertionError(errorMessage, undefined, ssfi);
+  }
+  if (doLength) {
+    let descriptor = "length", itemsCount;
+    if (objType === "map" || objType === "set") {
+      descriptor = "size";
+      itemsCount = obj.size;
+    } else {
+      itemsCount = obj.length;
+    }
+    this.assert(itemsCount < n, "expected #{this} to have a " + descriptor + " below #{exp} but got #{act}", "expected #{this} to not have a " + descriptor + " below #{exp}", n, itemsCount);
+  } else {
+    this.assert(obj < n, "expected #{this} to be below #{exp}", "expected #{this} to be at least #{exp}", n);
+  }
+}
+function assertMost(n, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  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;
+  if (doLength && objType !== "map" && objType !== "set") {
+    new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
+  }
+  if (!doLength && objType === "date" && nType !== "date") {
+    errorMessage = msgPrefix + "the argument to most must be a date";
+  } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
+    errorMessage = msgPrefix + "the argument to most must be a number";
+  } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
+    let printObj = objType === "string" ? "'" + obj + "'" : obj;
+    errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
+  } else {
+    shouldThrow = false;
+  }
+  if (shouldThrow) {
+    throw new AssertionError(errorMessage, undefined, ssfi);
+  }
+  if (doLength) {
+    let descriptor = "length", itemsCount;
+    if (objType === "map" || objType === "set") {
+      descriptor = "size";
+      itemsCount = obj.size;
+    } else {
+      itemsCount = obj.length;
+    }
+    this.assert(itemsCount <= n, "expected #{this} to have a " + descriptor + " at most #{exp} but got #{act}", "expected #{this} to have a " + descriptor + " above #{exp}", n, itemsCount);
+  } else {
+    this.assert(obj <= n, "expected #{this} to be at most #{exp}", "expected #{this} to be above #{exp}", n);
+  }
+}
+function assertInstanceOf(constructor, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let target = flag2(this, "object");
+  let ssfi = flag2(this, "ssfi");
+  let flagMsg = flag2(this, "message");
+  let isInstanceOf;
+  try {
+    isInstanceOf = target instanceof constructor;
+  } catch (err) {
+    if (err instanceof TypeError) {
+      flagMsg = flagMsg ? flagMsg + ": " : "";
+      throw new AssertionError(flagMsg + "The instanceof assertion needs a constructor but " + type(constructor) + " was given.", undefined, ssfi);
+    }
+    throw err;
+  }
+  let name = getName(constructor);
+  if (name == null) {
+    name = "an unnamed constructor";
+  }
+  this.assert(isInstanceOf, "expected #{this} to be an instance of " + name, "expected #{this} to not be an instance of " + name);
+}
+function assertProperty(name, val, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let isNested = flag2(this, "nested"), isOwn = flag2(this, "own"), flagMsg = flag2(this, "message"), obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), nameType = typeof name;
+  flagMsg = flagMsg ? flagMsg + ": " : "";
+  if (isNested) {
+    if (nameType !== "string") {
+      throw new AssertionError(flagMsg + "the argument to property must be a string when using nested syntax", undefined, ssfi);
+    }
+  } else {
+    if (nameType !== "string" && nameType !== "number" && nameType !== "symbol") {
+      throw new AssertionError(flagMsg + "the argument to property must be a string, number, or symbol", undefined, ssfi);
+    }
+  }
+  if (isNested && isOwn) {
+    throw new AssertionError(flagMsg + 'The "nested" and "own" flags cannot be combined.', undefined, ssfi);
+  }
+  if (obj === null || obj === undefined) {
+    throw new AssertionError(flagMsg + "Target cannot be null or undefined.", undefined, ssfi);
+  }
+  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;
+  let descriptor = "";
+  if (isDeep)
+    descriptor += "deep ";
+  if (isOwn)
+    descriptor += "own ";
+  if (isNested)
+    descriptor += "nested ";
+  descriptor += "property ";
+  let hasProperty2;
+  if (isOwn)
+    hasProperty2 = Object.prototype.hasOwnProperty.call(obj, name);
+  else if (isNested)
+    hasProperty2 = pathInfo.exists;
+  else
+    hasProperty2 = hasProperty(obj, name);
+  if (!negate || arguments.length === 1) {
+    this.assert(hasProperty2, "expected #{this} to have " + descriptor + inspect2(name), "expected #{this} to not have " + descriptor + inspect2(name));
+  }
+  if (arguments.length > 1) {
+    this.assert(hasProperty2 && isEql(val, value), "expected #{this} to have " + descriptor + inspect2(name) + " of #{exp}, but got #{act}", "expected #{this} to not have " + descriptor + inspect2(name) + " of #{act}", val, value);
+  }
+  flag2(this, "object", value);
+}
+function assertOwnProperty(_name, _value, _msg) {
+  flag2(this, "own", true);
+  assertProperty.apply(this, arguments);
+}
+function assertOwnPropertyDescriptor(name, descriptor, msg) {
+  if (typeof descriptor === "string") {
+    msg = descriptor;
+    descriptor = null;
+  }
+  if (msg)
+    flag2(this, "message", msg);
+  let obj = flag2(this, "object");
+  let actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name);
+  let eql = flag2(this, "eql");
+  if (actualDescriptor && descriptor) {
+    this.assert(eql(descriptor, actualDescriptor), "expected the own property descriptor for " + inspect2(name) + " on #{this} to match " + inspect2(descriptor) + ", got " + inspect2(actualDescriptor), "expected the own property descriptor for " + inspect2(name) + " on #{this} to not match " + inspect2(descriptor), descriptor, actualDescriptor, true);
+  } else {
+    this.assert(actualDescriptor, "expected #{this} to have an own property descriptor for " + inspect2(name), "expected #{this} to not have an own property descriptor for " + inspect2(name));
+  }
+  flag2(this, "object", actualDescriptor);
+}
+function assertLengthChain() {
+  flag2(this, "doLength", true);
+}
+function assertLength(n, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), descriptor = "length", itemsCount;
+  switch (objType) {
+    case "map":
+    case "set":
+      descriptor = "size";
+      itemsCount = obj.size;
+      break;
+    default:
+      new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
+      itemsCount = obj.length;
+  }
+  this.assert(itemsCount == n, "expected #{this} to have a " + descriptor + " of #{exp} but got #{act}", "expected #{this} to not have a " + descriptor + " of #{act}", n, itemsCount);
+}
+function assertMatch(re, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let obj = flag2(this, "object");
+  this.assert(re.exec(obj), "expected #{this} to match " + re, "expected #{this} not to match " + re);
+}
+function assertKeys(keys) {
+  let obj = flag2(this, "object"), objType = type(obj), keysType = type(keys), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), str, deepStr = "", actual, ok = true, flagMsg = flag2(this, "message");
+  flagMsg = flagMsg ? flagMsg + ": " : "";
+  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";
+  if (objType === "Map" || objType === "Set") {
+    deepStr = isDeep ? "deeply " : "";
+    actual = [];
+    obj.forEach(function(val, key) {
+      actual.push(key);
+    });
+    if (keysType !== "Array") {
+      keys = Array.prototype.slice.call(arguments);
+    }
+  } else {
+    actual = getOwnEnumerableProperties(obj);
+    switch (keysType) {
+      case "Array":
+        if (arguments.length > 1) {
+          throw new AssertionError(mixedArgsMsg, undefined, ssfi);
+        }
+        break;
+      case "Object":
+        if (arguments.length > 1) {
+          throw new AssertionError(mixedArgsMsg, undefined, ssfi);
+        }
+        keys = Object.keys(keys);
+        break;
+      default:
+        keys = Array.prototype.slice.call(arguments);
+    }
+    keys = keys.map(function(val) {
+      return typeof val === "symbol" ? val : String(val);
+    });
+  }
+  if (!keys.length) {
+    throw new AssertionError(flagMsg + "keys required", undefined, ssfi);
+  }
+  let len = keys.length, any = flag2(this, "any"), all = flag2(this, "all"), expected = keys, isEql = isDeep ? flag2(this, "eql") : (val1, val2) => val1 === val2;
+  if (!any && !all) {
+    all = true;
+  }
+  if (any) {
+    ok = expected.some(function(expectedKey) {
+      return actual.some(function(actualKey) {
+        return isEql(expectedKey, actualKey);
+      });
+    });
+  }
+  if (all) {
+    ok = expected.every(function(expectedKey) {
+      return actual.some(function(actualKey) {
+        return isEql(expectedKey, actualKey);
+      });
+    });
+    if (!flag2(this, "contains")) {
+      ok = ok && keys.length == actual.length;
+    }
+  }
+  if (len > 1) {
+    keys = keys.map(function(key) {
+      return inspect2(key);
+    });
+    let last = keys.pop();
+    if (all) {
+      str = keys.join(", ") + ", and " + last;
+    }
+    if (any) {
+      str = keys.join(", ") + ", or " + last;
+    }
+  } else {
+    str = inspect2(keys[0]);
+  }
+  str = (len > 1 ? "keys " : "key ") + str;
+  str = (flag2(this, "contains") ? "contain " : "have ") + str;
+  this.assert(ok, "expected #{this} to " + deepStr + str, "expected #{this} to not " + deepStr + str, expected.slice(0).sort(compareByInspect), actual.sort(compareByInspect), true);
+}
+function assertThrows(errorLike, errMsgMatcher, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), negate = flag2(this, "negate") || false;
+  new Assertion(obj, flagMsg, ssfi, true).is.a("function");
+  if (isRegExp2(errorLike) || typeof errorLike === "string") {
+    errMsgMatcher = errorLike;
+    errorLike = null;
+  }
+  let caughtErr;
+  let errorWasThrown = false;
+  try {
+    obj();
+  } catch (err) {
+    errorWasThrown = true;
+    caughtErr = err;
+  }
+  let everyArgIsUndefined = errorLike === undefined && errMsgMatcher === undefined;
+  let everyArgIsDefined = Boolean(errorLike && errMsgMatcher);
+  let errorLikeFail = false;
+  let errMsgMatcherFail = false;
+  if (everyArgIsUndefined || !everyArgIsUndefined && !negate) {
+    let errorLikeString = "an error";
+    if (errorLike instanceof Error) {
+      errorLikeString = "#{exp}";
+    } else if (errorLike) {
+      errorLikeString = check_error_exports.getConstructorName(errorLike);
+    }
+    let actual = caughtErr;
+    if (caughtErr instanceof Error) {
+      actual = caughtErr.toString();
+    } else if (typeof caughtErr === "string") {
+      actual = caughtErr;
+    } else if (caughtErr && (typeof caughtErr === "object" || typeof caughtErr === "function")) {
+      try {
+        actual = check_error_exports.getConstructorName(caughtErr);
+      } catch (_err) {}
+    }
+    this.assert(errorWasThrown, "expected #{this} to throw " + errorLikeString, "expected #{this} to not throw an error but #{act} was thrown", errorLike && errorLike.toString(), actual);
+  }
+  if (errorLike && caughtErr) {
+    if (errorLike instanceof Error) {
+      let isCompatibleInstance = check_error_exports.compatibleInstance(caughtErr, errorLike);
+      if (isCompatibleInstance === negate) {
+        if (everyArgIsDefined && negate) {
+          errorLikeFail = true;
+        } else {
+          this.assert(negate, "expected #{this} to throw #{exp} but #{act} was thrown", "expected #{this} to not throw #{exp}" + (caughtErr && !negate ? " but #{act} was thrown" : ""), errorLike.toString(), caughtErr.toString());
+        }
+      }
+    }
+    let isCompatibleConstructor = check_error_exports.compatibleConstructor(caughtErr, errorLike);
+    if (isCompatibleConstructor === negate) {
+      if (everyArgIsDefined && negate) {
+        errorLikeFail = true;
+      } else {
+        this.assert(negate, "expected #{this} to throw #{exp} but #{act} was thrown", "expected #{this} to not throw #{exp}" + (caughtErr ? " but #{act} was thrown" : ""), errorLike instanceof Error ? errorLike.toString() : errorLike && check_error_exports.getConstructorName(errorLike), caughtErr instanceof Error ? caughtErr.toString() : caughtErr && check_error_exports.getConstructorName(caughtErr));
+      }
+    }
+  }
+  if (caughtErr && errMsgMatcher !== undefined && errMsgMatcher !== null) {
+    let placeholder = "including";
+    if (isRegExp2(errMsgMatcher)) {
+      placeholder = "matching";
+    }
+    let isCompatibleMessage = check_error_exports.compatibleMessage(caughtErr, errMsgMatcher);
+    if (isCompatibleMessage === negate) {
+      if (everyArgIsDefined && negate) {
+        errMsgMatcherFail = true;
+      } else {
+        this.assert(negate, "expected #{this} to throw error " + placeholder + " #{exp} but got #{act}", "expected #{this} to throw error not " + placeholder + " #{exp}", errMsgMatcher, check_error_exports.getMessage(caughtErr));
+      }
+    }
+  }
+  if (errorLikeFail && errMsgMatcherFail) {
+    this.assert(negate, "expected #{this} to throw #{exp} but #{act} was thrown", "expected #{this} to not throw #{exp}" + (caughtErr ? " but #{act} was thrown" : ""), errorLike instanceof Error ? errorLike.toString() : errorLike && check_error_exports.getConstructorName(errorLike), caughtErr instanceof Error ? caughtErr.toString() : caughtErr && check_error_exports.getConstructorName(caughtErr));
+  }
+  flag2(this, "object", caughtErr);
+}
+function respondTo(method, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let obj = flag2(this, "object"), itself = flag2(this, "itself"), context = typeof obj === "function" && !itself ? obj.prototype[method] : obj[method];
+  this.assert(typeof context === "function", "expected #{this} to respond to " + inspect2(method), "expected #{this} to not respond to " + inspect2(method));
+}
+function satisfy(matcher, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let obj = flag2(this, "object");
+  let result = matcher(obj);
+  this.assert(result, "expected #{this} to satisfy " + objDisplay(matcher), "expected #{this} to not satisfy" + objDisplay(matcher), flag2(this, "negate") ? false : true, result);
+}
+function closeTo(expected, delta, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  new Assertion(obj, flagMsg, ssfi, true).is.numeric;
+  let message = "A `delta` value is required for `closeTo`";
+  if (delta == undefined) {
+    throw new AssertionError(flagMsg ? `${flagMsg}: ${message}` : message, undefined, ssfi);
+  }
+  new Assertion(delta, flagMsg, ssfi, true).is.numeric;
+  message = "A `expected` value is required for `closeTo`";
+  if (expected == undefined) {
+    throw new AssertionError(flagMsg ? `${flagMsg}: ${message}` : message, undefined, ssfi);
+  }
+  new Assertion(expected, flagMsg, ssfi, true).is.numeric;
+  const abs = /* @__PURE__ */ __name((x) => x < 0 ? -x : x, "abs");
+  const strip = /* @__PURE__ */ __name((number) => parseFloat(parseFloat(number).toPrecision(12)), "strip");
+  this.assert(strip(abs(obj - expected)) <= delta, "expected #{this} to be close to " + expected + " +/- " + delta, "expected #{this} not to be close to " + expected + " +/- " + delta);
+}
+function isSubsetOf(_subset, _superset, cmp, contains, ordered) {
+  let superset = Array.from(_superset);
+  let subset = Array.from(_subset);
+  if (!contains) {
+    if (subset.length !== superset.length)
+      return false;
+    superset = superset.slice();
+  }
+  return subset.every(function(elem, idx) {
+    if (ordered)
+      return cmp ? cmp(elem, superset[idx]) : elem === superset[idx];
+    if (!cmp) {
+      let matchIdx = superset.indexOf(elem);
+      if (matchIdx === -1)
+        return false;
+      if (!contains)
+        superset.splice(matchIdx, 1);
+      return true;
+    }
+    return superset.some(function(elem2, matchIdx) {
+      if (!cmp(elem, elem2))
+        return false;
+      if (!contains)
+        superset.splice(matchIdx, 1);
+      return true;
+    });
+  });
+}
+function oneOf(list, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  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");
+  new Assertion(list, flagMsg, ssfi, true).to.be.an("array");
+  if (contains) {
+    this.assert(list.some(function(possibility) {
+      return expected.indexOf(possibility) > -1;
+    }), "expected #{this} to contain one of #{exp}", "expected #{this} to not contain one of #{exp}", list, expected);
+  } else {
+    if (isDeep) {
+      this.assert(list.some(function(possibility) {
+        return eql(expected, possibility);
+      }), "expected #{this} to deeply equal one of #{exp}", "expected #{this} to deeply equal one of #{exp}", list, expected);
+    } else {
+      this.assert(list.indexOf(expected) > -1, "expected #{this} to be one of #{exp}", "expected #{this} to not be one of #{exp}", list, expected);
+    }
+  }
+}
+function assertChanges(subject, prop, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let fn = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  new Assertion(fn, flagMsg, ssfi, true).is.a("function");
+  let initial;
+  if (!prop) {
+    new Assertion(subject, flagMsg, ssfi, true).is.a("function");
+    initial = subject();
+  } else {
+    new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop);
+    initial = subject[prop];
+  }
+  fn();
+  let final = prop === undefined || prop === null ? subject() : subject[prop];
+  let msgObj = prop === undefined || prop === null ? initial : "." + prop;
+  flag2(this, "deltaMsgObj", msgObj);
+  flag2(this, "initialDeltaValue", initial);
+  flag2(this, "finalDeltaValue", final);
+  flag2(this, "deltaBehavior", "change");
+  flag2(this, "realDelta", final !== initial);
+  this.assert(initial !== final, "expected " + msgObj + " to change", "expected " + msgObj + " to not change");
+}
+function assertIncreases(subject, prop, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let fn = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  new Assertion(fn, flagMsg, ssfi, true).is.a("function");
+  let initial;
+  if (!prop) {
+    new Assertion(subject, flagMsg, ssfi, true).is.a("function");
+    initial = subject();
+  } else {
+    new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop);
+    initial = subject[prop];
+  }
+  new Assertion(initial, flagMsg, ssfi, true).is.a("number");
+  fn();
+  let final = prop === undefined || prop === null ? subject() : subject[prop];
+  let msgObj = prop === undefined || prop === null ? initial : "." + prop;
+  flag2(this, "deltaMsgObj", msgObj);
+  flag2(this, "initialDeltaValue", initial);
+  flag2(this, "finalDeltaValue", final);
+  flag2(this, "deltaBehavior", "increase");
+  flag2(this, "realDelta", final - initial);
+  this.assert(final - initial > 0, "expected " + msgObj + " to increase", "expected " + msgObj + " to not increase");
+}
+function assertDecreases(subject, prop, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let fn = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  new Assertion(fn, flagMsg, ssfi, true).is.a("function");
+  let initial;
+  if (!prop) {
+    new Assertion(subject, flagMsg, ssfi, true).is.a("function");
+    initial = subject();
+  } else {
+    new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop);
+    initial = subject[prop];
+  }
+  new Assertion(initial, flagMsg, ssfi, true).is.a("number");
+  fn();
+  let final = prop === undefined || prop === null ? subject() : subject[prop];
+  let msgObj = prop === undefined || prop === null ? initial : "." + prop;
+  flag2(this, "deltaMsgObj", msgObj);
+  flag2(this, "initialDeltaValue", initial);
+  flag2(this, "finalDeltaValue", final);
+  flag2(this, "deltaBehavior", "decrease");
+  flag2(this, "realDelta", initial - final);
+  this.assert(final - initial < 0, "expected " + msgObj + " to decrease", "expected " + msgObj + " to not decrease");
+}
+function assertDelta(delta, msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  let msgObj = flag2(this, "deltaMsgObj");
+  let initial = flag2(this, "initialDeltaValue");
+  let final = flag2(this, "finalDeltaValue");
+  let behavior = flag2(this, "deltaBehavior");
+  let realDelta = flag2(this, "realDelta");
+  let expression;
+  if (behavior === "change") {
+    expression = Math.abs(final - initial) === Math.abs(delta);
+  } else {
+    expression = realDelta === Math.abs(delta);
+  }
+  this.assert(expression, "expected " + msgObj + " to " + behavior + " by " + delta, "expected " + msgObj + " to not " + behavior + " by " + delta);
+}
+function compareSubset(expected, actual) {
+  if (expected === actual) {
+    return true;
+  }
+  if (typeof actual !== typeof expected) {
+    return false;
+  }
+  if (typeof expected !== "object" || expected === null) {
+    return expected === actual;
+  }
+  if (!actual) {
+    return false;
+  }
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual)) {
+      return false;
+    }
+    return expected.every(function(exp) {
+      return actual.some(function(act) {
+        return compareSubset(exp, act);
+      });
+    });
+  }
+  if (expected instanceof Date) {
+    if (actual instanceof Date) {
+      return expected.getTime() === actual.getTime();
+    } else {
+      return false;
+    }
+  }
+  return Object.keys(expected).every(function(key) {
+    let expectedValue = expected[key];
+    let actualValue = actual[key];
+    if (typeof expectedValue === "object" && expectedValue !== null && actualValue !== null) {
+      return compareSubset(expectedValue, actualValue);
+    }
+    if (typeof expectedValue === "function") {
+      return expectedValue(actualValue);
+    }
+    return actualValue === expectedValue;
+  });
+}
+function expect(val, message) {
+  return new Assertion(val, message);
+}
+function loadShould() {
+  function shouldGetter() {
+    if (this instanceof String || this instanceof Number || this instanceof Boolean || typeof Symbol === "function" && this instanceof Symbol || typeof BigInt === "function" && this instanceof BigInt) {
+      return new Assertion(this.valueOf(), null, shouldGetter);
+    }
+    return new Assertion(this, null, shouldGetter);
+  }
+  __name(shouldGetter, "shouldGetter");
+  function shouldSetter(value) {
+    Object.defineProperty(this, "should", {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  __name(shouldSetter, "shouldSetter");
+  Object.defineProperty(Object.prototype, "should", {
+    set: shouldSetter,
+    get: shouldGetter,
+    configurable: true
+  });
+  let should2 = {};
+  should2.fail = function(actual, expected, message, operator) {
+    if (arguments.length < 2) {
+      message = actual;
+      actual = undefined;
+    }
+    message = message || "should.fail()";
+    throw new AssertionError(message, {
+      actual,
+      expected,
+      operator
+    }, should2.fail);
+  };
+  should2.equal = function(actual, expected, message) {
+    new Assertion(actual, message).to.equal(expected);
+  };
+  should2.Throw = function(fn, errt, errs, msg) {
+    new Assertion(fn, msg).to.Throw(errt, errs);
+  };
+  should2.exist = function(val, msg) {
+    new Assertion(val, msg).to.exist;
+  };
+  should2.not = {};
+  should2.not.equal = function(actual, expected, msg) {
+    new Assertion(actual, msg).to.not.equal(expected);
+  };
+  should2.not.Throw = function(fn, errt, errs, msg) {
+    new Assertion(fn, msg).to.not.Throw(errt, errs);
+  };
+  should2.not.exist = function(val, msg) {
+    new Assertion(val, msg).to.not.exist;
+  };
+  should2["throw"] = should2["Throw"];
+  should2.not["throw"] = should2.not["Throw"];
+  return should2;
+}
+function assert(express, errmsg) {
+  let test2 = new Assertion(null, null, assert, true);
+  test2.assert(express, errmsg, "[ negation message unavailable ]");
+}
+function use(fn) {
+  const exports = {
+    use,
+    AssertionError,
+    util: utils_exports,
+    config,
+    expect,
+    assert,
+    Assertion,
+    ...should_exports
+  };
+  if (!~used.indexOf(fn)) {
+    fn(exports, utils_exports);
+    used.push(fn);
+  }
+  return exports;
+}
+var __defProp2, __defNormalProp = (obj, key, value) => (key in obj) ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, __name = (target, value) => __defProp2(target, "name", { value, configurable: true }), __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, { get: all[name], enumerable: true });
+}, __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value), utils_exports, check_error_exports, canElideFrames, _AssertionError, AssertionError, ansiColors, styles, truncator = "…", getArrayName, isNaN, stringEscapeChars, escapeCharacters, hex = 16, unicodeLength = 4, getPromiseValue, promise_default, toStringTag, errorKeys, symbolsSupported, chaiInspect, nodeInspect, constructorMap, stringTagMap, baseTypesMap, inspectCustom, toString, config, MemoizeMap, deep_eql_default, _Assertion = class _Assertion2 {
+  constructor(obj, msg, ssfi, lockSsfi) {
+    __publicField(this, "__flags", {});
+    flag(this, "ssfi", ssfi || _Assertion2);
+    flag(this, "lockSsfi", lockSsfi);
+    flag(this, "object", obj);
+    flag(this, "message", msg);
+    flag(this, "eql", config.deepEqual || deep_eql_default);
+    return proxify(this);
+  }
+  static get includeStack() {
+    console.warn("Assertion.includeStack is deprecated, use chai.config.includeStack instead.");
+    return config.includeStack;
+  }
+  static set includeStack(value) {
+    console.warn("Assertion.includeStack is deprecated, use chai.config.includeStack instead.");
+    config.includeStack = value;
+  }
+  static get showDiff() {
+    console.warn("Assertion.showDiff is deprecated, use chai.config.showDiff instead.");
+    return config.showDiff;
+  }
+  static set showDiff(value) {
+    console.warn("Assertion.showDiff is deprecated, use chai.config.showDiff instead.");
+    config.showDiff = value;
+  }
+  static addProperty(name, fn) {
+    addProperty(this.prototype, name, fn);
+  }
+  static addMethod(name, fn) {
+    addMethod(this.prototype, name, fn);
+  }
+  static addChainableMethod(name, fn, chainingBehavior) {
+    addChainableMethod(this.prototype, name, fn, chainingBehavior);
+  }
+  static overwriteProperty(name, fn) {
+    overwriteProperty(this.prototype, name, fn);
+  }
+  static overwriteMethod(name, fn) {
+    overwriteMethod(this.prototype, name, fn);
+  }
+  static overwriteChainableMethod(name, fn, chainingBehavior) {
+    overwriteChainableMethod(this.prototype, name, fn, chainingBehavior);
+  }
+  assert(_expr, msg, _negateMsg, expected, _actual, showDiff) {
+    const ok = test(this, arguments);
+    if (showDiff !== false)
+      showDiff = true;
+    if (expected === undefined && _actual === undefined)
+      showDiff = false;
+    if (config.showDiff !== true)
+      showDiff = false;
+    if (!ok) {
+      msg = getMessage2(this, arguments);
+      const actual = getActual(this, arguments);
+      const assertionErrorObjectProperties = {
+        actual,
+        expected,
+        showDiff
+      };
+      const operator = getOperator(this, arguments);
+      if (operator) {
+        assertionErrorObjectProperties.operator = operator;
+      }
+      throw new AssertionError(msg, assertionErrorObjectProperties, config.includeStack ? this.assert : flag(this, "ssfi"));
+    }
+  }
+  get _obj() {
+    return flag(this, "object");
+  }
+  set _obj(val) {
+    flag(this, "object", val);
+  }
+}, Assertion, events, _PluginEvent, PluginEvent, fnLengthDesc, builtins, canSetPrototype, testFn, excludeNames, call, apply, _PluginAddChainableMethodEvent, PluginAddChainableMethodEvent, isNaN2, flag2, functionTypes, should_exports, should, Should, aliases, used;
+var init_chai = __esm(() => {
+  __defProp2 = Object.defineProperty;
+  utils_exports = {};
+  __export2(utils_exports, {
+    addChainableMethod: () => addChainableMethod,
+    addLengthGuard: () => addLengthGuard,
+    addMethod: () => addMethod,
+    addProperty: () => addProperty,
+    checkError: () => check_error_exports,
+    compareByInspect: () => compareByInspect,
+    eql: () => deep_eql_default,
+    events: () => events,
+    expectTypes: () => expectTypes,
+    flag: () => flag,
+    getActual: () => getActual,
+    getMessage: () => getMessage2,
+    getName: () => getName,
+    getOperator: () => getOperator,
+    getOwnEnumerableProperties: () => getOwnEnumerableProperties,
+    getOwnEnumerablePropertySymbols: () => getOwnEnumerablePropertySymbols,
+    getPathInfo: () => getPathInfo,
+    hasProperty: () => hasProperty,
+    inspect: () => inspect2,
+    isNaN: () => isNaN2,
+    isNumeric: () => isNumeric,
+    isProxyEnabled: () => isProxyEnabled,
+    isRegExp: () => isRegExp2,
+    objDisplay: () => objDisplay,
+    overwriteChainableMethod: () => overwriteChainableMethod,
+    overwriteMethod: () => overwriteMethod,
+    overwriteProperty: () => overwriteProperty,
+    proxify: () => proxify,
+    test: () => test,
+    transferFlags: () => transferFlags,
+    type: () => type
+  });
+  check_error_exports = {};
+  __export2(check_error_exports, {
+    compatibleConstructor: () => compatibleConstructor,
+    compatibleInstance: () => compatibleInstance,
+    compatibleMessage: () => compatibleMessage,
+    getConstructorName: () => getConstructorName,
+    getMessage: () => getMessage
+  });
+  __name(isErrorInstance, "isErrorInstance");
+  __name(isRegExp, "isRegExp");
+  __name(compatibleInstance, "compatibleInstance");
+  __name(compatibleConstructor, "compatibleConstructor");
+  __name(compatibleMessage, "compatibleMessage");
+  __name(getConstructorName, "getConstructorName");
+  __name(getMessage, "getMessage");
+  __name(flag, "flag");
+  __name(test, "test");
+  __name(type, "type");
+  canElideFrames = "captureStackTrace" in Error;
+  _AssertionError = class _AssertionError2 extends Error {
+    constructor(message = "Unspecified AssertionError", props, ssf) {
+      super(message);
+      __publicField(this, "message");
+      this.message = message;
+      if (canElideFrames) {
+        Error.captureStackTrace(this, ssf || _AssertionError2);
+      }
+      for (const key in props) {
+        if (!(key in this)) {
+          this[key] = props[key];
+        }
+      }
+    }
+    get name() {
+      return "AssertionError";
+    }
+    get ok() {
+      return false;
+    }
+    toJSON(stack) {
+      return {
+        ...this,
+        name: this.name,
+        message: this.message,
+        ok: false,
+        stack: stack !== false ? this.stack : undefined
+      };
+    }
+  };
+  __name(_AssertionError, "AssertionError");
+  AssertionError = _AssertionError;
+  __name(expectTypes, "expectTypes");
+  __name(getActual, "getActual");
+  ansiColors = {
+    bold: ["1", "22"],
+    dim: ["2", "22"],
+    italic: ["3", "23"],
+    underline: ["4", "24"],
+    inverse: ["7", "27"],
+    hidden: ["8", "28"],
+    strike: ["9", "29"],
+    black: ["30", "39"],
+    red: ["31", "39"],
+    green: ["32", "39"],
+    yellow: ["33", "39"],
+    blue: ["34", "39"],
+    magenta: ["35", "39"],
+    cyan: ["36", "39"],
+    white: ["37", "39"],
+    brightblack: ["30;1", "39"],
+    brightred: ["31;1", "39"],
+    brightgreen: ["32;1", "39"],
+    brightyellow: ["33;1", "39"],
+    brightblue: ["34;1", "39"],
+    brightmagenta: ["35;1", "39"],
+    brightcyan: ["36;1", "39"],
+    brightwhite: ["37;1", "39"],
+    grey: ["90", "39"]
+  };
+  styles = {
+    special: "cyan",
+    number: "yellow",
+    bigint: "yellow",
+    boolean: "yellow",
+    undefined: "grey",
+    null: "bold",
+    string: "green",
+    symbol: "green",
+    date: "magenta",
+    regexp: "red"
+  };
+  __name(colorise, "colorise");
+  __name(normaliseOptions, "normaliseOptions");
+  __name(isHighSurrogate, "isHighSurrogate");
+  __name(truncate, "truncate");
+  __name(inspectList, "inspectList");
+  __name(quoteComplexKey, "quoteComplexKey");
+  __name(inspectProperty, "inspectProperty");
+  __name(inspectArray, "inspectArray");
+  getArrayName = /* @__PURE__ */ __name((array) => {
+    if (typeof Buffer === "function" && array instanceof Buffer) {
+      return "Buffer";
+    }
+    if (array[Symbol.toStringTag]) {
+      return array[Symbol.toStringTag];
+    }
+    return array.constructor.name;
+  }, "getArrayName");
+  __name(inspectTypedArray, "inspectTypedArray");
+  __name(inspectDate, "inspectDate");
+  __name(inspectFunction, "inspectFunction");
+  __name(inspectMapEntry, "inspectMapEntry");
+  __name(mapToEntries, "mapToEntries");
+  __name(inspectMap, "inspectMap");
+  isNaN = Number.isNaN || ((i) => i !== i);
+  __name(inspectNumber, "inspectNumber");
+  __name(inspectBigInt, "inspectBigInt");
+  __name(inspectRegExp, "inspectRegExp");
+  __name(arrayFromSet, "arrayFromSet");
+  __name(inspectSet, "inspectSet");
+  stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g");
+  escapeCharacters = {
+    "\b": "\\b",
+    "\t": "\\t",
+    "\n": "\\n",
+    "\f": "\\f",
+    "\r": "\\r",
+    "'": "\\'",
+    "\\": "\\\\"
+  };
+  __name(escape, "escape");
+  __name(inspectString, "inspectString");
+  __name(inspectSymbol, "inspectSymbol");
+  getPromiseValue = /* @__PURE__ */ __name(() => "Promise{…}", "getPromiseValue");
+  promise_default = getPromiseValue;
+  __name(inspectObject, "inspectObject");
+  toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag ? Symbol.toStringTag : false;
+  __name(inspectClass, "inspectClass");
+  __name(inspectArguments, "inspectArguments");
+  errorKeys = [
+    "stack",
+    "line",
+    "column",
+    "name",
+    "message",
+    "fileName",
+    "lineNumber",
+    "columnNumber",
+    "number",
+    "description",
+    "cause"
+  ];
+  __name(inspectObject2, "inspectObject");
+  __name(inspectAttribute, "inspectAttribute");
+  __name(inspectNodeCollection, "inspectNodeCollection");
+  __name(inspectNode, "inspectNode");
+  __name(inspectHTML, "inspectHTML");
+  symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function";
+  chaiInspect = symbolsSupported ? /* @__PURE__ */ Symbol.for("chai/inspect") : "@@chai/inspect";
+  nodeInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+  constructorMap = /* @__PURE__ */ new WeakMap;
+  stringTagMap = {};
+  baseTypesMap = {
+    undefined: /* @__PURE__ */ __name((value, options) => options.stylize("undefined", "undefined"), "undefined"),
+    null: /* @__PURE__ */ __name((value, options) => options.stylize("null", "null"), "null"),
+    boolean: /* @__PURE__ */ __name((value, options) => options.stylize(String(value), "boolean"), "boolean"),
+    Boolean: /* @__PURE__ */ __name((value, options) => options.stylize(String(value), "boolean"), "Boolean"),
+    number: inspectNumber,
+    Number: inspectNumber,
+    bigint: inspectBigInt,
+    BigInt: inspectBigInt,
+    string: inspectString,
+    String: inspectString,
+    function: inspectFunction,
+    Function: inspectFunction,
+    symbol: inspectSymbol,
+    Symbol: inspectSymbol,
+    Array: inspectArray,
+    Date: inspectDate,
+    Map: inspectMap,
+    Set: inspectSet,
+    RegExp: inspectRegExp,
+    Promise: promise_default,
+    WeakSet: /* @__PURE__ */ __name((value, options) => options.stylize("WeakSet{…}", "special"), "WeakSet"),
+    WeakMap: /* @__PURE__ */ __name((value, options) => options.stylize("WeakMap{…}", "special"), "WeakMap"),
+    Arguments: inspectArguments,
+    Int8Array: inspectTypedArray,
+    Uint8Array: inspectTypedArray,
+    Uint8ClampedArray: inspectTypedArray,
+    Int16Array: inspectTypedArray,
+    Uint16Array: inspectTypedArray,
+    Int32Array: inspectTypedArray,
+    Uint32Array: inspectTypedArray,
+    Float32Array: inspectTypedArray,
+    Float64Array: inspectTypedArray,
+    Generator: /* @__PURE__ */ __name(() => "", "Generator"),
+    DataView: /* @__PURE__ */ __name(() => "", "DataView"),
+    ArrayBuffer: /* @__PURE__ */ __name(() => "", "ArrayBuffer"),
+    Error: inspectObject2,
+    HTMLCollection: inspectNodeCollection,
+    NodeList: inspectNodeCollection
+  };
+  inspectCustom = /* @__PURE__ */ __name((value, options, type3, inspectFn) => {
+    if (chaiInspect in value && typeof value[chaiInspect] === "function") {
+      return value[chaiInspect](options);
+    }
+    if (nodeInspect in value && typeof value[nodeInspect] === "function") {
+      return value[nodeInspect](options.depth, options, inspectFn);
+    }
+    if ("inspect" in value && typeof value.inspect === "function") {
+      return value.inspect(options.depth, options);
+    }
+    if ("constructor" in value && constructorMap.has(value.constructor)) {
+      return constructorMap.get(value.constructor)(value, options);
+    }
+    if (stringTagMap[type3]) {
+      return stringTagMap[type3](value, options);
+    }
+    return "";
+  }, "inspectCustom");
+  toString = Object.prototype.toString;
+  __name(inspect, "inspect");
+  config = {
+    includeStack: false,
+    showDiff: true,
+    truncateThreshold: 40,
+    useProxy: true,
+    proxyExcludedKeys: ["then", "catch", "inspect", "toJSON"],
+    deepEqual: null
+  };
+  __name(inspect2, "inspect");
+  __name(objDisplay, "objDisplay");
+  __name(getMessage2, "getMessage");
+  __name(transferFlags, "transferFlags");
+  __name(type2, "type");
+  __name(FakeMap, "FakeMap");
+  FakeMap.prototype = {
+    get: /* @__PURE__ */ __name(function get(key) {
+      return key[this._key];
+    }, "get"),
+    set: /* @__PURE__ */ __name(function set(key, value) {
+      if (Object.isExtensible(key)) {
+        Object.defineProperty(key, this._key, {
+          value,
+          configurable: true
+        });
+      }
+    }, "set")
+  };
+  MemoizeMap = typeof WeakMap === "function" ? WeakMap : FakeMap;
+  __name(memoizeCompare, "memoizeCompare");
+  __name(memoizeSet, "memoizeSet");
+  deep_eql_default = deepEqual;
+  __name(deepEqual, "deepEqual");
+  __name(simpleEqual, "simpleEqual");
+  __name(extensiveDeepEqual, "extensiveDeepEqual");
+  __name(extensiveDeepEqualByType, "extensiveDeepEqualByType");
+  __name(regexpEqual, "regexpEqual");
+  __name(entriesEqual, "entriesEqual");
+  __name(iterableEqual, "iterableEqual");
+  __name(generatorEqual, "generatorEqual");
+  __name(hasIteratorFunction, "hasIteratorFunction");
+  __name(getIteratorEntries, "getIteratorEntries");
+  __name(getGeneratorEntries, "getGeneratorEntries");
+  __name(getEnumerableKeys, "getEnumerableKeys");
+  __name(getEnumerableSymbols, "getEnumerableSymbols");
+  __name(keysEqual, "keysEqual");
+  __name(objectEqual, "objectEqual");
+  __name(isPrimitive, "isPrimitive");
+  __name(mapSymbols, "mapSymbols");
+  __name(hasProperty, "hasProperty");
+  __name(parsePath, "parsePath");
+  __name(internalGetPathValue, "internalGetPathValue");
+  __name(getPathInfo, "getPathInfo");
+  __name(_Assertion, "Assertion");
+  Assertion = _Assertion;
+  events = new EventTarget;
+  _PluginEvent = class _PluginEvent2 extends Event {
+    constructor(type3, name, fn) {
+      super(type3);
+      this.name = String(name);
+      this.fn = fn;
+    }
+  };
+  __name(_PluginEvent, "PluginEvent");
+  PluginEvent = _PluginEvent;
+  __name(isProxyEnabled, "isProxyEnabled");
+  __name(addProperty, "addProperty");
+  fnLengthDesc = Object.getOwnPropertyDescriptor(function() {}, "length");
+  __name(addLengthGuard, "addLengthGuard");
+  __name(getProperties, "getProperties");
+  builtins = ["__flags", "__methods", "_obj", "assert"];
+  __name(proxify, "proxify");
+  __name(stringDistanceCapped, "stringDistanceCapped");
+  __name(addMethod, "addMethod");
+  __name(overwriteProperty, "overwriteProperty");
+  __name(overwriteMethod, "overwriteMethod");
+  canSetPrototype = typeof Object.setPrototypeOf === "function";
+  testFn = /* @__PURE__ */ __name(function() {}, "testFn");
+  excludeNames = Object.getOwnPropertyNames(testFn).filter(function(name) {
+    let propDesc = Object.getOwnPropertyDescriptor(testFn, name);
+    if (typeof propDesc !== "object")
+      return true;
+    return !propDesc.configurable;
+  });
+  call = Function.prototype.call;
+  apply = Function.prototype.apply;
+  _PluginAddChainableMethodEvent = class _PluginAddChainableMethodEvent2 extends PluginEvent {
+    constructor(type3, name, fn, chainingBehavior) {
+      super(type3, name, fn);
+      this.chainingBehavior = chainingBehavior;
+    }
+  };
+  __name(_PluginAddChainableMethodEvent, "PluginAddChainableMethodEvent");
+  PluginAddChainableMethodEvent = _PluginAddChainableMethodEvent;
+  __name(addChainableMethod, "addChainableMethod");
+  __name(overwriteChainableMethod, "overwriteChainableMethod");
+  __name(compareByInspect, "compareByInspect");
+  __name(getOwnEnumerablePropertySymbols, "getOwnEnumerablePropertySymbols");
+  __name(getOwnEnumerableProperties, "getOwnEnumerableProperties");
+  isNaN2 = Number.isNaN;
+  __name(isObjectType, "isObjectType");
+  __name(getOperator, "getOperator");
+  __name(getName, "getName");
+  __name(isRegExp2, "isRegExp");
+  __name(isNumeric, "isNumeric");
+  ({ flag: flag2 } = utils_exports);
+  [
+    "to",
+    "be",
+    "been",
+    "is",
+    "and",
+    "has",
+    "have",
+    "with",
+    "that",
+    "which",
+    "at",
+    "of",
+    "same",
+    "but",
+    "does",
+    "still",
+    "also"
+  ].forEach(function(chain) {
+    Assertion.addProperty(chain);
+  });
+  Assertion.addProperty("not", function() {
+    flag2(this, "negate", true);
+  });
+  Assertion.addProperty("deep", function() {
+    flag2(this, "deep", true);
+  });
+  Assertion.addProperty("nested", function() {
+    flag2(this, "nested", true);
+  });
+  Assertion.addProperty("own", function() {
+    flag2(this, "own", true);
+  });
+  Assertion.addProperty("ordered", function() {
+    flag2(this, "ordered", true);
+  });
+  Assertion.addProperty("any", function() {
+    flag2(this, "any", true);
+    flag2(this, "all", false);
+  });
+  Assertion.addProperty("all", function() {
+    flag2(this, "all", true);
+    flag2(this, "any", false);
+  });
+  functionTypes = {
+    function: [
+      "function",
+      "asyncfunction",
+      "generatorfunction",
+      "asyncgeneratorfunction"
+    ],
+    asyncfunction: ["asyncfunction", "asyncgeneratorfunction"],
+    generatorfunction: ["generatorfunction", "asyncgeneratorfunction"],
+    asyncgeneratorfunction: ["asyncgeneratorfunction"]
+  };
+  __name(an, "an");
+  Assertion.addChainableMethod("an", an);
+  Assertion.addChainableMethod("a", an);
+  __name(SameValueZero, "SameValueZero");
+  __name(includeChainingBehavior, "includeChainingBehavior");
+  __name(include, "include");
+  Assertion.addChainableMethod("include", include, includeChainingBehavior);
+  Assertion.addChainableMethod("contain", include, includeChainingBehavior);
+  Assertion.addChainableMethod("contains", include, includeChainingBehavior);
+  Assertion.addChainableMethod("includes", include, includeChainingBehavior);
+  Assertion.addProperty("ok", function() {
+    this.assert(flag2(this, "object"), "expected #{this} to be truthy", "expected #{this} to be falsy");
+  });
+  Assertion.addProperty("true", function() {
+    this.assert(flag2(this, "object") === true, "expected #{this} to be true", "expected #{this} to be false", flag2(this, "negate") ? false : true);
+  });
+  Assertion.addProperty("numeric", function() {
+    const object = flag2(this, "object");
+    this.assert(["Number", "BigInt"].includes(type(object)), "expected #{this} to be numeric", "expected #{this} to not be numeric", flag2(this, "negate") ? false : true);
+  });
+  Assertion.addProperty("callable", function() {
+    const val = flag2(this, "object");
+    const ssfi = flag2(this, "ssfi");
+    const message = flag2(this, "message");
+    const msg = message ? `${message}: ` : "";
+    const negate = flag2(this, "negate");
+    const assertionMessage = negate ? `${msg}expected ${inspect2(val)} not to be a callable function` : `${msg}expected ${inspect2(val)} to be a callable function`;
+    const isCallable = [
+      "Function",
+      "AsyncFunction",
+      "GeneratorFunction",
+      "AsyncGeneratorFunction"
+    ].includes(type(val));
+    if (isCallable && negate || !isCallable && !negate) {
+      throw new AssertionError(assertionMessage, undefined, ssfi);
+    }
+  });
+  Assertion.addProperty("false", function() {
+    this.assert(flag2(this, "object") === false, "expected #{this} to be false", "expected #{this} to be true", flag2(this, "negate") ? true : false);
+  });
+  Assertion.addProperty("null", function() {
+    this.assert(flag2(this, "object") === null, "expected #{this} to be null", "expected #{this} not to be null");
+  });
+  Assertion.addProperty("undefined", function() {
+    this.assert(flag2(this, "object") === undefined, "expected #{this} to be undefined", "expected #{this} not to be undefined");
+  });
+  Assertion.addProperty("NaN", function() {
+    this.assert(isNaN2(flag2(this, "object")), "expected #{this} to be NaN", "expected #{this} not to be NaN");
+  });
+  __name(assertExist, "assertExist");
+  Assertion.addProperty("exist", assertExist);
+  Assertion.addProperty("exists", assertExist);
+  Assertion.addProperty("empty", function() {
+    let val = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), itemsCount;
+    flagMsg = flagMsg ? flagMsg + ": " : "";
+    switch (type(val).toLowerCase()) {
+      case "array":
+      case "string":
+        itemsCount = val.length;
+        break;
+      case "map":
+      case "set":
+        itemsCount = val.size;
+        break;
+      case "weakmap":
+      case "weakset":
+        throw new AssertionError(flagMsg + ".empty was passed a weak collection", undefined, ssfi);
+      case "function": {
+        const msg = flagMsg + ".empty was passed a function " + getName(val);
+        throw new AssertionError(msg.trim(), undefined, ssfi);
+      }
+      default:
+        if (val !== Object(val)) {
+          throw new AssertionError(flagMsg + ".empty was passed non-string primitive " + inspect2(val), undefined, ssfi);
+        }
+        itemsCount = Object.keys(val).length;
+    }
+    this.assert(itemsCount === 0, "expected #{this} to be empty", "expected #{this} not to be empty");
+  });
+  __name(checkArguments, "checkArguments");
+  Assertion.addProperty("arguments", checkArguments);
+  Assertion.addProperty("Arguments", checkArguments);
+  __name(assertEqual, "assertEqual");
+  Assertion.addMethod("equal", assertEqual);
+  Assertion.addMethod("equals", assertEqual);
+  Assertion.addMethod("eq", assertEqual);
+  __name(assertEql, "assertEql");
+  Assertion.addMethod("eql", assertEql);
+  Assertion.addMethod("eqls", assertEql);
+  __name(assertAbove, "assertAbove");
+  Assertion.addMethod("above", assertAbove);
+  Assertion.addMethod("gt", assertAbove);
+  Assertion.addMethod("greaterThan", assertAbove);
+  __name(assertLeast, "assertLeast");
+  Assertion.addMethod("least", assertLeast);
+  Assertion.addMethod("gte", assertLeast);
+  Assertion.addMethod("greaterThanOrEqual", assertLeast);
+  __name(assertBelow, "assertBelow");
+  Assertion.addMethod("below", assertBelow);
+  Assertion.addMethod("lt", assertBelow);
+  Assertion.addMethod("lessThan", assertBelow);
+  __name(assertMost, "assertMost");
+  Assertion.addMethod("most", assertMost);
+  Assertion.addMethod("lte", assertMost);
+  Assertion.addMethod("lessThanOrEqual", assertMost);
+  Assertion.addMethod("within", function(start, finish, msg) {
+    if (msg)
+      flag2(this, "message", msg);
+    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;
+    if (doLength && objType !== "map" && objType !== "set") {
+      new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
+    }
+    if (!doLength && objType === "date" && (startType !== "date" || finishType !== "date")) {
+      errorMessage = msgPrefix + "the arguments to within must be dates";
+    } else if ((!isNumeric(start) || !isNumeric(finish)) && (doLength || isNumeric(obj))) {
+      errorMessage = msgPrefix + "the arguments to within must be numbers";
+    } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
+      let printObj = objType === "string" ? "'" + obj + "'" : obj;
+      errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
+    } else {
+      shouldThrow = false;
+    }
+    if (shouldThrow) {
+      throw new AssertionError(errorMessage, undefined, ssfi);
+    }
+    if (doLength) {
+      let descriptor = "length", itemsCount;
+      if (objType === "map" || objType === "set") {
+        descriptor = "size";
+        itemsCount = obj.size;
+      } else {
+        itemsCount = obj.length;
+      }
+      this.assert(itemsCount >= start && itemsCount <= finish, "expected #{this} to have a " + descriptor + " within " + range, "expected #{this} to not have a " + descriptor + " within " + range);
+    } else {
+      this.assert(obj >= start && obj <= finish, "expected #{this} to be within " + range, "expected #{this} to not be within " + range);
+    }
+  });
+  __name(assertInstanceOf, "assertInstanceOf");
+  Assertion.addMethod("instanceof", assertInstanceOf);
+  Assertion.addMethod("instanceOf", assertInstanceOf);
+  __name(assertProperty, "assertProperty");
+  Assertion.addMethod("property", assertProperty);
+  __name(assertOwnProperty, "assertOwnProperty");
+  Assertion.addMethod("ownProperty", assertOwnProperty);
+  Assertion.addMethod("haveOwnProperty", assertOwnProperty);
+  __name(assertOwnPropertyDescriptor, "assertOwnPropertyDescriptor");
+  Assertion.addMethod("ownPropertyDescriptor", assertOwnPropertyDescriptor);
+  Assertion.addMethod("haveOwnPropertyDescriptor", assertOwnPropertyDescriptor);
+  __name(assertLengthChain, "assertLengthChain");
+  __name(assertLength, "assertLength");
+  Assertion.addChainableMethod("length", assertLength, assertLengthChain);
+  Assertion.addChainableMethod("lengthOf", assertLength, assertLengthChain);
+  __name(assertMatch, "assertMatch");
+  Assertion.addMethod("match", assertMatch);
+  Assertion.addMethod("matches", assertMatch);
+  Assertion.addMethod("string", function(str, msg) {
+    if (msg)
+      flag2(this, "message", msg);
+    let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+    new Assertion(obj, flagMsg, ssfi, true).is.a("string");
+    this.assert(~obj.indexOf(str), "expected #{this} to contain " + inspect2(str), "expected #{this} to not contain " + inspect2(str));
+  });
+  __name(assertKeys, "assertKeys");
+  Assertion.addMethod("keys", assertKeys);
+  Assertion.addMethod("key", assertKeys);
+  __name(assertThrows, "assertThrows");
+  Assertion.addMethod("throw", assertThrows);
+  Assertion.addMethod("throws", assertThrows);
+  Assertion.addMethod("Throw", assertThrows);
+  __name(respondTo, "respondTo");
+  Assertion.addMethod("respondTo", respondTo);
+  Assertion.addMethod("respondsTo", respondTo);
+  Assertion.addProperty("itself", function() {
+    flag2(this, "itself", true);
+  });
+  __name(satisfy, "satisfy");
+  Assertion.addMethod("satisfy", satisfy);
+  Assertion.addMethod("satisfies", satisfy);
+  __name(closeTo, "closeTo");
+  Assertion.addMethod("closeTo", closeTo);
+  Assertion.addMethod("approximately", closeTo);
+  __name(isSubsetOf, "isSubsetOf");
+  Assertion.addMethod("members", function(subset, msg) {
+    if (msg)
+      flag2(this, "message", msg);
+    let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+    new Assertion(obj, flagMsg, ssfi, true).to.be.iterable;
+    new Assertion(subset, flagMsg, ssfi, true).to.be.iterable;
+    let contains = flag2(this, "contains");
+    let ordered = flag2(this, "ordered");
+    let subject, failMsg, failNegateMsg;
+    if (contains) {
+      subject = ordered ? "an ordered superset" : "a superset";
+      failMsg = "expected #{this} to be " + subject + " of #{exp}";
+      failNegateMsg = "expected #{this} to not be " + subject + " of #{exp}";
+    } else {
+      subject = ordered ? "ordered members" : "members";
+      failMsg = "expected #{this} to have the same " + subject + " as #{exp}";
+      failNegateMsg = "expected #{this} to not have the same " + subject + " as #{exp}";
+    }
+    let cmp = flag2(this, "deep") ? flag2(this, "eql") : undefined;
+    this.assert(isSubsetOf(subset, obj, cmp, contains, ordered), failMsg, failNegateMsg, subset, obj, true);
+  });
+  Assertion.addProperty("iterable", function(msg) {
+    if (msg)
+      flag2(this, "message", msg);
+    let obj = flag2(this, "object");
+    this.assert(obj != null && obj[Symbol.iterator], "expected #{this} to be an iterable", "expected #{this} to not be an iterable", obj);
+  });
+  __name(oneOf, "oneOf");
+  Assertion.addMethod("oneOf", oneOf);
+  __name(assertChanges, "assertChanges");
+  Assertion.addMethod("change", assertChanges);
+  Assertion.addMethod("changes", assertChanges);
+  __name(assertIncreases, "assertIncreases");
+  Assertion.addMethod("increase", assertIncreases);
+  Assertion.addMethod("increases", assertIncreases);
+  __name(assertDecreases, "assertDecreases");
+  Assertion.addMethod("decrease", assertDecreases);
+  Assertion.addMethod("decreases", assertDecreases);
+  __name(assertDelta, "assertDelta");
+  Assertion.addMethod("by", assertDelta);
+  Assertion.addProperty("extensible", function() {
+    let obj = flag2(this, "object");
+    let isExtensible = obj === Object(obj) && Object.isExtensible(obj);
+    this.assert(isExtensible, "expected #{this} to be extensible", "expected #{this} to not be extensible");
+  });
+  Assertion.addProperty("sealed", function() {
+    let obj = flag2(this, "object");
+    let isSealed = obj === Object(obj) ? Object.isSealed(obj) : true;
+    this.assert(isSealed, "expected #{this} to be sealed", "expected #{this} to not be sealed");
+  });
+  Assertion.addProperty("frozen", function() {
+    let obj = flag2(this, "object");
+    let isFrozen = obj === Object(obj) ? Object.isFrozen(obj) : true;
+    this.assert(isFrozen, "expected #{this} to be frozen", "expected #{this} to not be frozen");
+  });
+  Assertion.addProperty("finite", function(_msg) {
+    let obj = flag2(this, "object");
+    this.assert(typeof obj === "number" && isFinite(obj), "expected #{this} to be a finite number", "expected #{this} to not be a finite number");
+  });
+  __name(compareSubset, "compareSubset");
+  Assertion.addMethod("containSubset", function(expected) {
+    const actual = flag(this, "object");
+    const showDiff = config.showDiff;
+    this.assert(compareSubset(expected, actual), "expected #{act} to contain subset #{exp}", "expected #{act} to not contain subset #{exp}", expected, actual, showDiff);
+  });
+  __name(expect, "expect");
+  expect.fail = function(actual, expected, message, operator) {
+    if (arguments.length < 2) {
+      message = actual;
+      actual = undefined;
+    }
+    message = message || "expect.fail()";
+    throw new AssertionError(message, {
+      actual,
+      expected,
+      operator
+    }, expect.fail);
+  };
+  should_exports = {};
+  __export2(should_exports, {
+    Should: () => Should,
+    should: () => should
+  });
+  __name(loadShould, "loadShould");
+  should = loadShould;
+  Should = loadShould;
+  __name(assert, "assert");
+  assert.fail = function(actual, expected, message, operator) {
+    if (arguments.length < 2) {
+      message = actual;
+      actual = undefined;
+    }
+    message = message || "assert.fail()";
+    throw new AssertionError(message, {
+      actual,
+      expected,
+      operator
+    }, assert.fail);
+  };
+  assert.isOk = function(val, msg) {
+    new Assertion(val, msg, assert.isOk, true).is.ok;
+  };
+  assert.isNotOk = function(val, msg) {
+    new Assertion(val, msg, assert.isNotOk, true).is.not.ok;
+  };
+  assert.equal = function(act, exp, msg) {
+    let test2 = new Assertion(act, msg, assert.equal, true);
+    test2.assert(exp == flag(test2, "object"), "expected #{this} to equal #{exp}", "expected #{this} to not equal #{act}", exp, act, true);
+  };
+  assert.notEqual = function(act, exp, msg) {
+    let test2 = new Assertion(act, msg, assert.notEqual, true);
+    test2.assert(exp != flag(test2, "object"), "expected #{this} to not equal #{exp}", "expected #{this} to equal #{act}", exp, act, true);
+  };
+  assert.strictEqual = function(act, exp, msg) {
+    new Assertion(act, msg, assert.strictEqual, true).to.equal(exp);
+  };
+  assert.notStrictEqual = function(act, exp, msg) {
+    new Assertion(act, msg, assert.notStrictEqual, true).to.not.equal(exp);
+  };
+  assert.deepEqual = assert.deepStrictEqual = function(act, exp, msg) {
+    new Assertion(act, msg, assert.deepEqual, true).to.eql(exp);
+  };
+  assert.notDeepEqual = function(act, exp, msg) {
+    new Assertion(act, msg, assert.notDeepEqual, true).to.not.eql(exp);
+  };
+  assert.isAbove = function(val, abv, msg) {
+    new Assertion(val, msg, assert.isAbove, true).to.be.above(abv);
+  };
+  assert.isAtLeast = function(val, atlst, msg) {
+    new Assertion(val, msg, assert.isAtLeast, true).to.be.least(atlst);
+  };
+  assert.isBelow = function(val, blw, msg) {
+    new Assertion(val, msg, assert.isBelow, true).to.be.below(blw);
+  };
+  assert.isAtMost = function(val, atmst, msg) {
+    new Assertion(val, msg, assert.isAtMost, true).to.be.most(atmst);
+  };
+  assert.isTrue = function(val, msg) {
+    new Assertion(val, msg, assert.isTrue, true).is["true"];
+  };
+  assert.isNotTrue = function(val, msg) {
+    new Assertion(val, msg, assert.isNotTrue, true).to.not.equal(true);
+  };
+  assert.isFalse = function(val, msg) {
+    new Assertion(val, msg, assert.isFalse, true).is["false"];
+  };
+  assert.isNotFalse = function(val, msg) {
+    new Assertion(val, msg, assert.isNotFalse, true).to.not.equal(false);
+  };
+  assert.isNull = function(val, msg) {
+    new Assertion(val, msg, assert.isNull, true).to.equal(null);
+  };
+  assert.isNotNull = function(val, msg) {
+    new Assertion(val, msg, assert.isNotNull, true).to.not.equal(null);
+  };
+  assert.isNaN = function(val, msg) {
+    new Assertion(val, msg, assert.isNaN, true).to.be.NaN;
+  };
+  assert.isNotNaN = function(value, message) {
+    new Assertion(value, message, assert.isNotNaN, true).not.to.be.NaN;
+  };
+  assert.exists = function(val, msg) {
+    new Assertion(val, msg, assert.exists, true).to.exist;
+  };
+  assert.notExists = function(val, msg) {
+    new Assertion(val, msg, assert.notExists, true).to.not.exist;
+  };
+  assert.isUndefined = function(val, msg) {
+    new Assertion(val, msg, assert.isUndefined, true).to.equal(undefined);
+  };
+  assert.isDefined = function(val, msg) {
+    new Assertion(val, msg, assert.isDefined, true).to.not.equal(undefined);
+  };
+  assert.isCallable = function(value, message) {
+    new Assertion(value, message, assert.isCallable, true).is.callable;
+  };
+  assert.isNotCallable = function(value, message) {
+    new Assertion(value, message, assert.isNotCallable, true).is.not.callable;
+  };
+  assert.isObject = function(val, msg) {
+    new Assertion(val, msg, assert.isObject, true).to.be.a("object");
+  };
+  assert.isNotObject = function(val, msg) {
+    new Assertion(val, msg, assert.isNotObject, true).to.not.be.a("object");
+  };
+  assert.isArray = function(val, msg) {
+    new Assertion(val, msg, assert.isArray, true).to.be.an("array");
+  };
+  assert.isNotArray = function(val, msg) {
+    new Assertion(val, msg, assert.isNotArray, true).to.not.be.an("array");
+  };
+  assert.isString = function(val, msg) {
+    new Assertion(val, msg, assert.isString, true).to.be.a("string");
+  };
+  assert.isNotString = function(val, msg) {
+    new Assertion(val, msg, assert.isNotString, true).to.not.be.a("string");
+  };
+  assert.isNumber = function(val, msg) {
+    new Assertion(val, msg, assert.isNumber, true).to.be.a("number");
+  };
+  assert.isNotNumber = function(val, msg) {
+    new Assertion(val, msg, assert.isNotNumber, true).to.not.be.a("number");
+  };
+  assert.isNumeric = function(val, msg) {
+    new Assertion(val, msg, assert.isNumeric, true).is.numeric;
+  };
+  assert.isNotNumeric = function(val, msg) {
+    new Assertion(val, msg, assert.isNotNumeric, true).is.not.numeric;
+  };
+  assert.isFinite = function(val, msg) {
+    new Assertion(val, msg, assert.isFinite, true).to.be.finite;
+  };
+  assert.isBoolean = function(val, msg) {
+    new Assertion(val, msg, assert.isBoolean, true).to.be.a("boolean");
+  };
+  assert.isNotBoolean = function(val, msg) {
+    new Assertion(val, msg, assert.isNotBoolean, true).to.not.be.a("boolean");
+  };
+  assert.typeOf = function(val, type3, msg) {
+    new Assertion(val, msg, assert.typeOf, true).to.be.a(type3);
+  };
+  assert.notTypeOf = function(value, type3, message) {
+    new Assertion(value, message, assert.notTypeOf, true).to.not.be.a(type3);
+  };
+  assert.instanceOf = function(val, type3, msg) {
+    new Assertion(val, msg, assert.instanceOf, true).to.be.instanceOf(type3);
+  };
+  assert.notInstanceOf = function(val, type3, msg) {
+    new Assertion(val, msg, assert.notInstanceOf, true).to.not.be.instanceOf(type3);
+  };
+  assert.include = function(exp, inc, msg) {
+    new Assertion(exp, msg, assert.include, true).include(inc);
+  };
+  assert.notInclude = function(exp, inc, msg) {
+    new Assertion(exp, msg, assert.notInclude, true).not.include(inc);
+  };
+  assert.deepInclude = function(exp, inc, msg) {
+    new Assertion(exp, msg, assert.deepInclude, true).deep.include(inc);
+  };
+  assert.notDeepInclude = function(exp, inc, msg) {
+    new Assertion(exp, msg, assert.notDeepInclude, true).not.deep.include(inc);
+  };
+  assert.nestedInclude = function(exp, inc, msg) {
+    new Assertion(exp, msg, assert.nestedInclude, true).nested.include(inc);
+  };
+  assert.notNestedInclude = function(exp, inc, msg) {
+    new Assertion(exp, msg, assert.notNestedInclude, true).not.nested.include(inc);
+  };
+  assert.deepNestedInclude = function(exp, inc, msg) {
+    new Assertion(exp, msg, assert.deepNestedInclude, true).deep.nested.include(inc);
+  };
+  assert.notDeepNestedInclude = function(exp, inc, msg) {
+    new Assertion(exp, msg, assert.notDeepNestedInclude, true).not.deep.nested.include(inc);
+  };
+  assert.ownInclude = function(exp, inc, msg) {
+    new Assertion(exp, msg, assert.ownInclude, true).own.include(inc);
+  };
+  assert.notOwnInclude = function(exp, inc, msg) {
+    new Assertion(exp, msg, assert.notOwnInclude, true).not.own.include(inc);
+  };
+  assert.deepOwnInclude = function(exp, inc, msg) {
+    new Assertion(exp, msg, assert.deepOwnInclude, true).deep.own.include(inc);
+  };
+  assert.notDeepOwnInclude = function(exp, inc, msg) {
+    new Assertion(exp, msg, assert.notDeepOwnInclude, true).not.deep.own.include(inc);
+  };
+  assert.match = function(exp, re, msg) {
+    new Assertion(exp, msg, assert.match, true).to.match(re);
+  };
+  assert.notMatch = function(exp, re, msg) {
+    new Assertion(exp, msg, assert.notMatch, true).to.not.match(re);
+  };
+  assert.property = function(obj, prop, msg) {
+    new Assertion(obj, msg, assert.property, true).to.have.property(prop);
+  };
+  assert.notProperty = function(obj, prop, msg) {
+    new Assertion(obj, msg, assert.notProperty, true).to.not.have.property(prop);
+  };
+  assert.propertyVal = function(obj, prop, val, msg) {
+    new Assertion(obj, msg, assert.propertyVal, true).to.have.property(prop, val);
+  };
+  assert.notPropertyVal = function(obj, prop, val, msg) {
+    new Assertion(obj, msg, assert.notPropertyVal, true).to.not.have.property(prop, val);
+  };
+  assert.deepPropertyVal = function(obj, prop, val, msg) {
+    new Assertion(obj, msg, assert.deepPropertyVal, true).to.have.deep.property(prop, val);
+  };
+  assert.notDeepPropertyVal = function(obj, prop, val, msg) {
+    new Assertion(obj, msg, assert.notDeepPropertyVal, true).to.not.have.deep.property(prop, val);
+  };
+  assert.ownProperty = function(obj, prop, msg) {
+    new Assertion(obj, msg, assert.ownProperty, true).to.have.own.property(prop);
+  };
+  assert.notOwnProperty = function(obj, prop, msg) {
+    new Assertion(obj, msg, assert.notOwnProperty, true).to.not.have.own.property(prop);
+  };
+  assert.ownPropertyVal = function(obj, prop, value, msg) {
+    new Assertion(obj, msg, assert.ownPropertyVal, true).to.have.own.property(prop, value);
+  };
+  assert.notOwnPropertyVal = function(obj, prop, value, msg) {
+    new Assertion(obj, msg, assert.notOwnPropertyVal, true).to.not.have.own.property(prop, value);
+  };
+  assert.deepOwnPropertyVal = function(obj, prop, value, msg) {
+    new Assertion(obj, msg, assert.deepOwnPropertyVal, true).to.have.deep.own.property(prop, value);
+  };
+  assert.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
+    new Assertion(obj, msg, assert.notDeepOwnPropertyVal, true).to.not.have.deep.own.property(prop, value);
+  };
+  assert.nestedProperty = function(obj, prop, msg) {
+    new Assertion(obj, msg, assert.nestedProperty, true).to.have.nested.property(prop);
+  };
+  assert.notNestedProperty = function(obj, prop, msg) {
+    new Assertion(obj, msg, assert.notNestedProperty, true).to.not.have.nested.property(prop);
+  };
+  assert.nestedPropertyVal = function(obj, prop, val, msg) {
+    new Assertion(obj, msg, assert.nestedPropertyVal, true).to.have.nested.property(prop, val);
+  };
+  assert.notNestedPropertyVal = function(obj, prop, val, msg) {
+    new Assertion(obj, msg, assert.notNestedPropertyVal, true).to.not.have.nested.property(prop, val);
+  };
+  assert.deepNestedPropertyVal = function(obj, prop, val, msg) {
+    new Assertion(obj, msg, assert.deepNestedPropertyVal, true).to.have.deep.nested.property(prop, val);
+  };
+  assert.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
+    new Assertion(obj, msg, assert.notDeepNestedPropertyVal, true).to.not.have.deep.nested.property(prop, val);
+  };
+  assert.lengthOf = function(exp, len, msg) {
+    new Assertion(exp, msg, assert.lengthOf, true).to.have.lengthOf(len);
+  };
+  assert.hasAnyKeys = function(obj, keys, msg) {
+    new Assertion(obj, msg, assert.hasAnyKeys, true).to.have.any.keys(keys);
+  };
+  assert.hasAllKeys = function(obj, keys, msg) {
+    new Assertion(obj, msg, assert.hasAllKeys, true).to.have.all.keys(keys);
+  };
+  assert.containsAllKeys = function(obj, keys, msg) {
+    new Assertion(obj, msg, assert.containsAllKeys, true).to.contain.all.keys(keys);
+  };
+  assert.doesNotHaveAnyKeys = function(obj, keys, msg) {
+    new Assertion(obj, msg, assert.doesNotHaveAnyKeys, true).to.not.have.any.keys(keys);
+  };
+  assert.doesNotHaveAllKeys = function(obj, keys, msg) {
+    new Assertion(obj, msg, assert.doesNotHaveAllKeys, true).to.not.have.all.keys(keys);
+  };
+  assert.hasAnyDeepKeys = function(obj, keys, msg) {
+    new Assertion(obj, msg, assert.hasAnyDeepKeys, true).to.have.any.deep.keys(keys);
+  };
+  assert.hasAllDeepKeys = function(obj, keys, msg) {
+    new Assertion(obj, msg, assert.hasAllDeepKeys, true).to.have.all.deep.keys(keys);
+  };
+  assert.containsAllDeepKeys = function(obj, keys, msg) {
+    new Assertion(obj, msg, assert.containsAllDeepKeys, true).to.contain.all.deep.keys(keys);
+  };
+  assert.doesNotHaveAnyDeepKeys = function(obj, keys, msg) {
+    new Assertion(obj, msg, assert.doesNotHaveAnyDeepKeys, true).to.not.have.any.deep.keys(keys);
+  };
+  assert.doesNotHaveAllDeepKeys = function(obj, keys, msg) {
+    new Assertion(obj, msg, assert.doesNotHaveAllDeepKeys, true).to.not.have.all.deep.keys(keys);
+  };
+  assert.throws = function(fn, errorLike, errMsgMatcher, msg) {
+    if (typeof errorLike === "string" || errorLike instanceof RegExp) {
+      errMsgMatcher = errorLike;
+      errorLike = null;
+    }
+    let assertErr = new Assertion(fn, msg, assert.throws, true).to.throw(errorLike, errMsgMatcher);
+    return flag(assertErr, "object");
+  };
+  assert.doesNotThrow = function(fn, errorLike, errMsgMatcher, message) {
+    if (typeof errorLike === "string" || errorLike instanceof RegExp) {
+      errMsgMatcher = errorLike;
+      errorLike = null;
+    }
+    new Assertion(fn, message, assert.doesNotThrow, true).to.not.throw(errorLike, errMsgMatcher);
+  };
+  assert.operator = function(val, operator, val2, msg) {
+    let ok;
+    switch (operator) {
+      case "==":
+        ok = val == val2;
+        break;
+      case "===":
+        ok = val === val2;
+        break;
+      case ">":
+        ok = val > val2;
+        break;
+      case ">=":
+        ok = val >= val2;
+        break;
+      case "<":
+        ok = val < val2;
+        break;
+      case "<=":
+        ok = val <= val2;
+        break;
+      case "!=":
+        ok = val != val2;
+        break;
+      case "!==":
+        ok = val !== val2;
+        break;
+      default:
+        msg = msg ? msg + ": " : msg;
+        throw new AssertionError(msg + 'Invalid operator "' + operator + '"', undefined, assert.operator);
+    }
+    let test2 = new Assertion(ok, msg, assert.operator, true);
+    test2.assert(flag(test2, "object") === true, "expected " + inspect2(val) + " to be " + operator + " " + inspect2(val2), "expected " + inspect2(val) + " to not be " + operator + " " + inspect2(val2));
+  };
+  assert.closeTo = function(act, exp, delta, msg) {
+    new Assertion(act, msg, assert.closeTo, true).to.be.closeTo(exp, delta);
+  };
+  assert.approximately = function(act, exp, delta, msg) {
+    new Assertion(act, msg, assert.approximately, true).to.be.approximately(exp, delta);
+  };
+  assert.sameMembers = function(set1, set2, msg) {
+    new Assertion(set1, msg, assert.sameMembers, true).to.have.same.members(set2);
+  };
+  assert.notSameMembers = function(set1, set2, msg) {
+    new Assertion(set1, msg, assert.notSameMembers, true).to.not.have.same.members(set2);
+  };
+  assert.sameDeepMembers = function(set1, set2, msg) {
+    new Assertion(set1, msg, assert.sameDeepMembers, true).to.have.same.deep.members(set2);
+  };
+  assert.notSameDeepMembers = function(set1, set2, msg) {
+    new Assertion(set1, msg, assert.notSameDeepMembers, true).to.not.have.same.deep.members(set2);
+  };
+  assert.sameOrderedMembers = function(set1, set2, msg) {
+    new Assertion(set1, msg, assert.sameOrderedMembers, true).to.have.same.ordered.members(set2);
+  };
+  assert.notSameOrderedMembers = function(set1, set2, msg) {
+    new Assertion(set1, msg, assert.notSameOrderedMembers, true).to.not.have.same.ordered.members(set2);
+  };
+  assert.sameDeepOrderedMembers = function(set1, set2, msg) {
+    new Assertion(set1, msg, assert.sameDeepOrderedMembers, true).to.have.same.deep.ordered.members(set2);
+  };
+  assert.notSameDeepOrderedMembers = function(set1, set2, msg) {
+    new Assertion(set1, msg, assert.notSameDeepOrderedMembers, true).to.not.have.same.deep.ordered.members(set2);
+  };
+  assert.includeMembers = function(superset, subset, msg) {
+    new Assertion(superset, msg, assert.includeMembers, true).to.include.members(subset);
+  };
+  assert.notIncludeMembers = function(superset, subset, msg) {
+    new Assertion(superset, msg, assert.notIncludeMembers, true).to.not.include.members(subset);
+  };
+  assert.includeDeepMembers = function(superset, subset, msg) {
+    new Assertion(superset, msg, assert.includeDeepMembers, true).to.include.deep.members(subset);
+  };
+  assert.notIncludeDeepMembers = function(superset, subset, msg) {
+    new Assertion(superset, msg, assert.notIncludeDeepMembers, true).to.not.include.deep.members(subset);
+  };
+  assert.includeOrderedMembers = function(superset, subset, msg) {
+    new Assertion(superset, msg, assert.includeOrderedMembers, true).to.include.ordered.members(subset);
+  };
+  assert.notIncludeOrderedMembers = function(superset, subset, msg) {
+    new Assertion(superset, msg, assert.notIncludeOrderedMembers, true).to.not.include.ordered.members(subset);
+  };
+  assert.includeDeepOrderedMembers = function(superset, subset, msg) {
+    new Assertion(superset, msg, assert.includeDeepOrderedMembers, true).to.include.deep.ordered.members(subset);
+  };
+  assert.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
+    new Assertion(superset, msg, assert.notIncludeDeepOrderedMembers, true).to.not.include.deep.ordered.members(subset);
+  };
+  assert.oneOf = function(inList, list, msg) {
+    new Assertion(inList, msg, assert.oneOf, true).to.be.oneOf(list);
+  };
+  assert.isIterable = function(obj, msg) {
+    if (obj == undefined || !obj[Symbol.iterator]) {
+      msg = msg ? `${msg} expected ${inspect2(obj)} to be an iterable` : `expected ${inspect2(obj)} to be an iterable`;
+      throw new AssertionError(msg, undefined, assert.isIterable);
+    }
+  };
+  assert.changes = function(fn, obj, prop, msg) {
+    if (arguments.length === 3 && typeof obj === "function") {
+      msg = prop;
+      prop = null;
+    }
+    new Assertion(fn, msg, assert.changes, true).to.change(obj, prop);
+  };
+  assert.changesBy = function(fn, obj, prop, delta, msg) {
+    if (arguments.length === 4 && typeof obj === "function") {
+      let tmpMsg = delta;
+      delta = prop;
+      msg = tmpMsg;
+    } else if (arguments.length === 3) {
+      delta = prop;
+      prop = null;
+    }
+    new Assertion(fn, msg, assert.changesBy, true).to.change(obj, prop).by(delta);
+  };
+  assert.doesNotChange = function(fn, obj, prop, msg) {
+    if (arguments.length === 3 && typeof obj === "function") {
+      msg = prop;
+      prop = null;
+    }
+    return new Assertion(fn, msg, assert.doesNotChange, true).to.not.change(obj, prop);
+  };
+  assert.changesButNotBy = function(fn, obj, prop, delta, msg) {
+    if (arguments.length === 4 && typeof obj === "function") {
+      let tmpMsg = delta;
+      delta = prop;
+      msg = tmpMsg;
+    } else if (arguments.length === 3) {
+      delta = prop;
+      prop = null;
+    }
+    new Assertion(fn, msg, assert.changesButNotBy, true).to.change(obj, prop).but.not.by(delta);
+  };
+  assert.increases = function(fn, obj, prop, msg) {
+    if (arguments.length === 3 && typeof obj === "function") {
+      msg = prop;
+      prop = null;
+    }
+    return new Assertion(fn, msg, assert.increases, true).to.increase(obj, prop);
+  };
+  assert.increasesBy = function(fn, obj, prop, delta, msg) {
+    if (arguments.length === 4 && typeof obj === "function") {
+      let tmpMsg = delta;
+      delta = prop;
+      msg = tmpMsg;
+    } else if (arguments.length === 3) {
+      delta = prop;
+      prop = null;
+    }
+    new Assertion(fn, msg, assert.increasesBy, true).to.increase(obj, prop).by(delta);
+  };
+  assert.doesNotIncrease = function(fn, obj, prop, msg) {
+    if (arguments.length === 3 && typeof obj === "function") {
+      msg = prop;
+      prop = null;
+    }
+    return new Assertion(fn, msg, assert.doesNotIncrease, true).to.not.increase(obj, prop);
+  };
+  assert.increasesButNotBy = function(fn, obj, prop, delta, msg) {
+    if (arguments.length === 4 && typeof obj === "function") {
+      let tmpMsg = delta;
+      delta = prop;
+      msg = tmpMsg;
+    } else if (arguments.length === 3) {
+      delta = prop;
+      prop = null;
+    }
+    new Assertion(fn, msg, assert.increasesButNotBy, true).to.increase(obj, prop).but.not.by(delta);
+  };
+  assert.decreases = function(fn, obj, prop, msg) {
+    if (arguments.length === 3 && typeof obj === "function") {
+      msg = prop;
+      prop = null;
+    }
+    return new Assertion(fn, msg, assert.decreases, true).to.decrease(obj, prop);
+  };
+  assert.decreasesBy = function(fn, obj, prop, delta, msg) {
+    if (arguments.length === 4 && typeof obj === "function") {
+      let tmpMsg = delta;
+      delta = prop;
+      msg = tmpMsg;
+    } else if (arguments.length === 3) {
+      delta = prop;
+      prop = null;
+    }
+    new Assertion(fn, msg, assert.decreasesBy, true).to.decrease(obj, prop).by(delta);
+  };
+  assert.doesNotDecrease = function(fn, obj, prop, msg) {
+    if (arguments.length === 3 && typeof obj === "function") {
+      msg = prop;
+      prop = null;
+    }
+    return new Assertion(fn, msg, assert.doesNotDecrease, true).to.not.decrease(obj, prop);
+  };
+  assert.doesNotDecreaseBy = function(fn, obj, prop, delta, msg) {
+    if (arguments.length === 4 && typeof obj === "function") {
+      let tmpMsg = delta;
+      delta = prop;
+      msg = tmpMsg;
+    } else if (arguments.length === 3) {
+      delta = prop;
+      prop = null;
+    }
+    return new Assertion(fn, msg, assert.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta);
+  };
+  assert.decreasesButNotBy = function(fn, obj, prop, delta, msg) {
+    if (arguments.length === 4 && typeof obj === "function") {
+      let tmpMsg = delta;
+      delta = prop;
+      msg = tmpMsg;
+    } else if (arguments.length === 3) {
+      delta = prop;
+      prop = null;
+    }
+    new Assertion(fn, msg, assert.decreasesButNotBy, true).to.decrease(obj, prop).but.not.by(delta);
+  };
+  assert.ifError = function(val) {
+    if (val) {
+      throw val;
+    }
+  };
+  assert.isExtensible = function(obj, msg) {
+    new Assertion(obj, msg, assert.isExtensible, true).to.be.extensible;
+  };
+  assert.isNotExtensible = function(obj, msg) {
+    new Assertion(obj, msg, assert.isNotExtensible, true).to.not.be.extensible;
+  };
+  assert.isSealed = function(obj, msg) {
+    new Assertion(obj, msg, assert.isSealed, true).to.be.sealed;
+  };
+  assert.isNotSealed = function(obj, msg) {
+    new Assertion(obj, msg, assert.isNotSealed, true).to.not.be.sealed;
+  };
+  assert.isFrozen = function(obj, msg) {
+    new Assertion(obj, msg, assert.isFrozen, true).to.be.frozen;
+  };
+  assert.isNotFrozen = function(obj, msg) {
+    new Assertion(obj, msg, assert.isNotFrozen, true).to.not.be.frozen;
+  };
+  assert.isEmpty = function(val, msg) {
+    new Assertion(val, msg, assert.isEmpty, true).to.be.empty;
+  };
+  assert.isNotEmpty = function(val, msg) {
+    new Assertion(val, msg, assert.isNotEmpty, true).to.not.be.empty;
+  };
+  assert.containsSubset = function(val, exp, msg) {
+    new Assertion(val, msg).to.containSubset(exp);
+  };
+  assert.doesNotContainSubset = function(val, exp, msg) {
+    new Assertion(val, msg).to.not.containSubset(exp);
+  };
+  aliases = [
+    ["isOk", "ok"],
+    ["isNotOk", "notOk"],
+    ["throws", "throw"],
+    ["throws", "Throw"],
+    ["isExtensible", "extensible"],
+    ["isNotExtensible", "notExtensible"],
+    ["isSealed", "sealed"],
+    ["isNotSealed", "notSealed"],
+    ["isFrozen", "frozen"],
+    ["isNotFrozen", "notFrozen"],
+    ["isEmpty", "empty"],
+    ["isNotEmpty", "notEmpty"],
+    ["isCallable", "isFunction"],
+    ["isNotCallable", "isNotFunction"],
+    ["containsSubset", "containSubset"]
+  ];
+  for (const [name, as] of aliases) {
+    assert[as] = assert[name];
+  }
+  used = [];
+  __name(use, "use");
+});
+
 // tools/core/results.js
 class ModuleInfo {
   constructor({ path = null, present = new Set, counts = {}, warnings = [] }) {
@@ -118,6 +3408,50 @@ class RenderBatch {
   }
 }
 
+class TestResult {
+  constructor({ title, fullPath, componentName = null, status, durationMs = 0, error = null }) {
+    this.title = title;
+    this.fullPath = fullPath;
+    this.componentName = componentName;
+    this.status = status;
+    this.durationMs = durationMs;
+    this.error = error;
+  }
+}
+
+class DescribeResult {
+  constructor({ title, componentName = null, children = [] }) {
+    this.title = title;
+    this.componentName = componentName;
+    this.children = children;
+  }
+}
+
+class ModuleTestReport {
+  constructor({ path = null, suites = [], counts = { pass: 0, fail: 0, skip: 0, total: 0 } }) {
+    this.path = path;
+    this.suites = suites;
+    this.counts = counts;
+  }
+}
+
+class TestReport {
+  constructor({ modules = [] }) {
+    this.modules = modules;
+  }
+  get totals() {
+    return this.modules.reduce((acc, m) => ({
+      pass: acc.pass + m.counts.pass,
+      fail: acc.fail + m.counts.fail,
+      skip: acc.skip + m.counts.skip,
+      total: acc.total + m.counts.total
+    }), { pass: 0, fail: 0, skip: 0, total: 0 });
+  }
+  get hasFailures() {
+    return this.modules.some((m) => m.counts.fail > 0);
+  }
+}
+
 // tools/core/module.js
 class Example {
   constructor({ title, description = null, value, view = "main", componentName = null }) {
@@ -211,6 +3545,7 @@ function normalizeModule(mod, { path = null } = {}) {
     "getMacros",
     "getRequestHandlers",
     "getExamples",
+    "getTests",
     "getRoot"
   ]) {
     if (typeof mod[key] === "function")
@@ -266,7 +3601,7 @@ function getSignature(name, fn) {
   return `${name}(${params})`;
 }
 function getFieldMethods(field) {
-  const { name, type } = field;
+  const { name, type: type3 } = field;
   const uname = name[0].toUpperCase() + name.slice(1);
   const methods = [
     { name: `set${uname}`, sig: `set${uname}(v)`, desc: "Set value" },
@@ -291,7 +3626,7 @@ function getFieldMethods(field) {
       desc: "Check if not null/undefined"
     }
   ];
-  switch (type) {
+  switch (type3) {
     case "bool":
       methods[0].desc = "Set value (coerces to boolean)";
       methods.push({
@@ -344,7 +3679,7 @@ function getFieldMethods(field) {
       break;
     case "map":
     case "omap": {
-      const label = type === "omap" ? "ordered map" : "map";
+      const label = type3 === "omap" ? "ordered map" : "map";
       methods.push({
         name: `is${uname}Empty`,
         sig: `is${uname}Empty()`,
@@ -567,8 +3902,8 @@ class Path {
     return [new Path(pathSteps.reverse()), handlers];
   }
   static fromEvent(e, rNode, maxDepth, comps, stopOnNoEvent = true) {
-    const { type, target } = e;
-    return Path.fromNodeAndEventName(target, type, rNode, maxDepth, comps, stopOnNoEvent);
+    const { type: type3, target } = e;
+    return Path.fromNodeAndEventName(target, type3, rNode, maxDepth, comps, stopOnNoEvent);
   }
 }
 function parseMetaComment(n) {
@@ -864,8 +4199,8 @@ function getValSubType(s) {
     return open === 1 && close === 1 ? VAL_SUB_TYPE_SEQ_ACCESS : VAL_SUB_TYPE_INVALID;
   return -1;
 }
-var VALID_VAL_ID_RE, isValidValId = (name) => VALID_VAL_ID_RE.test(name), VALID_FLOAT_RE, STR_TPL_SPLIT_RE, parseStrTemplate = (v, px) => StrTplVal.parse(v, px), parseConst = (v, _) => new ConstVal(v), parseName = (v, _) => isValidValId(v) ? new NameVal(v) : null, parseType = (v, _) => isValidValId(v) ? new TypeVal(v) : null, parseBind = (v, _) => isValidValId(v) ? new BindVal(v) : null, parseDyn = (v, _) => isValidValId(v) ? new DynVal(v) : null, parseField = (v, _) => isValidValId(v) ? new FieldVal(v) : null, parseReq = (v, _) => isValidValId(v) ? new RequestVal(v) : null, ConstVal, VarVal, StrTplVal, NameVal, InputHandlerNameVal, AlterHandlerNameVal, mk404Handler = (type, name) => function(...args) {
-  console.warn("handler not found", { type, name, args }, this);
+var VALID_VAL_ID_RE, isValidValId = (name) => VALID_VAL_ID_RE.test(name), VALID_FLOAT_RE, STR_TPL_SPLIT_RE, parseStrTemplate = (v, px) => StrTplVal.parse(v, px), parseConst = (v, _) => new ConstVal(v), parseName = (v, _) => isValidValId(v) ? new NameVal(v) : null, parseType = (v, _) => isValidValId(v) ? new TypeVal(v) : null, parseBind = (v, _) => isValidValId(v) ? new BindVal(v) : null, parseDyn = (v, _) => isValidValId(v) ? new DynVal(v) : null, parseField = (v, _) => isValidValId(v) ? new FieldVal(v) : null, parseReq = (v, _) => isValidValId(v) ? new RequestVal(v) : null, ConstVal, VarVal, StrTplVal, NameVal, InputHandlerNameVal, AlterHandlerNameVal, mk404Handler = (type3, name) => function(...args) {
+  console.warn("handler not found", { type: type3, name, args }, this);
   return this;
 }, TypeVal, RequestVal, RawFieldVal, RenderVal, RenderNameVal, BindVal, DynVal, FieldVal, SeqAccessVal, VAL_SUB_TYPE_STRING_TEMPLATE = 0, VAL_SUB_TYPE_SEQ_ACCESS = 1, VAL_SUB_TYPE_INVALID = 2, VAL_SUB_TYPE_CONST_STRING = 3, vp;
 var init_value = __esm(() => {
@@ -1471,9 +4806,9 @@ class IterInfo {
 }
 
 class ParseContext {
-  constructor(document2, Text, Comment, nodes, events, macroNodes, frame, parent) {
+  constructor(document2, Text, Comment, nodes, events2, macroNodes, frame, parent) {
     this.nodes = nodes ?? [];
-    this.events = events ?? [];
+    this.events = events2 ?? [];
     this.macroNodes = macroNodes ?? [];
     this.parent = parent ?? null;
     this.frame = frame ?? {};
@@ -1487,9 +4822,9 @@ class ParseContext {
     return this.frame.macroName === name || this.parent?.isInsideMacro(name);
   }
   enterMacro(macroName, macroVars, macroSlots) {
-    const { document: document2, Text, Comment, nodes, events, macroNodes } = this;
+    const { document: document2, Text, Comment, nodes, events: events2, macroNodes } = this;
     const frame = { macroName, macroVars, macroSlots };
-    return new ParseContext(document2, Text, Comment, nodes, events, macroNodes, frame, this);
+    return new ParseContext(document2, Text, Comment, nodes, events2, macroNodes, frame, this);
   }
   parseHTML(html) {
     const t = this.document.createElement("template");
@@ -1507,9 +4842,9 @@ class ParseContext {
   }
   registerEvents() {
     const id = this.events.length;
-    const events = new NodeEvents(id);
-    this.events.push(events);
-    return events;
+    const events2 = new NodeEvents(id);
+    this.events.push(events2);
+    return events2;
   }
   newMacroNode(macroName, mAttrs, childs) {
     const anySlot = [];
@@ -2000,10 +5335,10 @@ class Components {
     return comp ? comp.scope.lookupRequest(name) : null;
   }
   compileStyles() {
-    const styles = [];
+    const styles2 = [];
     for (const comp of this.byId.values())
-      styles.push(comp.compileStyle());
-    return styles.join(`
+      styles2.push(comp.compileStyle());
+    return styles2.join(`
 `);
   }
 }
@@ -2019,20 +5354,20 @@ class ComponentStack {
   enter() {
     return new ComponentStack(this.comps, this);
   }
-  registerComponents(comps, aliases = {}) {
+  registerComponents(comps, aliases2 = {}) {
     for (let i = 0;i < comps.length; i++) {
       const comp = comps[i];
       comp.scope = this.enter();
       this.comps.registerComponent(comp);
       this.byName[comp.name] = comp;
     }
-    for (const alias in aliases) {
-      const comp = this.byName[aliases[alias]];
+    for (const alias in aliases2) {
+      const comp = this.byName[aliases2[alias]];
       console.assert(this.byName[alias] === undefined, "alias overrides component", alias);
       if (comp !== undefined)
         this.byName[alias] = comp;
       else
-        console.warn("alias", alias, "to inexistent component", aliases[alias]);
+        console.warn("alias", alias, "to inexistent component", aliases2[alias]);
     }
   }
   registerMacros(macros) {
@@ -3851,8 +7186,8 @@ class LinterCtx {
       return this.startInBody(name, raw, selfClosing, start, endIndex);
     }
     if (name === "input") {
-      const type = (this.getAttr("type") ?? "").toLowerCase();
-      if (type === "hidden")
+      const type3 = (this.getAttr("type") ?? "").toLowerCase();
+      if (type3 === "hidden")
         return;
       this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_WARN, start, {
         tag: raw,
@@ -5310,13 +8645,13 @@ function diffProps(a, b) {
 function morphNode(domNode, source, target, opts) {
   if (source === target || source.isEqualTo(target))
     return domNode;
-  const type = source.nodeType;
-  if (type === target.nodeType) {
-    if (type === 3 || type === 8) {
+  const type3 = source.nodeType;
+  if (type3 === target.nodeType) {
+    if (type3 === 3 || type3 === 8) {
       domNode.data = target.text;
       return domNode;
     }
-    if (type === 1 && source.isSameKind(target)) {
+    if (type3 === 1 && source.isSameKind(target)) {
       const propsDiff = diffProps(source.attrs, target.attrs);
       const isSelect = source.tag === "SELECT";
       if (propsDiff) {
@@ -5332,7 +8667,7 @@ function morphNode(domNode, source, target, opts) {
         applyProperties(domNode, { value: target.attrs.value }, source.attrs);
       return domNode;
     }
-    if (type === 11) {
+    if (type3 === 11) {
       morphChildren(domNode, source.childs, target.childs, opts);
       return domNode;
     }
@@ -5375,18 +8710,18 @@ function morphChildren(parentDom, oldChilds, newChilds, opts) {
     if (key != null)
       oldKeyMap[key] = i;
   }
-  const used = new Uint8Array(oldChilds.length);
+  const used2 = new Uint8Array(oldChilds.length);
   let unkeyedCursor = 0;
   for (let j = 0;j < newChilds.length; j++) {
     const newChild = newChilds[j];
     const newKey = getKey(newChild);
     let oldIdx = -1;
     if (newKey != null) {
-      if (newKey in oldKeyMap && !used[oldKeyMap[newKey]])
+      if (newKey in oldKeyMap && !used2[oldKeyMap[newKey]])
         oldIdx = oldKeyMap[newKey];
     } else {
       while (unkeyedCursor < oldChilds.length) {
-        if (!used[unkeyedCursor] && getKey(oldChilds[unkeyedCursor]) == null) {
+        if (!used2[unkeyedCursor] && getKey(oldChilds[unkeyedCursor]) == null) {
           oldIdx = unkeyedCursor++;
           break;
         }
@@ -5394,7 +8729,7 @@ function morphChildren(parentDom, oldChilds, newChilds, opts) {
       }
     }
     if (oldIdx >= 0) {
-      used[oldIdx] = 1;
+      used2[oldIdx] = 1;
       const newDom = morphNode(domNodes[oldIdx], oldChilds[oldIdx], newChild, opts);
       const ref = parentDom.childNodes[j] ?? null;
       if (newDom !== ref)
@@ -5405,7 +8740,7 @@ function morphChildren(parentDom, oldChilds, newChilds, opts) {
     }
   }
   for (let i = oldChilds.length - 1;i >= 0; i--)
-    if (!used[i] && domNodes[i].parentNode === parentDom)
+    if (!used2[i] && domNodes[i].parentNode === parentDom)
       parentDom.removeChild(domNodes[i]);
 }
 function render(vnode, container, options, prev) {
@@ -5575,27 +8910,27 @@ class App {
     return this.transactor.state;
   }
   handleEvent(e) {
-    const { type } = e;
-    if (type[0] === "t" && type.startsWith("touch")) {
+    const { type: type3 } = e;
+    if (type3[0] === "t" && type3.startsWith("touch")) {
       this._handleTouchEvent(e);
       return;
     }
     this._dispatchEvent(e);
   }
   _dispatchEvent(e) {
-    const { type } = e;
-    const isDrag = type === "dragover" || type === "dragstart" || type === "dragend";
+    const { type: type3 } = e;
+    const isDrag = type3 === "dragover" || type3 === "dragstart" || type3 === "dragend";
     const { rootNode: root, maxEventNodeDepth: maxDepth, comps, transactor } = this;
     const [path, handlers] = Path.fromEvent(e, root, maxDepth, comps, !isDrag);
     if (isDrag)
-      this._handleDragEvent(e, type, path);
+      this._handleDragEvent(e, type3, path);
     if (path !== null && handlers !== null)
       for (const handler of handlers)
         transactor.transactInputNow(path, e, handler, this.dragInfo);
   }
   _handleTouchEvent(e) {
-    const { type } = e;
-    if (type === "touchstart") {
+    const { type: type3 } = e;
+    if (type3 === "touchstart") {
       if (this._touch !== null || e.touches.length !== 1)
         return;
       const t = e.touches[0];
@@ -5612,11 +8947,11 @@ class App {
       return;
     const { rootNode, _touch } = this;
     const { clientX, clientY } = touch;
-    const fire = (type2, target) => {
-      const e2 = { type: type2, target, clientX, clientY, preventDefault: NOOP };
+    const fire = (type4, target) => {
+      const e2 = { type: type4, target, clientX, clientY, preventDefault: NOOP };
       this._dispatchEvent(e2);
     };
-    if (type === "touchmove") {
+    if (type3 === "touchmove") {
       if (!_touch.active) {
         const dx = clientX - _touch.startX;
         const dy = clientY - _touch.startY;
@@ -5631,17 +8966,17 @@ class App {
       }
       return;
     }
-    if (type === "touchend" || type === "touchcancel") {
+    if (type3 === "touchend" || type3 === "touchcancel") {
       if (_touch.active) {
-        if (type === "touchend")
+        if (type3 === "touchend")
           fire("drop", hitTest(rootNode, clientX, clientY));
         fire("dragend", _touch.target);
       }
       this._touch = null;
     }
   }
-  _handleDragEvent(e, type, path) {
-    if (type === "dragover") {
+  _handleDragEvent(e, type3, path) {
+    if (type3 === "dragover") {
       const dropTarget = getClosestDropTarget(e.target, this.rootNode, 50);
       if (dropTarget !== null) {
         e.preventDefault();
@@ -5649,7 +8984,7 @@ class App {
         this.curDragOver = dropTarget;
         dropTarget.dataset.draggingover = this.dragInfo?.type ?? "_external";
       }
-    } else if (type === "dragstart") {
+    } else if (type3 === "dragstart") {
       e.target.dataset.dragging = 1;
       const rootValue = this.state.val;
       const value = path.lookup(rootValue);
@@ -5714,12 +9049,12 @@ class App {
     for (const name of this._eventNames)
       this.rootNode.removeEventListener(name, this, listenerOpts(name));
   }
-  dispatchSendAtRoot(name, args, opts) {
+  sendAtRoot(name, args, opts) {
     this.transactor.pushSend(new Path([]), name, args, opts);
   }
-  registerComponents(comps, aliases) {
+  registerComponents(comps, aliases2) {
     const scope = this.compStack.enter();
-    scope.registerComponents(comps, aliases);
+    scope.registerComponents(comps, aliases2);
     return scope;
   }
   _transactNextBatch(maxRunTimeMs = 10) {
@@ -5785,12 +9120,12 @@ function getClosestDropTarget(target, rootNode, count) {
 }
 
 class DragInfo {
-  constructor(path, stack, e, val, type, node) {
+  constructor(path, stack, e, val, type3, node) {
     this.path = path;
     this.stack = stack;
     this.e = e;
     this.val = val;
-    this.type = type;
+    this.type = type3;
     this.node = node;
   }
   lookupBind(name) {
@@ -6200,14 +9535,14 @@ function coerceKeyPath(keyPath) {
   }
   throw new TypeError(`Invalid keyPath: expected Ordered Collection or Array: ${keyPath}`);
 }
-function get(collection, key, notSetValue) {
+function get2(collection, key, notSetValue) {
   return isImmutable(collection) ? collection.get(key, notSetValue) : !has(collection, key) ? notSetValue : typeof collection.get === "function" ? collection.get(key) : collection[key];
 }
 function getIn$1(collection, searchKeyPath, notSetValue) {
   const keyPath = coerceKeyPath(searchKeyPath);
   let i = 0;
   while (i !== keyPath.length) {
-    collection = get(collection, keyPath[i++], NOT_SET);
+    collection = get2(collection, keyPath[i++], NOT_SET);
     if (collection === NOT_SET) {
       return notSetValue;
     }
@@ -6256,7 +9591,7 @@ function toJS(value) {
   });
   return result;
 }
-function deepEqual(a, b) {
+function deepEqual2(a, b) {
   if (a === b) {
     return true;
   }
@@ -6984,7 +10319,7 @@ function remove(collection, key) {
   }
   return collectionCopy;
 }
-function set(collection, key, value) {
+function set2(collection, key, value) {
   if (!isDataStructure(collection)) {
     throw new TypeError(`Cannot update non-data-structure value: ${collection}`);
   }
@@ -7020,7 +10355,7 @@ function updateInDeeply(inImmutable, existing, keyPath, i, notSetValue, updater)
     throw new TypeError(`Cannot update within non-data-structure value in path [${Array.from(keyPath).slice(0, i).map(quoteString)}]: ${existing}`);
   }
   const key = keyPath[i];
-  const nextExisting = wasNotSet ? NOT_SET : get(existing, key, NOT_SET);
+  const nextExisting = wasNotSet ? NOT_SET : get2(existing, key, NOT_SET);
   const nextUpdated = updateInDeeply(nextExisting === NOT_SET ? inImmutable : isImmutable(nextExisting), nextExisting, keyPath, i + 1, notSetValue, updater);
   if (nextUpdated === nextExisting) {
     return existing;
@@ -7029,7 +10364,7 @@ function updateInDeeply(inImmutable, existing, keyPath, i, notSetValue, updater)
     return remove(existing, key);
   }
   const collection = wasNotSet ? inImmutable ? emptyMap() : {} : existing;
-  return set(collection, key, nextUpdated);
+  return set2(collection, key, nextUpdated);
 }
 function update$1(collection, key, notSetValue, updater) {
   return updateIn$1(collection, [key], notSetValue, updater);
@@ -7535,26 +10870,26 @@ function returnStack(stack, newSize, head) {
   }
   return makeStack(newSize, head);
 }
-function filterByIters(set2, iters, shouldRemove) {
+function filterByIters(set3, iters, shouldRemove) {
   if (iters.length === 0) {
-    return set2;
+    return set3;
   }
   iters = iters.map((iter) => SetCollection(iter));
-  return set2.withMutations((s) => {
-    set2.forEach((value) => {
+  return set3.withMutations((s) => {
+    set3.forEach((value) => {
       if (shouldRemove(value, iters)) {
         s.remove(value);
       }
     });
   });
 }
-function updateSet(set2, newMap) {
-  if (set2.__ownerID) {
-    set2.size = newMap.size;
-    set2._map = newMap;
-    return set2;
+function updateSet(set3, newMap) {
+  if (set3.__ownerID) {
+    set3.size = newMap.size;
+    set3._map = newMap;
+    return set3;
   }
-  return newMap === set2._map ? set2 : newMap.size === 0 ? set2.__empty() : set2.__make(newMap);
+  return newMap === set3._map ? set3 : newMap.size === 0 ? set3.__empty() : set3.__make(newMap);
 }
 function throwOnInvalidDefaultValues(defaultValues) {
   if (isRecord(defaultValues)) {
@@ -7673,14 +11008,14 @@ var keyMapper = (v, k) => k, entryMapper = (v, k) => [k, v], not = (predicate) =
   const iter = KeyedCollection(value);
   assertNotInfinite(iter.size);
   iter.forEach((v, k) => map.set(k, v));
-}), OrderedMapImpl, makeOrderedMap = (map, list, ownerID, hash2) => new OrderedMapImpl(map, list, ownerID, hash2), emptyOrderedMap = () => makeOrderedMap(emptyMap(), emptyList()), Stack2 = (value) => value === undefined || value === null ? emptyStack() : isStack(value) ? value : emptyStack().pushAll(value), StackImpl, makeStack = (size, head, ownerID, hash2) => new StackImpl(size, head, ownerID, hash2), EMPTY_STACK, emptyStack = () => EMPTY_STACK || (EMPTY_STACK = makeStack(0)), Set2 = (value) => value === undefined || value === null ? emptySet() : isSet(value) && !isOrdered(value) ? value : emptySet().withMutations((set2) => {
+}), OrderedMapImpl, makeOrderedMap = (map, list, ownerID, hash2) => new OrderedMapImpl(map, list, ownerID, hash2), emptyOrderedMap = () => makeOrderedMap(emptyMap(), emptyList()), Stack2 = (value) => value === undefined || value === null ? emptyStack() : isStack(value) ? value : emptyStack().pushAll(value), StackImpl, makeStack = (size, head, ownerID, hash2) => new StackImpl(size, head, ownerID, hash2), EMPTY_STACK, emptyStack = () => EMPTY_STACK || (EMPTY_STACK = makeStack(0)), Set2 = (value) => value === undefined || value === null ? emptySet() : isSet(value) && !isOrdered(value) ? value : emptySet().withMutations((set3) => {
   const iter = SetCollection(value);
   assertNotInfinite(iter.size);
-  iter.forEach((v) => set2.add(v));
-}), SetImpl, makeSet = (map, ownerID) => new SetImpl(map, ownerID), EMPTY_SET, emptySet = () => EMPTY_SET || (EMPTY_SET = makeSet(emptyMap())), OrderedSet = (value) => value === undefined || value === null ? emptyOrderedSet() : isOrderedSet(value) ? value : emptyOrderedSet().withMutations((set2) => {
+  iter.forEach((v) => set3.add(v));
+}), SetImpl, makeSet = (map, ownerID) => new SetImpl(map, ownerID), EMPTY_SET, emptySet = () => EMPTY_SET || (EMPTY_SET = makeSet(emptyMap())), OrderedSet = (value) => value === undefined || value === null ? emptyOrderedSet() : isOrderedSet(value) ? value : emptyOrderedSet().withMutations((set3) => {
   const iter = SetCollection(value);
   assertNotInfinite(iter.size);
-  iter.forEach((v) => set2.add(v));
+  iter.forEach((v) => set3.add(v));
 }), OrderedSetImpl, makeOrderedSet = (map, ownerID) => new OrderedSetImpl(map, ownerID), emptyOrderedSet = () => makeOrderedSet(emptyOrderedMap()), Record = (defaultValues, name) => {
   let hasInitialized;
   throwOnInvalidDefaultValues(defaultValues);
@@ -7765,7 +11100,7 @@ var init_immutable = __esm(() => {
       this.prototype.contains = this.prototype.includes;
     }
     equals(other) {
-      return deepEqual(this, other);
+      return deepEqual2(this, other);
     }
     hashCode() {
       return this.__hash ?? (this.__hash = hashCollection(this));
@@ -9619,12 +12954,12 @@ var init_immutable = __esm(() => {
       if (this.size === 0 && !this.__ownerID && iters.length === 1) {
         return Set2(iters[0]);
       }
-      return this.withMutations((set2) => {
+      return this.withMutations((set3) => {
         for (const iter of iters) {
           if (typeof iter === "string") {
-            set2.add(iter);
+            set3.add(iter);
           } else {
-            SetCollection(iter).forEach((value) => set2.add(value));
+            SetCollection(iter).forEach((value) => set3.add(value));
           }
         }
       });
@@ -9929,7 +13264,7 @@ var init_immutable = __esm(() => {
       return makeIndexKeys(this.size);
     }
     equals(other) {
-      return other instanceof RangeImpl ? this._start === other._start && this._end === other._end && this._step === other._step : deepEqual(this, other);
+      return other instanceof RangeImpl ? this._start === other._start && this._end === other._end && this._step === other._step : deepEqual2(this, other);
     }
     static {
       this.prototype[Symbol.iterator] = this.prototype.values;
@@ -10015,7 +13350,7 @@ var init_immutable = __esm(() => {
       return makeIndexKeys(this.size);
     }
     equals(other) {
-      return other instanceof RepeatImpl ? this.size === other.size && is(this._value, other._value) : deepEqual(this, other);
+      return other instanceof RepeatImpl ? this.size === other.size && is(this._value, other._value) : deepEqual2(this, other);
     }
     static {
       this.prototype[Symbol.iterator] = this.prototype.values;
@@ -10312,6 +13647,227 @@ var init_render2 = __esm(() => {
   init_render();
 });
 
+// tools/core/tests.js
+class Describe {
+  constructor({ title, componentName = null, parent = null }) {
+    this.title = title;
+    this.componentName = componentName;
+    this.parent = parent;
+    this.children = [];
+  }
+}
+
+class Test {
+  constructor({ title, fn, componentName = null, parent = null }) {
+    this.title = title;
+    this.fn = fn;
+    this.componentName = componentName;
+    this.parent = parent;
+  }
+}
+
+class ModuleTests {
+  constructor({ path = null, suites = [] } = {}) {
+    this.path = path;
+    this.suites = suites;
+  }
+}
+function isComponentObject(x) {
+  return x !== null && typeof x === "object" && typeof x.name === "string" && typeof x.Class === "function";
+}
+function resolveComponentName2(arg, components) {
+  if (isComponentObject(arg))
+    return arg.name;
+  if (typeof arg === "function") {
+    for (const c of components)
+      if (c.Class === arg)
+        return c.name;
+  }
+  return null;
+}
+function titleFromArg(arg) {
+  if (typeof arg === "string")
+    return arg;
+  if (isComponentObject(arg))
+    return arg.name;
+  if (typeof arg === "function")
+    return arg.name || "(anonymous)";
+  return String(arg);
+}
+function makeCollector({ path = null, components = [] } = {}) {
+  const moduleTests = new ModuleTests({ path, suites: [] });
+  const stack = [];
+  function describe(...args) {
+    let head;
+    let options = null;
+    let fn;
+    if (args.length === 2) {
+      [head, fn] = args;
+    } else if (args.length === 3) {
+      [head, options, fn] = args;
+    } else {
+      throw new Error(`describe() expects 2 or 3 arguments, got ${args.length}`);
+    }
+    if (typeof fn !== "function") {
+      throw new Error(`describe(${JSON.stringify(titleFromArg(head))}): final argument must be a function`);
+    }
+    let componentName = null;
+    if (typeof head !== "string") {
+      componentName = resolveComponentName2(head, components);
+    }
+    if (componentName === null && options && options.component != null) {
+      componentName = resolveComponentName2(options.component, components);
+    }
+    if (componentName === null) {
+      const parent2 = stack.length ? stack[stack.length - 1] : null;
+      if (parent2)
+        componentName = parent2.componentName;
+    }
+    const parent = stack.length ? stack[stack.length - 1] : null;
+    const node = new Describe({
+      title: titleFromArg(head),
+      componentName,
+      parent
+    });
+    if (parent)
+      parent.children.push(node);
+    else
+      moduleTests.suites.push(node);
+    stack.push(node);
+    try {
+      fn();
+    } finally {
+      stack.pop();
+    }
+  }
+  function test2(title, fn) {
+    if (typeof title !== "string") {
+      throw new Error("test(title, fn): title must be a string");
+    }
+    if (typeof fn !== "function") {
+      throw new Error(`test(${JSON.stringify(title)}): fn must be a function`);
+    }
+    const parent = stack.length ? stack[stack.length - 1] : null;
+    if (!parent) {
+      throw new Error(`test(${JSON.stringify(title)}) must be called inside a describe()`);
+    }
+    parent.children.push(new Test({
+      title,
+      fn,
+      componentName: parent.componentName,
+      parent
+    }));
+  }
+  return { describe, test: test2, moduleTests };
+}
+
+// tools/core/test.js
+function buildPath(node) {
+  const parts = [];
+  let cur = node;
+  while (cur) {
+    parts.unshift(cur.title);
+    cur = cur.parent;
+  }
+  return parts.join(" > ");
+}
+function captureError(e) {
+  const out = { message: e.message, stack: e.stack };
+  if ("expected" in e)
+    out.expected = e.expected;
+  if ("actual" in e)
+    out.actual = e.actual;
+  return out;
+}
+async function runTests({
+  getTests,
+  components = [],
+  path = null,
+  expect: expect2,
+  name = null,
+  grep = null,
+  bail = false
+} = {}) {
+  const counts = { pass: 0, fail: 0, skip: 0, total: 0 };
+  if (typeof getTests !== "function") {
+    return new TestReport({
+      modules: [new ModuleTestReport({ path, suites: [], counts })]
+    });
+  }
+  if (typeof expect2 !== "function") {
+    throw new Error("runTests: expect must be provided (e.g. chai's expect)");
+  }
+  const { describe, test: test2, moduleTests } = makeCollector({ path, components });
+  await getTests({ describe, test: test2, expect: expect2 });
+  let bailed = false;
+  async function visit(node) {
+    if (node instanceof Test) {
+      if (name !== null && node.componentName !== name)
+        return null;
+      const fullPath = buildPath(node);
+      if (grep !== null && !fullPath.includes(grep))
+        return null;
+      counts.total++;
+      if (bailed) {
+        counts.skip++;
+        return new TestResult({
+          title: node.title,
+          fullPath,
+          componentName: node.componentName,
+          status: "skip"
+        });
+      }
+      const start = performance.now();
+      try {
+        await node.fn();
+        counts.pass++;
+        return new TestResult({
+          title: node.title,
+          fullPath,
+          componentName: node.componentName,
+          status: "pass",
+          durationMs: performance.now() - start
+        });
+      } catch (e) {
+        counts.fail++;
+        if (bail)
+          bailed = true;
+        return new TestResult({
+          title: node.title,
+          fullPath,
+          componentName: node.componentName,
+          status: "fail",
+          durationMs: performance.now() - start,
+          error: captureError(e)
+        });
+      }
+    }
+    const childResults = [];
+    for (const child of node.children) {
+      const r = await visit(child);
+      if (r !== null)
+        childResults.push(r);
+    }
+    if (childResults.length === 0)
+      return null;
+    return new DescribeResult({
+      title: node.title,
+      componentName: node.componentName,
+      children: childResults
+    });
+  }
+  const suiteResults = [];
+  for (const suite of moduleTests.suites) {
+    const r = await visit(suite);
+    if (r !== null)
+      suiteResults.push(r);
+  }
+  return new TestReport({
+    modules: [new ModuleTestReport({ path, suites: suiteResults, counts })]
+  });
+}
+var init_test = () => {};
+
 // tools/cli/commands/_registry.js
 var exports__registry = {};
 __export(exports__registry, {
@@ -10319,11 +13875,13 @@ __export(exports__registry, {
 });
 var COMMANDS;
 var init__registry = __esm(() => {
+  init_chai();
   init_describe();
   init_docs();
   init_list();
   init_lint();
   init_render2();
+  init_test();
   COMMANDS = {
     info: {
       describe: "Summarize the module's exports and counts.",
@@ -10369,6 +13927,25 @@ var init__registry = __esm(() => {
         view: values.view ?? null
       }),
       exitOn: (result) => result.hasErrors ? 3 : 0
+    },
+    test: {
+      describe: "Run tests defined by getTests() (optional <name> to filter by component).",
+      defaultFormat: "cli",
+      needsEnv: true,
+      parseOptions: {
+        grep: { type: "string" },
+        bail: { type: "boolean" }
+      },
+      run: (normalized, { values, positionals }) => runTests({
+        getTests: normalized.mod.getTests,
+        components: normalized.components,
+        path: normalized.path,
+        expect,
+        name: positionals[0] ?? null,
+        grep: values.grep ?? null,
+        bail: values.bail ?? false
+      }),
+      exitOn: (result) => result.hasFailures ? 4 : 0
     }
   };
 });
@@ -10548,6 +14125,15 @@ MODULE CONVENTION
     export function getRequestHandlers()  // optional
       -> Record<string, Function>
 
+    export function getTests({ describe, test, expect })   // required for test
+      -> void                             // imperative collector
+      where describe is one of:
+        describe(Component, fn)           // tags suite with Component.name
+        describe(title, fn)               // untagged
+        describe(title, { component }, fn)// explicit tag with custom title
+      and   test(title, fn)               // fn may be async
+      and   expect comes from chai
+
     export function getRoot()             // optional; returned by info
 
 COMMANDS (require <module-path>)
@@ -10579,6 +14165,14 @@ COMMANDS (require <module-path>)
         --view <v>   override the example's view name
       Exits 3 if any render crashes.
 
+  test [name] [--grep <pattern>] [--bail]
+      Run tests defined by getTests({ describe, test, expect }). Filters:
+        [name]       only tests whose tagged componentName equals <name>
+        --grep <p>   substring match against the full test path
+                     (e.g. "MyComp > nested describe > test name")
+        --bail       stop on first failure; remaining tests reported as skip
+      Exits 4 if any test fails.
+
 COMMANDS (no module required)
   help [command]
       Without [command]: prints this full reference.
@@ -10615,6 +14209,7 @@ EXIT CODES
   1   usage error (bad args, missing module, bad module shape)
   2   lint findings at error level
   3   render crash
+  4   test failures
 
 ENVIRONMENT
   \`prettier\` is an optional peer dep, only used by --pretty.
@@ -10981,6 +14576,51 @@ function fmtLintReport(rep) {
   return lines.join(`
 `);
 }
+function fmtTestNode(node, depth, lines) {
+  const pad = "  ".repeat(depth);
+  if (node.children) {
+    lines.push(`${pad}${node.title}`);
+    for (const child of node.children)
+      fmtTestNode(child, depth + 1, lines);
+    return;
+  }
+  const mark = node.status === "pass" ? "✓" : node.status === "fail" ? "✗" : "○";
+  const dur = node.status === "skip" ? "" : ` (${Math.round(node.durationMs)}ms)`;
+  lines.push(`${pad}${mark} ${node.title}${dur}`);
+  if (node.status === "fail" && node.error) {
+    const errPad = "  ".repeat(depth + 1);
+    lines.push(`${errPad}${node.error.message}`);
+    if ("expected" in node.error || "actual" in node.error) {
+      lines.push(`${errPad}  expected: ${JSON.stringify(node.error.expected)}`);
+      lines.push(`${errPad}  actual:   ${JSON.stringify(node.error.actual)}`);
+    }
+    if (node.error.stack) {
+      const trimmed = node.error.stack.split(`
+`).slice(1, 4).map((l) => `${errPad}${l.trim()}`).join(`
+`);
+      if (trimmed)
+        lines.push(trimmed);
+    }
+  }
+}
+function fmtTestReport(report) {
+  const lines = [];
+  for (const m of report.modules) {
+    if (m.path)
+      lines.push(`Module: ${m.path}`);
+    if (m.suites.length === 0) {
+      lines.push("(no tests)");
+    } else {
+      for (const s of m.suites)
+        fmtTestNode(s, 0, lines);
+    }
+    const c = m.counts;
+    lines.push("");
+    lines.push(`Total: ${c.pass} passed, ${c.fail} failed, ${c.skip} skipped (${c.total} total)`);
+  }
+  return lines.join(`
+`);
+}
 function fmtRenderBatch(batch) {
   const totalItems = batch.sections.reduce((n, s) => n + s.items.length, 0);
   if (totalItems === 0)
@@ -11002,7 +14642,8 @@ var { supports, format } = makeFormatter("cli", {
   ExampleIndex: fmtExampleIndex,
   ComponentDocs: fmtComponentDocs,
   LintReport: fmtLintReport,
-  RenderBatch: fmtRenderBatch
+  RenderBatch: fmtRenderBatch,
+  TestReport: fmtTestReport
 });
 
 // tools/format/md.js
@@ -11149,13 +14790,54 @@ function fmtComponentList2(list) {
   return lines.join(`
 `);
 }
+function fmtTestSubtree(node, depth, lines) {
+  if (node.children) {
+    const headerLevel = Math.min(depth + 2, 6);
+    lines.push(`${"#".repeat(headerLevel)} ${node.title}`, "");
+    for (const child of node.children)
+      fmtTestSubtree(child, depth + 1, lines);
+    return;
+  }
+  const mark = node.status === "pass" ? "✓" : node.status === "fail" ? "✗" : "○";
+  const dur = node.status === "skip" ? "" : ` _(${Math.round(node.durationMs)}ms)_`;
+  lines.push(`- ${mark} **${node.title}**${dur}`);
+  if (node.status === "fail" && node.error) {
+    lines.push("", "```");
+    lines.push(node.error.message);
+    if ("expected" in node.error || "actual" in node.error) {
+      lines.push(`expected: ${JSON.stringify(node.error.expected)}`);
+      lines.push(`actual:   ${JSON.stringify(node.error.actual)}`);
+    }
+    if (node.error.stack)
+      lines.push(node.error.stack);
+    lines.push("```", "");
+  }
+}
+function fmtTestReport2(report) {
+  const lines = [];
+  for (const m of report.modules) {
+    lines.push(`# Test report${m.path ? ` — ${m.path}` : ""}`, "");
+    if (m.suites.length === 0) {
+      lines.push("_(no tests)_", "");
+    } else {
+      for (const s of m.suites)
+        fmtTestSubtree(s, 0, lines);
+    }
+    const c = m.counts;
+    lines.push("");
+    lines.push(`**Total:** ${c.pass} passed, ${c.fail} failed, ${c.skip} skipped (${c.total} total)`);
+  }
+  return lines.join(`
+`);
+}
 var { supports: supports2, format: format2 } = makeFormatter("md", {
   ComponentDocs: fmtComponentDocs2,
   RenderBatch: fmtRenderBatch2,
   ExampleIndex: fmtExampleIndex2,
   LintReport: fmtLintReport2,
   ModuleInfo: fmtModuleInfo2,
-  ComponentList: fmtComponentList2
+  ComponentList: fmtComponentList2,
+  TestReport: fmtTestReport2
 });
 
 // tools/format/json.js
@@ -11178,7 +14860,8 @@ var { supports: supports3, format: format3 } = makeFormatter("json", {
   ExampleIndex: fmtJson,
   ComponentDocs: fmtJson,
   LintReport: fmtJson,
-  RenderBatch: fmtJson
+  RenderBatch: fmtJson,
+  TestReport: fmtJson
 });
 
 // tools/format/html.js