tutuca 0.9.71 → 0.9.73

package/dist/tutuca-dev.ext.js

@@ -1,3465 +1,5 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __reExport = (target, mod, secondTarget) => {
-  var keys = __getOwnPropNames(mod);
-  for (let key of keys)
-    if (!__hasOwnProp.call(target, key) && key !== "default")
-      __defProp(target, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (secondTarget) {
-    for (let key of keys)
-      if (!__hasOwnProp.call(secondTarget, key) && key !== "default")
-        __defProp(secondTarget, key, {
-          get: __accessProp.bind(mod, key),
-          enumerable: true
-        });
-    return secondTarget;
-  }
-};
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
-// dev.js
-var exports_dev = {};
-__export(exports_dev, {
-  tutuca: () => tutuca,
-  test: () => test4,
-  suggestionToMessage: () => suggestionToMessage,
-  runTests: () => runTests,
-  reportTestReportToConsole: () => reportTestReportToConsole,
-  makeCollector: () => makeCollector,
-  macro: () => macro,
-  lintIdToMessage: () => lintIdToMessage,
-  isOMap: () => isOrderedMap,
-  isIMap: () => isMap,
-  injectCss: () => injectCss,
-  html: () => html,
-  getComponentsDocs: () => getComponentsDocs,
-  docComponents: () => docComponents,
-  css: () => css,
-  component: () => component,
-  compileClassesToStyleText: () => compileClassesToStyleText,
-  compileClassesToStyle: () => compileClassesToStyle,
-  collectIterBindings: () => collectIterBindings2,
-  checkComponent: () => checkComponent,
-  check: () => check2,
-  UNSUPPORTED_EXPR_SYNTAX: () => UNSUPPORTED_EXPR_SYNTAX,
-  UNKNOWN_X_OP: () => UNKNOWN_X_OP,
-  UNKNOWN_X_ATTR: () => UNKNOWN_X_ATTR,
-  UNKNOWN_REQUEST_NAME: () => UNKNOWN_REQUEST_NAME,
-  UNKNOWN_MACRO_ARG: () => UNKNOWN_MACRO_ARG,
-  UNKNOWN_HANDLER_ARG_NAME: () => UNKNOWN_HANDLER_ARG_NAME,
-  UNKNOWN_EVENT_MODIFIER: () => UNKNOWN_EVENT_MODIFIER,
-  UNKNOWN_DIRECTIVE: () => UNKNOWN_DIRECTIVE,
-  UNKNOWN_COMPONENT_SPEC_KEY: () => UNKNOWN_COMPONENT_SPEC_KEY,
-  UNKNOWN_COMPONENT_NAME: () => UNKNOWN_COMPONENT_NAME,
-  TestResult: () => TestResult,
-  TestReport: () => TestReport,
-  TestIndex: () => TestIndex,
-  Test: () => Test,
-  SEQ_INFO: () => SEQ_INFO,
-  RenderedSection: () => RenderedSection,
-  RenderedExample: () => RenderedExample,
-  RenderBatch: () => RenderBatch,
-  RENDER_IT_OUTSIDE_OF_LOOP: () => RENDER_IT_OUTSIDE_OF_LOOP,
-  REDUNDANT_TEMPLATE_STRING: () => REDUNDANT_TEMPLATE_STRING,
-  ParseContext: () => ParseContext,
-  PLACEHOLDERLESS_TEMPLATE_STRING: () => PLACEHOLDERLESS_TEMPLATE_STRING,
-  OMap: () => OrderedMap2,
-  ModuleTests: () => ModuleTests,
-  ModuleTestReport: () => ModuleTestReport,
-  ModuleInfo: () => ModuleInfo,
-  METHOD_VAL_NOT_DEFINED: () => METHOD_VAL_NOT_DEFINED,
-  METHOD_VAL_IS_FIELD: () => METHOD_VAL_IS_FIELD,
-  MAYBE_DROP_AT_PREFIX: () => MAYBE_DROP_AT_PREFIX,
-  MAYBE_ADD_AT_PREFIX: () => MAYBE_ADD_AT_PREFIX,
-  LintReport: () => LintReport,
-  LintParseContext: () => LintParseContext,
-  LintFinding: () => LintFinding,
-  LintContext: () => LintContext,
-  LintComponentResult: () => LintComponentResult,
-  LintClassCollectorCtx: () => LintClassCollectorCtx,
-  KList: () => KList,
-  ISet: () => Set2,
-  INPUT_HANDLER_NOT_REFERENCED: () => INPUT_HANDLER_NOT_REFERENCED,
-  INPUT_HANDLER_NOT_IMPLEMENTED: () => INPUT_HANDLER_NOT_IMPLEMENTED,
-  INPUT_HANDLER_METHOD_NOT_IMPLEMENTED: () => INPUT_HANDLER_METHOD_NOT_IMPLEMENTED,
-  INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER: () => INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER,
-  INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD: () => INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD,
-  IMap: () => Map2,
-  IF_NO_BRANCH_SET: () => IF_NO_BRANCH_SET,
-  FIELD_VAL_NOT_DEFINED: () => FIELD_VAL_NOT_DEFINED,
-  FIELD_VAL_IS_METHOD: () => FIELD_VAL_IS_METHOD,
-  FIELD_CLASS: () => FIELD_CLASS,
-  ExampleIndex: () => ExampleIndex,
-  DescribeResult: () => DescribeResult,
-  Describe: () => Describe,
-  DYN_VAL_NOT_DEFINED: () => DYN_VAL_NOT_DEFINED,
-  DYN_ALIAS_NOT_REFERENCED: () => DYN_ALIAS_NOT_REFERENCED,
-  DUPLICATE_ATTR_DEFINITION: () => DUPLICATE_ATTR_DEFINITION,
-  ComponentSummary: () => ComponentSummary,
-  ComponentList: () => ComponentList,
-  ComponentDocs: () => ComponentDocs,
-  COMP_FIELD_BAD_SHAPE: () => COMP_FIELD_BAD_SHAPE,
-  BAD_VALUE: () => BAD_VALUE,
-  ALT_HANDLER_NOT_REFERENCED: () => ALT_HANDLER_NOT_REFERENCED,
-  ALT_HANDLER_NOT_DEFINED: () => ALT_HANDLER_NOT_DEFINED
-});
-
-// node_modules/chai/index.js
-var exports_chai = {};
-__export(exports_chai, {
-  util: () => utils_exports,
-  use: () => use,
-  should: () => should,
-  expect: () => expect,
-  config: () => config,
-  assert: () => assert,
-  Should: () => Should,
-  AssertionError: () => AssertionError,
-  Assertion: () => Assertion
-});
-var __defProp2 = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
-var __export2 = (target, all) => {
-  for (var name in all)
-    __defProp2(target, name, { get: all[name], enumerable: true });
-};
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var 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
-});
-var check_error_exports = {};
-__export2(check_error_exports, {
-  compatibleConstructor: () => compatibleConstructor,
-  compatibleInstance: () => compatibleInstance,
-  compatibleMessage: () => compatibleMessage,
-  getConstructorName: () => getConstructorName,
-  getMessage: () => getMessage
-});
-function isErrorInstance(obj) {
-  return obj instanceof Error || Object.prototype.toString.call(obj) === "[object Error]";
-}
-__name(isErrorInstance, "isErrorInstance");
-function isRegExp(obj) {
-  return Object.prototype.toString.call(obj) === "[object RegExp]";
-}
-__name(isRegExp, "isRegExp");
-function compatibleInstance(thrown, errorLike) {
-  return isErrorInstance(errorLike) && thrown === errorLike;
-}
-__name(compatibleInstance, "compatibleInstance");
-function compatibleConstructor(thrown, errorLike) {
-  if (isErrorInstance(errorLike)) {
-    return thrown.constructor === errorLike.constructor || thrown instanceof errorLike.constructor;
-  } else if ((typeof errorLike === "object" || typeof errorLike === "function") && errorLike.prototype) {
-    return thrown.constructor === errorLike || thrown instanceof errorLike;
-  }
-  return false;
-}
-__name(compatibleConstructor, "compatibleConstructor");
-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;
-}
-__name(compatibleMessage, "compatibleMessage");
-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;
-}
-__name(getConstructorName, "getConstructorName");
-function getMessage(errorLike) {
-  let msg = "";
-  if (errorLike && errorLike.message) {
-    msg = errorLike.message;
-  } else if (typeof errorLike === "string") {
-    msg = errorLike;
-  }
-  return msg;
-}
-__name(getMessage, "getMessage");
-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];
-  }
-}
-__name(flag, "flag");
-function test(obj, args) {
-  let negate = flag(obj, "negate"), expr = args[0];
-  return negate ? !expr : expr;
-}
-__name(test, "test");
-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;
-}
-__name(type, "type");
-var canElideFrames = "captureStackTrace" in Error;
-var _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");
-var AssertionError = _AssertionError;
-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);
-  }
-}
-__name(expectTypes, "expectTypes");
-function getActual(obj, args) {
-  return args.length > 4 ? args[4] : obj._obj;
-}
-__name(getActual, "getActual");
-var 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"]
-};
-var styles = {
-  special: "cyan",
-  number: "yellow",
-  bigint: "yellow",
-  boolean: "yellow",
-  undefined: "grey",
-  null: "bold",
-  string: "green",
-  symbol: "green",
-  date: "magenta",
-  regexp: "red"
-};
-var truncator = "…";
-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`;
-}
-__name(colorise, "colorise");
-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;
-}
-__name(normaliseOptions, "normaliseOptions");
-function isHighSurrogate(char) {
-  return char >= "\uD800" && char <= "\uDBFF";
-}
-__name(isHighSurrogate, "isHighSurrogate");
-function truncate(string, length, tail = truncator) {
-  string = String(string);
-  const tailLength = tail.length;
-  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;
-}
-__name(truncate, "truncate");
-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}`;
-}
-__name(inspectList, "inspectList");
-function quoteComplexKey(key) {
-  if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) {
-    return key;
-  }
-  return JSON.stringify(key).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
-}
-__name(quoteComplexKey, "quoteComplexKey");
-function inspectProperty([key, value], options) {
-  options.truncate -= 2;
-  if (typeof key === "string") {
-    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}`;
-}
-__name(inspectProperty, "inspectProperty");
-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}` : ""} ]`;
-}
-__name(inspectArray, "inspectArray");
-var 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");
-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}` : ""} ]`;
-}
-__name(inspectTypedArray, "inspectTypedArray");
-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");
-}
-__name(inspectDate, "inspectDate");
-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");
-}
-__name(inspectFunction, "inspectFunction");
-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}`;
-}
-__name(inspectMapEntry, "inspectMapEntry");
-function mapToEntries(map) {
-  const entries = [];
-  map.forEach((value, key) => {
-    entries.push([key, value]);
-  });
-  return entries;
-}
-__name(mapToEntries, "mapToEntries");
-function inspectMap(map, options) {
-  if (map.size === 0)
-    return "Map{}";
-  options.truncate -= 7;
-  return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`;
-}
-__name(inspectMap, "inspectMap");
-var isNaN = Number.isNaN || ((i) => i !== i);
-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");
-}
-__name(inspectNumber, "inspectNumber");
-function inspectBigInt(number, options) {
-  let nums = truncate(number.toString(), options.truncate - 1);
-  if (nums !== truncator)
-    nums += "n";
-  return options.stylize(nums, "bigint");
-}
-__name(inspectBigInt, "inspectBigInt");
-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");
-}
-__name(inspectRegExp, "inspectRegExp");
-function arrayFromSet(set2) {
-  const values = [];
-  set2.forEach((value) => {
-    values.push(value);
-  });
-  return values;
-}
-__name(arrayFromSet, "arrayFromSet");
-function inspectSet(set2, options) {
-  if (set2.size === 0)
-    return "Set{}";
-  options.truncate -= 7;
-  return `Set{ ${inspectList(arrayFromSet(set2), options)} }`;
-}
-__name(inspectSet, "inspectSet");
-var stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g");
-var escapeCharacters = {
-  "\b": "\\b",
-  "\t": "\\t",
-  "\n": "\\n",
-  "\f": "\\f",
-  "\r": "\\r",
-  "'": "\\'",
-  "\\": "\\\\"
-};
-var hex = 16;
-var unicodeLength = 4;
-function escape(char) {
-  return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-unicodeLength)}`;
-}
-__name(escape, "escape");
-function inspectString(string, options) {
-  if (stringEscapeChars.test(string)) {
-    string = string.replace(stringEscapeChars, escape);
-  }
-  return options.stylize(`'${truncate(string, options.truncate - 2)}'`, "string");
-}
-__name(inspectString, "inspectString");
-function inspectSymbol(value) {
-  if ("description" in Symbol.prototype) {
-    return value.description ? `Symbol(${value.description})` : "Symbol()";
-  }
-  return value.toString();
-}
-__name(inspectSymbol, "inspectSymbol");
-var getPromiseValue = /* @__PURE__ */ __name(() => "Promise{…}", "getPromiseValue");
-var promise_default = getPromiseValue;
-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} }`;
-}
-__name(inspectObject, "inspectObject");
-var toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag ? Symbol.toStringTag : false;
-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)}`;
-}
-__name(inspectClass, "inspectClass");
-function inspectArguments(args, options) {
-  if (args.length === 0)
-    return "Arguments[]";
-  options.truncate -= 13;
-  return `Arguments[ ${inspectList(args, options)} ]`;
-}
-__name(inspectArguments, "inspectArguments");
-var errorKeys = [
-  "stack",
-  "line",
-  "column",
-  "name",
-  "message",
-  "fileName",
-  "lineNumber",
-  "columnNumber",
-  "number",
-  "description",
-  "cause"
-];
-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} }` : ""}`;
-}
-__name(inspectObject2, "inspectObject");
-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")}`;
-}
-__name(inspectAttribute, "inspectAttribute");
-function inspectNodeCollection(collection, options) {
-  return inspectList(collection, options, inspectNode, `
-`);
-}
-__name(inspectNodeCollection, "inspectNodeCollection");
-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);
-  }
-}
-__name(inspectNode, "inspectNode");
-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}`;
-}
-__name(inspectHTML, "inspectHTML");
-var symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function";
-var chaiInspect = symbolsSupported ? /* @__PURE__ */ Symbol.for("chai/inspect") : "@@chai/inspect";
-var nodeInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
-var constructorMap = /* @__PURE__ */ new WeakMap;
-var stringTagMap = {};
-var 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
-};
-var 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");
-var toString = Object.prototype.toString;
-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);
-}
-__name(inspect, "inspect");
-var config = {
-  includeStack: false,
-  showDiff: true,
-  truncateThreshold: 40,
-  useProxy: true,
-  proxyExcludedKeys: ["then", "catch", "inspect", "toJSON"],
-  deepEqual: null
-};
-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);
-}
-__name(inspect2, "inspect");
-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;
-  }
-}
-__name(objDisplay, "objDisplay");
-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;
-}
-__name(getMessage2, "getMessage");
-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];
-    }
-  }
-}
-__name(transferFlags, "transferFlags");
-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);
-}
-__name(type2, "type");
-function FakeMap() {
-  this._key = "chai/deep-eql__" + Math.random() + Date.now();
-}
-__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")
-};
-var MemoizeMap = typeof WeakMap === "function" ? WeakMap : FakeMap;
-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;
-}
-__name(memoizeCompare, "memoizeCompare");
-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);
-  }
-}
-__name(memoizeSet, "memoizeSet");
-var deep_eql_default = deepEqual;
-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);
-}
-__name(deepEqual, "deepEqual");
-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;
-}
-__name(simpleEqual, "simpleEqual");
-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;
-}
-__name(extensiveDeepEqual, "extensiveDeepEqual");
-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);
-  }
-}
-__name(extensiveDeepEqualByType, "extensiveDeepEqualByType");
-function regexpEqual(leftHandOperand, rightHandOperand) {
-  return leftHandOperand.toString() === rightHandOperand.toString();
-}
-__name(regexpEqual, "regexpEqual");
-function entriesEqual(leftHandOperand, rightHandOperand, options) {
-  try {
-    if (leftHandOperand.size !== rightHandOperand.size) {
-      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);
-}
-__name(entriesEqual, "entriesEqual");
-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;
-}
-__name(iterableEqual, "iterableEqual");
-function generatorEqual(leftHandOperand, rightHandOperand, options) {
-  return iterableEqual(getGeneratorEntries(leftHandOperand), getGeneratorEntries(rightHandOperand), options);
-}
-__name(generatorEqual, "generatorEqual");
-function hasIteratorFunction(target) {
-  return typeof Symbol !== "undefined" && typeof target === "object" && typeof Symbol.iterator !== "undefined" && typeof target[Symbol.iterator] === "function";
-}
-__name(hasIteratorFunction, "hasIteratorFunction");
-function getIteratorEntries(target) {
-  if (hasIteratorFunction(target)) {
-    try {
-      return getGeneratorEntries(target[Symbol.iterator]());
-    } catch (iteratorError) {
-      return [];
-    }
-  }
-  return [];
-}
-__name(getIteratorEntries, "getIteratorEntries");
-function getGeneratorEntries(generator) {
-  var generatorResult = generator.next();
-  var accumulator = [generatorResult.value];
-  while (generatorResult.done === false) {
-    generatorResult = generator.next();
-    accumulator.push(generatorResult.value);
-  }
-  return accumulator;
-}
-__name(getGeneratorEntries, "getGeneratorEntries");
-function getEnumerableKeys(target) {
-  var keys = [];
-  for (var key in target) {
-    keys.push(key);
-  }
-  return keys;
-}
-__name(getEnumerableKeys, "getEnumerableKeys");
-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;
-}
-__name(getEnumerableSymbols, "getEnumerableSymbols");
-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;
-}
-__name(keysEqual, "keysEqual");
-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;
-}
-__name(objectEqual, "objectEqual");
-function isPrimitive(value) {
-  return value === null || typeof value !== "object";
-}
-__name(isPrimitive, "isPrimitive");
-function mapSymbols(arr) {
-  return arr.map(/* @__PURE__ */ __name(function mapSymbol(entry) {
-    if (typeof entry === "symbol") {
-      return entry.toString();
-    }
-    return entry;
-  }, "mapSymbol"));
-}
-__name(mapSymbols, "mapSymbols");
-function hasProperty(obj, name) {
-  if (typeof obj === "undefined" || obj === null) {
-    return false;
-  }
-  return name in Object(obj);
-}
-__name(hasProperty, "hasProperty");
-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;
-  });
-}
-__name(parsePath, "parsePath");
-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;
-}
-__name(internalGetPathValue, "internalGetPathValue");
-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;
-}
-__name(getPathInfo, "getPathInfo");
-var _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);
-  }
-};
-__name(_Assertion, "Assertion");
-var Assertion = _Assertion;
-var events = new EventTarget;
-var _PluginEvent = class _PluginEvent2 extends Event {
-  constructor(type3, name, fn) {
-    super(type3);
-    this.name = String(name);
-    this.fn = fn;
-  }
-};
-__name(_PluginEvent, "PluginEvent");
-var PluginEvent = _PluginEvent;
-function isProxyEnabled() {
-  return config.useProxy && typeof Proxy !== "undefined" && typeof Reflect !== "undefined";
-}
-__name(isProxyEnabled, "isProxyEnabled");
-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));
-}
-__name(addProperty, "addProperty");
-var fnLengthDesc = Object.getOwnPropertyDescriptor(function() {}, "length");
-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;
-}
-__name(addLengthGuard, "addLengthGuard");
-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;
-}
-__name(getProperties, "getProperties");
-var builtins = ["__flags", "__methods", "_obj", "assert"];
-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")
-  });
-}
-__name(proxify, "proxify");
-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];
-}
-__name(stringDistanceCapped, "stringDistanceCapped");
-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));
-}
-__name(addMethod, "addMethod");
-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
-  });
-}
-__name(overwriteProperty, "overwriteProperty");
-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);
-}
-__name(overwriteMethod, "overwriteMethod");
-var canSetPrototype = typeof Object.setPrototypeOf === "function";
-var testFn = /* @__PURE__ */ __name(function() {}, "testFn");
-var excludeNames = Object.getOwnPropertyNames(testFn).filter(function(name) {
-  let propDesc = Object.getOwnPropertyDescriptor(testFn, name);
-  if (typeof propDesc !== "object")
-    return true;
-  return !propDesc.configurable;
-});
-var call = Function.prototype.call;
-var apply = Function.prototype.apply;
-var _PluginAddChainableMethodEvent = class _PluginAddChainableMethodEvent2 extends PluginEvent {
-  constructor(type3, name, fn, chainingBehavior) {
-    super(type3, name, fn);
-    this.chainingBehavior = chainingBehavior;
-  }
-};
-__name(_PluginAddChainableMethodEvent, "PluginAddChainableMethodEvent");
-var PluginAddChainableMethodEvent = _PluginAddChainableMethodEvent;
-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));
-}
-__name(addChainableMethod, "addChainableMethod");
-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");
-}
-__name(overwriteChainableMethod, "overwriteChainableMethod");
-function compareByInspect(a, b) {
-  return inspect2(a) < inspect2(b) ? -1 : 1;
-}
-__name(compareByInspect, "compareByInspect");
-function getOwnEnumerablePropertySymbols(obj) {
-  if (typeof Object.getOwnPropertySymbols !== "function")
-    return [];
-  return Object.getOwnPropertySymbols(obj).filter(function(sym) {
-    return Object.getOwnPropertyDescriptor(obj, sym).enumerable;
-  });
-}
-__name(getOwnEnumerablePropertySymbols, "getOwnEnumerablePropertySymbols");
-function getOwnEnumerableProperties(obj) {
-  return Object.keys(obj).concat(getOwnEnumerablePropertySymbols(obj));
-}
-__name(getOwnEnumerableProperties, "getOwnEnumerableProperties");
-var isNaN2 = Number.isNaN;
-function isObjectType(obj) {
-  let objectType = type(obj);
-  let objectTypes = ["Array", "Object", "Function"];
-  return objectTypes.indexOf(objectType) !== -1;
-}
-__name(isObjectType, "isObjectType");
-function getOperator(obj, args) {
-  let operator = flag(obj, "operator");
-  let negate = flag(obj, "negate");
-  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";
-}
-__name(getOperator, "getOperator");
-function getName(fn) {
-  return fn.name;
-}
-__name(getName, "getName");
-function isRegExp2(obj) {
-  return Object.prototype.toString.call(obj) === "[object RegExp]";
-}
-__name(isRegExp2, "isRegExp");
-function isNumeric(obj) {
-  return ["Number", "BigInt"].includes(type(obj));
-}
-__name(isNumeric, "isNumeric");
-var { 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);
-});
-var functionTypes = {
-  function: [
-    "function",
-    "asyncfunction",
-    "generatorfunction",
-    "asyncgeneratorfunction"
-  ],
-  asyncfunction: ["asyncfunction", "asyncgeneratorfunction"],
-  generatorfunction: ["generatorfunction", "asyncgeneratorfunction"],
-  asyncgeneratorfunction: ["asyncgeneratorfunction"]
-};
-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);
-  }
-}
-__name(an, "an");
-Assertion.addChainableMethod("an", an);
-Assertion.addChainableMethod("a", an);
-function SameValueZero(a, b) {
-  return isNaN2(a) && isNaN2(b) || a === b;
-}
-__name(SameValueZero, "SameValueZero");
-function includeChainingBehavior() {
-  flag2(this, "contains", true);
-}
-__name(includeChainingBehavior, "includeChainingBehavior");
-function include(val, msg) {
-  if (msg)
-    flag2(this, "message", msg);
-  let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), negate = flag2(this, "negate"), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), descriptor = isDeep ? "deep " : "", isEql = isDeep ? flag2(this, "eql") : SameValueZero;
-  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));
-}
-__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");
-});
-function assertExist() {
-  let val = flag2(this, "object");
-  this.assert(val !== null && val !== undefined, "expected #{this} to exist", "expected #{this} to not exist");
-}
-__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");
-});
-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");
-}
-__name(checkArguments, "checkArguments");
-Assertion.addProperty("arguments", checkArguments);
-Assertion.addProperty("Arguments", checkArguments);
-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);
-  }
-}
-__name(assertEqual, "assertEqual");
-Assertion.addMethod("equal", assertEqual);
-Assertion.addMethod("equals", assertEqual);
-Assertion.addMethod("eq", assertEqual);
-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);
-}
-__name(assertEql, "assertEql");
-Assertion.addMethod("eql", assertEql);
-Assertion.addMethod("eqls", assertEql);
-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);
-  }
-}
-__name(assertAbove, "assertAbove");
-Assertion.addMethod("above", assertAbove);
-Assertion.addMethod("gt", assertAbove);
-Assertion.addMethod("greaterThan", assertAbove);
-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);
-  }
-}
-__name(assertLeast, "assertLeast");
-Assertion.addMethod("least", assertLeast);
-Assertion.addMethod("gte", assertLeast);
-Assertion.addMethod("greaterThanOrEqual", assertLeast);
-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);
-  }
-}
-__name(assertBelow, "assertBelow");
-Assertion.addMethod("below", assertBelow);
-Assertion.addMethod("lt", assertBelow);
-Assertion.addMethod("lessThan", assertBelow);
-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);
-  }
-}
-__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);
-  }
-});
-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);
-}
-__name(assertInstanceOf, "assertInstanceOf");
-Assertion.addMethod("instanceof", assertInstanceOf);
-Assertion.addMethod("instanceOf", assertInstanceOf);
-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);
-}
-__name(assertProperty, "assertProperty");
-Assertion.addMethod("property", assertProperty);
-function assertOwnProperty(_name, _value, _msg) {
-  flag2(this, "own", true);
-  assertProperty.apply(this, arguments);
-}
-__name(assertOwnProperty, "assertOwnProperty");
-Assertion.addMethod("ownProperty", assertOwnProperty);
-Assertion.addMethod("haveOwnProperty", assertOwnProperty);
-function assertOwnPropertyDescriptor(name, descriptor, msg) {
-  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);
-}
-__name(assertOwnPropertyDescriptor, "assertOwnPropertyDescriptor");
-Assertion.addMethod("ownPropertyDescriptor", assertOwnPropertyDescriptor);
-Assertion.addMethod("haveOwnPropertyDescriptor", assertOwnPropertyDescriptor);
-function assertLengthChain() {
-  flag2(this, "doLength", true);
-}
-__name(assertLengthChain, "assertLengthChain");
-function assertLength(n, msg) {
-  if (msg)
-    flag2(this, "message", msg);
-  let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), descriptor = "length", itemsCount;
-  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);
-}
-__name(assertLength, "assertLength");
-Assertion.addChainableMethod("length", assertLength, assertLengthChain);
-Assertion.addChainableMethod("lengthOf", assertLength, assertLengthChain);
-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);
-}
-__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));
-});
-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);
-}
-__name(assertKeys, "assertKeys");
-Assertion.addMethod("keys", assertKeys);
-Assertion.addMethod("key", assertKeys);
-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);
-}
-__name(assertThrows, "assertThrows");
-Assertion.addMethod("throw", assertThrows);
-Assertion.addMethod("throws", assertThrows);
-Assertion.addMethod("Throw", assertThrows);
-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));
-}
-__name(respondTo, "respondTo");
-Assertion.addMethod("respondTo", respondTo);
-Assertion.addMethod("respondsTo", respondTo);
-Assertion.addProperty("itself", function() {
-  flag2(this, "itself", true);
-});
-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);
-}
-__name(satisfy, "satisfy");
-Assertion.addMethod("satisfy", satisfy);
-Assertion.addMethod("satisfies", satisfy);
-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);
-}
-__name(closeTo, "closeTo");
-Assertion.addMethod("closeTo", closeTo);
-Assertion.addMethod("approximately", closeTo);
-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;
-    });
-  });
-}
-__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);
-});
-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);
-    }
-  }
-}
-__name(oneOf, "oneOf");
-Assertion.addMethod("oneOf", oneOf);
-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");
-}
-__name(assertChanges, "assertChanges");
-Assertion.addMethod("change", assertChanges);
-Assertion.addMethod("changes", assertChanges);
-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");
-}
-__name(assertIncreases, "assertIncreases");
-Assertion.addMethod("increase", assertIncreases);
-Assertion.addMethod("increases", assertIncreases);
-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");
-}
-__name(assertDecreases, "assertDecreases");
-Assertion.addMethod("decrease", assertDecreases);
-Assertion.addMethod("decreases", assertDecreases);
-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);
-}
-__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");
-});
-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;
-  });
-}
-__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);
-});
-function expect(val, message) {
-  return new Assertion(val, message);
-}
-__name(expect, "expect");
-expect.fail = function(actual, expected, message, operator) {
-  if (arguments.length < 2) {
-    message = actual;
-    actual = undefined;
-  }
-  message = message || "expect.fail()";
-  throw new AssertionError(message, {
-    actual,
-    expected,
-    operator
-  }, expect.fail);
-};
-var should_exports = {};
-__export2(should_exports, {
-  Should: () => Should,
-  should: () => should
-});
-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;
-}
-__name(loadShould, "loadShould");
-var should = loadShould;
-var Should = loadShould;
-function assert(express, errmsg) {
-  let test2 = new Assertion(null, null, assert, true);
-  test2.assert(express, errmsg, "[ negation message unavailable ]");
-}
-__name(assert, "assert");
-assert.fail = function(actual, expected, message, operator) {
-  if (arguments.length < 2) {
-    message = actual;
-    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);
-};
-var 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];
-}
-var used = [];
-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;
-}
-__name(use, "use");
-
-// src/anode.js
-var exports_anode = {};
-__export(exports_anode, {
-  compileModifiers: () => compileModifiers,
-  WrapperNode: () => WrapperNode,
-  View: () => View,
-  TextNode: () => TextNode,
-  SlotNode: () => SlotNode,
-  ShowNode: () => ShowNode,
-  ScopeNode: () => ScopeNode,
-  RenderTextNode: () => RenderTextNode,
-  RenderOnceNode: () => RenderOnceNode,
-  RenderNode: () => RenderNode,
-  RenderItNode: () => RenderItNode,
-  RenderEachNode: () => RenderEachNode,
-  PushViewNameNode: () => PushViewNameNode,
-  ParseContext: () => ParseContext,
-  NodeEvents: () => NodeEvents,
-  MacroNode: () => MacroNode,
-  Macro: () => Macro,
-  MOD_WRAPPERS_BY_EVENT: () => MOD_WRAPPERS_BY_EVENT,
-  IterInfo: () => IterInfo,
-  HideNode: () => HideNode,
-  FragmentNode: () => FragmentNode,
-  EachNode: () => EachNode,
-  DomNode: () => DomNode,
-  CommentNode: () => CommentNode,
-  BaseNode: () => BaseNode,
-  ANode: () => ANode
-});
+// dev.js
+import { expect } from "chai";
 
 // src/value.js
 import { is } from "immutable";
@@ -3800,8 +340,8 @@ class Path {
     return [new Path(pathSteps.reverse()), handlers];
   }
   static fromEvent(e, rNode, maxDepth, comps, stopOnNoEvent = true) {
-    const { type: type3, target } = e;
-    return Path.fromNodeAndEventName(target, type3, rNode, maxDepth, comps, stopOnNoEvent);
+    const { type, target } = e;
+    return Path.fromNodeAndEventName(target, type, rNode, maxDepth, comps, stopOnNoEvent);
   }
 }
 function metaChain(n) {
@@ -4242,8 +782,8 @@ class HandlerNameVal extends NameVal {
     return stack.getHandlerFor(this.name, this.namespace) ?? mk404Handler(this.namespace, this.name);
   }
 }
-var mk404Handler = (type3, name) => function(...args) {
-  console.warn("handler not found", { type: type3, name, args }, this);
+var mk404Handler = (type, name) => function(...args) {
+  console.warn("handler not found", { type, name, args }, this);
   return this;
 };
 
@@ -4860,13 +1400,13 @@ function diffProps(a, b) {
 function morphNode(domNode, source, target, opts) {
   if (source === target || source.isEqualTo(target))
     return domNode;
-  const type3 = source.nodeType;
-  if (type3 === target.nodeType) {
-    if (type3 === 3 || type3 === 8) {
+  const type = source.nodeType;
+  if (type === target.nodeType) {
+    if (type === 3 || type === 8) {
       domNode.data = target.text;
       return domNode;
     }
-    if (type3 === 1 && source.isSameKind(target)) {
+    if (type === 1 && source.isSameKind(target)) {
       const propsDiff = diffProps(source.attrs, target.attrs);
       let pendingValue;
       let pendingChecked;
@@ -4901,7 +1441,7 @@ function morphNode(domNode, source, target, opts) {
         setProp(domNode, "checked", pendingChecked, false);
       return domNode;
     }
-    if (type3 === 11) {
+    if (type === 11) {
       morphChildren(domNode, source.childs, target.childs, opts);
       return domNode;
     }
@@ -4944,18 +1484,18 @@ function morphChildren(parentDom, oldChilds, newChilds, opts) {
     if (key != null)
       oldKeyMap[key] = i;
   }
-  const used2 = new Uint8Array(oldChilds.length);
+  const used = 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 && !used2[oldKeyMap[newKey]])
+      if (newKey in oldKeyMap && !used[oldKeyMap[newKey]])
         oldIdx = oldKeyMap[newKey];
     } else {
       while (unkeyedCursor < oldChilds.length) {
-        if (!used2[unkeyedCursor] && getKey(oldChilds[unkeyedCursor]) == null) {
+        if (!used[unkeyedCursor] && getKey(oldChilds[unkeyedCursor]) == null) {
           oldIdx = unkeyedCursor++;
           break;
         }
@@ -4963,7 +1503,7 @@ function morphChildren(parentDom, oldChilds, newChilds, opts) {
       }
     }
     if (oldIdx >= 0) {
-      used2[oldIdx] = 1;
+      used[oldIdx] = 1;
       const newDom = morphNode(domNodes[oldIdx], oldChilds[oldIdx], newChild, opts);
       const ref = parentDom.childNodes[j] ?? null;
       if (newDom !== ref)
@@ -4974,7 +1514,7 @@ function morphChildren(parentDom, oldChilds, newChilds, opts) {
     }
   }
   for (let i = oldChilds.length - 1;i >= 0; i--)
-    if (!used2[i] && domNodes[i].parentNode === parentDom)
+    if (!used[i] && domNodes[i].parentNode === parentDom)
       parentDom.removeChild(domNodes[i]);
 }
 function render(vnode, container, options, prev) {
@@ -5566,9 +2106,9 @@ var WRAPPER_NODES = {
 };
 
 class ParseContext {
-  constructor(document2, Text, Comment, nodes, events2, macroNodes, frame, parent) {
+  constructor(document2, Text, Comment, nodes, events, macroNodes, frame, parent) {
     this.nodes = nodes ?? [];
-    this.events = events2 ?? [];
+    this.events = events ?? [];
     this.macroNodes = macroNodes ?? [];
     this.parent = parent ?? null;
     this.frame = frame ?? {};
@@ -5582,9 +2122,9 @@ class ParseContext {
     return this.frame.macroName === name || this.parent?.isInsideMacro(name);
   }
   enterMacro(macroName, macroVars, macroSlots) {
-    const { document: document2, Text, Comment, nodes, events: events2, macroNodes } = this;
+    const { document: document2, Text, Comment, nodes, events, macroNodes } = this;
     const frame = { macroName, macroVars, macroSlots };
-    return new ParseContext(document2, Text, Comment, nodes, events2, macroNodes, frame, this);
+    return new ParseContext(document2, Text, Comment, nodes, events, macroNodes, frame, this);
   }
   parseHTML(html) {
     const t = this.document.createElement("template");
@@ -5602,9 +2142,9 @@ class ParseContext {
   }
   registerEvents() {
     const id = this.events.length;
-    const events2 = new NodeEvents(id);
-    this.events.push(events2);
-    return events2;
+    const events = new NodeEvents(id);
+    this.events.push(events);
+    return events;
   }
   newMacroNode(macroName, mAttrs, childs) {
     const anySlot = [];
@@ -5762,11 +2302,6 @@ function compileModifiers(eventName, names) {
 }
 
 // src/util/parsectx.js
-var exports_parsectx = {};
-__export(exports_parsectx, {
-  collectAppClassesInSet: () => collectAppClassesInSet,
-  ParseCtxClassSetCollector: () => ParseCtxClassSetCollector
-});
 class ParseCtxClassSetCollector extends ParseContext {
   constructor(...args) {
     super(...args);
@@ -5778,9 +2313,9 @@ class ParseCtxClassSetCollector extends ParseContext {
     }
   }
   enterMacro(macroName, macroVars, macroSlots) {
-    const { document: document2, Text, Comment, nodes, events: events2, macroNodes } = this;
+    const { document: document2, Text, Comment, nodes, events, macroNodes } = this;
     const frame = { macroName, macroVars, macroSlots };
-    const v = new ParseCtxClassSetCollector(document2, Text, Comment, nodes, events2, macroNodes, frame, this);
+    const v = new ParseCtxClassSetCollector(document2, Text, Comment, nodes, events, macroNodes, frame, this);
     v.classes = this.classes;
     return v;
   }
@@ -5822,58 +2357,6 @@ class ParseCtxClassSetCollector extends ParseContext {
     return false;
   }
 }
-function collectAppClassesInSet(app) {
-  const classes = new Set;
-  for (const Comp of app.comps.byId.values()) {
-    for (const key in Comp.views) {
-      const view = Comp.views[key];
-      for (const name of view.ctx.classes) {
-        classes.add(name);
-      }
-    }
-  }
-  return classes;
-}
-
-// tools/core/lint-check.js
-var exports_lint_check = {};
-__export(exports_lint_check, {
-  checkComponent: () => checkComponent,
-  UNSUPPORTED_EXPR_SYNTAX: () => UNSUPPORTED_EXPR_SYNTAX,
-  UNKNOWN_X_OP: () => UNKNOWN_X_OP,
-  UNKNOWN_X_ATTR: () => UNKNOWN_X_ATTR,
-  UNKNOWN_REQUEST_NAME: () => UNKNOWN_REQUEST_NAME,
-  UNKNOWN_MACRO_ARG: () => UNKNOWN_MACRO_ARG,
-  UNKNOWN_HANDLER_ARG_NAME: () => UNKNOWN_HANDLER_ARG_NAME,
-  UNKNOWN_EVENT_MODIFIER: () => UNKNOWN_EVENT_MODIFIER,
-  UNKNOWN_DIRECTIVE: () => UNKNOWN_DIRECTIVE,
-  UNKNOWN_COMPONENT_SPEC_KEY: () => UNKNOWN_COMPONENT_SPEC_KEY,
-  UNKNOWN_COMPONENT_NAME: () => UNKNOWN_COMPONENT_NAME,
-  RENDER_IT_OUTSIDE_OF_LOOP: () => RENDER_IT_OUTSIDE_OF_LOOP,
-  REDUNDANT_TEMPLATE_STRING: () => REDUNDANT_TEMPLATE_STRING,
-  PLACEHOLDERLESS_TEMPLATE_STRING: () => PLACEHOLDERLESS_TEMPLATE_STRING,
-  METHOD_VAL_NOT_DEFINED: () => METHOD_VAL_NOT_DEFINED,
-  METHOD_VAL_IS_FIELD: () => METHOD_VAL_IS_FIELD,
-  MAYBE_DROP_AT_PREFIX: () => MAYBE_DROP_AT_PREFIX,
-  MAYBE_ADD_AT_PREFIX: () => MAYBE_ADD_AT_PREFIX,
-  LintParseContext: () => LintParseContext,
-  LintContext: () => LintContext,
-  INPUT_HANDLER_NOT_REFERENCED: () => INPUT_HANDLER_NOT_REFERENCED,
-  INPUT_HANDLER_NOT_IMPLEMENTED: () => INPUT_HANDLER_NOT_IMPLEMENTED,
-  INPUT_HANDLER_METHOD_NOT_IMPLEMENTED: () => INPUT_HANDLER_METHOD_NOT_IMPLEMENTED,
-  INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER: () => INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER,
-  INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD: () => INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD,
-  IF_NO_BRANCH_SET: () => IF_NO_BRANCH_SET,
-  FIELD_VAL_NOT_DEFINED: () => FIELD_VAL_NOT_DEFINED,
-  FIELD_VAL_IS_METHOD: () => FIELD_VAL_IS_METHOD,
-  DYN_VAL_NOT_DEFINED: () => DYN_VAL_NOT_DEFINED,
-  DYN_ALIAS_NOT_REFERENCED: () => DYN_ALIAS_NOT_REFERENCED,
-  DUPLICATE_ATTR_DEFINITION: () => DUPLICATE_ATTR_DEFINITION,
-  COMP_FIELD_BAD_SHAPE: () => COMP_FIELD_BAD_SHAPE,
-  BAD_VALUE: () => BAD_VALUE,
-  ALT_HANDLER_NOT_REFERENCED: () => ALT_HANDLER_NOT_REFERENCED,
-  ALT_HANDLER_NOT_DEFINED: () => ALT_HANDLER_NOT_DEFINED
-});
 
 // tools/core/html-tokenizer.js
 var CharCodes = {
@@ -7681,8 +4164,8 @@ class LinterCtx {
       return this.startInBody(name, raw, selfClosing, start, endIndex);
     }
     if (name === "input") {
-      const type3 = (this.getAttr("type") ?? "").toLowerCase();
-      if (type3 === "hidden")
+      const type = (this.getAttr("type") ?? "").toLowerCase();
+      if (type === "hidden")
         return;
       this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_WARN, start, {
         tag: raw,
@@ -8813,32 +5296,7 @@ class LintParseContext extends ParseContext {
   }
 }
 
-// tools/core/test.js
-var exports_test = {};
-__export(exports_test, {
-  runTests: () => runTests
-});
-
 // tools/core/results.js
-var exports_results = {};
-__export(exports_results, {
-  TestResult: () => TestResult,
-  TestReport: () => TestReport,
-  RenderedSection: () => RenderedSection,
-  RenderedExample: () => RenderedExample,
-  RenderBatch: () => RenderBatch,
-  ModuleTestReport: () => ModuleTestReport,
-  ModuleInfo: () => ModuleInfo,
-  LintReport: () => LintReport,
-  LintFinding: () => LintFinding,
-  LintComponentResult: () => LintComponentResult,
-  ExampleIndex: () => ExampleIndex,
-  DescribeResult: () => DescribeResult,
-  ComponentSummary: () => ComponentSummary,
-  ComponentList: () => ComponentList,
-  ComponentDocs: () => ComponentDocs
-});
-
 class ModuleInfo {
   constructor({ path = null, present = new Set, counts = {}, warnings = [] }) {
     this.path = path;
@@ -8989,15 +5447,6 @@ class TestReport {
 }
 
 // tools/core/tests.js
-var exports_tests = {};
-__export(exports_tests, {
-  makeCollector: () => makeCollector,
-  TestIndex: () => TestIndex,
-  Test: () => Test,
-  ModuleTests: () => ModuleTests,
-  Describe: () => Describe
-});
-
 class Describe {
   constructor({ title, componentName = null, parent = null }) {
     this.title = title;
@@ -9096,7 +5545,7 @@ function makeCollector({ path = null, components = [] } = {}) {
       stack.pop();
     }
   }
-  function test2(title, fn) {
+  function test(title, fn) {
     if (typeof title !== "string") {
       throw new Error("test(title, fn): title must be a string");
     }
@@ -9114,7 +5563,7 @@ function makeCollector({ path = null, components = [] } = {}) {
       parent
     }));
   }
-  return { describe, test: test2, moduleTests };
+  return { describe, test, moduleTests };
 }
 
 // tools/core/test.js
@@ -9139,7 +5588,7 @@ async function runTests({
   getTests,
   components = [],
   path = null,
-  expect: expect2,
+  expect,
   name = null,
   grep = null,
   bail = false
@@ -9150,11 +5599,11 @@ async function runTests({
       modules: [new ModuleTestReport({ path, suites: [], counts })]
     });
   }
-  if (typeof expect2 !== "function") {
+  if (typeof expect !== "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 });
+  const { describe, test, moduleTests } = makeCollector({ path, components });
+  await getTests({ describe, test, expect });
   let bailed = false;
   async function visit(node) {
     if (node instanceof Test) {
@@ -9224,10 +5673,6 @@ async function runTests({
 }
 
 // tools/core/test-console.js
-var exports_test_console = {};
-__export(exports_test_console, {
-  reportTestReportToConsole: () => reportTestReportToConsole
-});
 var PASS = "color: #0a0; font-weight: bold";
 var FAIL = "color: #c00; font-weight: bold";
 var SKIP = "color: #888";
@@ -9283,11 +5728,6 @@ function reportTestReportToConsole(report) {
 }
 
 // tools/format/lint.js
-var exports_lint = {};
-__export(exports_lint, {
-  suggestionToMessage: () => suggestionToMessage,
-  lintIdToMessage: () => lintIdToMessage
-});
 var UNSUPPORTED_EXPR_LABEL = {
   "legacy-template": "string template",
   ternary: "ternary expression",
@@ -9523,47 +5963,7 @@ function htmlActionPhrase(action, tag, parent) {
   }
 }
 
-// extra.js
-var exports_extra = {};
-__export(exports_extra, {
-  tutuca: () => tutuca,
-  test: () => test2,
-  macro: () => macro,
-  isOMap: () => isOrderedMap,
-  isIMap: () => isMap,
-  injectCss: () => injectCss,
-  html: () => html,
-  css: () => css,
-  component: () => component,
-  compileClassesToStyleText: () => compileClassesToStyleText,
-  compileClassesToStyle: () => compileClassesToStyle,
-  collectIterBindings: () => collectIterBindings,
-  check: () => check,
-  SEQ_INFO: () => SEQ_INFO,
-  ParseContext: () => ParseContext,
-  OMap: () => OrderedMap2,
-  KList: () => KList,
-  ISet: () => Set2,
-  IMap: () => Map2,
-  FIELD_CLASS: () => FIELD_CLASS
-});
-
-// src/app.js
-var exports_app = {};
-__export(exports_app, {
-  injectCss: () => injectCss,
-  App: () => App
-});
-
 // src/components.js
-var exports_components = {};
-__export(exports_components, {
-  DynamicAlias: () => DynamicAlias,
-  Dynamic: () => Dynamic,
-  Components: () => Components,
-  ComponentStack: () => ComponentStack,
-  Component: () => Component
-});
 class Components {
   constructor() {
     this.getComponentSymbol = Symbol("getComponent");
@@ -9589,10 +5989,10 @@ class Components {
     return this.getCompFor(v)?.scope.lookupRequest(name) ?? null;
   }
   compileStyles() {
-    const styles2 = [];
+    const styles = [];
     for (const comp of this.byId.values())
-      styles2.push(comp.compileStyle());
-    return styles2.join(`
+      styles.push(comp.compileStyle());
+    return styles.join(`
 `);
   }
 }
@@ -9609,20 +6009,20 @@ class ComponentStack {
     return new ComponentStack(this.comps, this);
   }
   registerComponents(comps, opts) {
-    const { aliases: aliases2 = {} } = opts ?? {};
+    const { aliases = {} } = opts ?? {};
     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 aliases2) {
-      const comp = this.byName[aliases2[alias]];
+    for (const alias in aliases) {
+      const comp = this.byName[aliases[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", aliases2[alias]);
+        console.warn("alias", alias, "to inexistent component", aliases[alias]);
     }
   }
   registerMacros(macros) {
@@ -9740,15 +6140,15 @@ class Component {
   }
   compileStyle() {
     const { id, commonStyle, globalStyle, views } = this;
-    const styles2 = commonStyle ? [`[data-cid="${id}"]{${commonStyle}}`] : [];
+    const styles = commonStyle ? [`[data-cid="${id}"]{${commonStyle}}`] : [];
     if (globalStyle !== "")
-      styles2.push(globalStyle);
+      styles.push(globalStyle);
     for (const name in views) {
       const { style } = views[name];
       if (style !== "")
-        styles2.push(`[data-cid="${id}"][data-vid="${name}"]{${style}}`);
+        styles.push(`[data-cid="${id}"][data-vid="${name}"]{${style}}`);
     }
-    return styles2.join(`
+    return styles.join(`
 `);
   }
 }
@@ -10256,27 +6656,27 @@ class App {
     return this.transactor.state;
   }
   handleEvent(e) {
-    const { type: type3 } = e;
-    if (type3[0] === "t" && type3.startsWith("touch")) {
+    const { type } = e;
+    if (type[0] === "t" && type.startsWith("touch")) {
       this._handleTouchEvent(e);
       return;
     }
     this._dispatchEvent(e);
   }
   _dispatchEvent(e) {
-    const { type: type3 } = e;
-    const isDrag = type3 === "dragover" || type3 === "dragstart" || type3 === "dragend" || type3 === "drop";
+    const { type } = e;
+    const isDrag = type === "dragover" || type === "dragstart" || type === "dragend" || type === "drop";
     const { rootNode: root, maxEventNodeDepth: maxDepth, comps, transactor } = this;
     const [path, handlers] = Path.fromEvent(e, root, maxDepth, comps, !isDrag);
     if (isDrag)
-      this._handleDragEvent(e, type3, path);
+      this._handleDragEvent(e, type, path);
     if (path !== null && handlers !== null)
       for (const handler of handlers)
         transactor.transactInputNow(path, e, handler, this.dragInfo);
   }
   _handleTouchEvent(e) {
-    const { type: type3 } = e;
-    if (type3 === "touchstart") {
+    const { type } = e;
+    if (type === "touchstart") {
       if (this._touch !== null || e.touches.length !== 1)
         return;
       const t = e.touches[0];
@@ -10293,11 +6693,11 @@ class App {
       return;
     const { rootNode, _touch } = this;
     const { clientX, clientY } = touch;
-    const fire = (type4, target) => {
-      const e2 = { type: type4, target, clientX, clientY, preventDefault: NOOP };
+    const fire = (type2, target) => {
+      const e2 = { type: type2, target, clientX, clientY, preventDefault: NOOP };
       this._dispatchEvent(e2);
     };
-    if (type3 === "touchmove") {
+    if (type === "touchmove") {
       if (!_touch.active) {
         const dx = clientX - _touch.startX;
         const dy = clientY - _touch.startY;
@@ -10312,17 +6712,17 @@ class App {
       }
       return;
     }
-    if (type3 === "touchend" || type3 === "touchcancel") {
+    if (type === "touchend" || type === "touchcancel") {
       if (_touch.active) {
-        if (type3 === "touchend")
+        if (type === "touchend")
           fire("drop", hitTest(rootNode, clientX, clientY));
         fire("dragend", _touch.target);
       }
       this._touch = null;
     }
   }
-  _handleDragEvent(e, type3, path) {
-    if (type3 === "dragover") {
+  _handleDragEvent(e, type, path) {
+    if (type === "dragover") {
       const dropTarget = getClosestDropTarget(e.target, this.rootNode, Infinity);
       if (dropTarget !== null) {
         e.preventDefault();
@@ -10330,7 +6730,7 @@ class App {
         this.curDragOver = dropTarget;
         dropTarget.dataset.draggingover = this.dragInfo?.type ?? "_external";
       }
-    } else if (type3 === "dragstart") {
+    } else if (type === "dragstart") {
       e.target.dataset.dragging = 1;
       const rootValue = this.state.val;
       const txnPath = path.compact().toTransactionPath();
@@ -10338,7 +6738,7 @@ class App {
       const dragType = e.target.dataset.dragtype ?? "?";
       const stack = path.toTransactionPath().buildStack(this.makeStack(rootValue));
       this.dragInfo = new DragInfo(txnPath, stack, e, value, dragType, e.target);
-    } else if (type3 === "drop") {
+    } else if (type === "drop") {
       e.preventDefault();
       this._cleanDragOverAttrs();
     } else {
@@ -10478,12 +6878,12 @@ function getClosestDropTarget(target, rootNode, count) {
 }
 
 class DragInfo {
-  constructor(path, stack, e, val, type3, node) {
+  constructor(path, stack, e, val, type, node) {
     this.path = path;
     this.stack = stack;
     this.e = e;
     this.val = val;
-    this.type = type3;
+    this.type = type;
     this.node = node;
   }
   lookupBind(name) {
@@ -10492,41 +6892,16 @@ class DragInfo {
 }
 
 // extra/klist.js
-var exports_klist = {};
-__export(exports_klist, {
-  KList: () => KList,
-  FieldKList: () => FieldKList
-});
 import { Map as IMap2, List as List2 } from "immutable";
 
 // src/oo.js
-var exports_oo = {};
-__export(exports_oo, {
-  getTypeName: () => getTypeName,
-  fieldsByTypeName: () => fieldsByTypeName,
-  extendProtoForKeyed: () => extendProtoForKeyed,
-  component: () => component,
-  classFromData: () => classFromData,
-  FieldString: () => FieldString,
-  FieldSet: () => FieldSet,
-  FieldOMap: () => FieldOMap,
-  FieldMap: () => FieldMap,
-  FieldList: () => FieldList,
-  FieldInt: () => FieldInt,
-  FieldFloat: () => FieldFloat,
-  FieldComp: () => FieldComp,
-  FieldBool: () => FieldBool,
-  FieldAny: () => FieldAny,
-  Field: () => Field,
-  FIELD_CLASS: () => FIELD_CLASS
-});
 import { Map as IMap, Set as ISet, List, OrderedMap, Record } from "immutable";
 var BAD_VALUE2 = Symbol("BadValue");
 var nullCoercer = (v) => v;
 
 class Field {
-  constructor(type3, name, typeCheck, coercer, defaultValue = null) {
-    this.type = type3;
+  constructor(type, name, typeCheck, coercer, defaultValue = null) {
+    this.type = type;
     this.name = name;
     this.typeCheck = typeCheck;
     this.coercer = coercer;
@@ -10534,8 +6909,8 @@ class Field {
     this.defaultValue = defaultValue;
   }
   toDataDef() {
-    const { type: type3, defaultValue: dv } = this;
-    return { type: type3, defaultValue: dv?.toJS ? dv.toJS() : dv };
+    const { type, defaultValue: dv } = this;
+    return { type, defaultValue: dv?.toJS ? dv.toJS() : dv };
   }
   getFirstFailingCheck(v) {
     if (!this.typeCheck.isValid(v))
@@ -10642,8 +7017,8 @@ class FieldAny extends Field {
   }
   toDataDef() {
     const { defaultValue: dv } = this;
-    const type3 = getTypeName(dv) ?? "any";
-    return { type: type3, defaultValue: dv?.toJS ? dv.toJS() : dv };
+    const type = getTypeName(dv) ?? "any";
+    return { type, defaultValue: dv?.toJS ? dv.toJS() : dv };
   }
 }
 var stringCoercer = (v) => v?.toString?.() ?? "";
@@ -10686,8 +7061,8 @@ class CheckTypeName {
 }
 
 class FieldComp extends Field {
-  constructor(type3, name, args) {
-    super(type3, name, new CheckTypeName(type3), nullCoercer, null);
+  constructor(type, name, args) {
+    super(type, name, new CheckTypeName(type), nullCoercer, null);
     this.args = args;
   }
   toDataDef() {
@@ -10846,8 +7221,8 @@ class ClassBuilder {
     this.fields[name] = field;
     return field;
   }
-  addCompField(name, type3, args) {
-    const field = new FieldComp(type3, name, args);
+  addCompField(name, type, args) {
+    const field = new FieldComp(type, name, args);
     this.compFields.add(name);
     this.fields[name] = field;
     return field;
@@ -10869,12 +7244,12 @@ function classFromData(name, { fields = {}, methods, statics }) {
   const b = new ClassBuilder(name);
   for (const field in fields) {
     const value = fields[field];
-    const type3 = typeof value;
-    if (type3 === "string")
+    const type = typeof value;
+    if (type === "string")
       b.addField(field, value, FieldString);
-    else if (type3 === "number")
+    else if (type === "number")
       b.addField(field, value, FieldFloat);
-    else if (type3 === "boolean")
+    else if (type === "boolean")
       b.addField(field, value, FieldBool);
     else if (List.isList(value) || Array.isArray(value))
       b.addField(field, List(value), FieldList);
@@ -10903,15 +7278,6 @@ function classFromData(name, { fields = {}, methods, statics }) {
 var component = (opts) => new Component(classFromData(opts.name, opts), opts);
 
 // src/renderer.js
-var exports_renderer = {};
-__export(exports_renderer, {
-  unpackLoopResult: () => unpackLoopResult,
-  normalizeRange: () => normalizeRange,
-  getSeqInfo: () => getSeqInfo,
-  SEQ_INFO: () => SEQ_INFO,
-  Renderer: () => Renderer,
-  DATASET_ATTRS: () => DATASET_ATTRS
-});
 import { isIndexed, isKeyed } from "immutable";
 
 // src/cache.js
@@ -11230,48 +7596,62 @@ KList.prototype[SEQ_INFO] = (seq, visit) => {
     visit(k, seq.items.get(k), "data-sk");
 };
 // index.js
-var exports_tutuca = {};
-__export(exports_tutuca, {
-  tutuca: () => tutuca,
-  test: () => test2,
-  macro: () => macro,
-  isOMap: () => isOrderedMap,
-  isIMap: () => isMap,
-  injectCss: () => injectCss,
-  html: () => html,
-  css: () => css,
-  component: () => component,
-  collectIterBindings: () => collectIterBindings,
-  check: () => check,
-  SEQ_INFO: () => SEQ_INFO,
-  ParseContext: () => ParseContext,
-  OMap: () => OrderedMap2,
-  ISet: () => Set2,
-  IMap: () => Map2,
-  FIELD_CLASS: () => FIELD_CLASS
-});
-__reExport(exports_tutuca, immutable);
-import"immutable";
 import {
-  isMap,
-  isOrderedMap,
+  Collection,
+  List as List3,
   Map as Map2,
   OrderedMap as OrderedMap2,
-  Set as Set2
+  OrderedSet,
+  PairSorting,
+  Range,
+  Record as Record2,
+  Repeat,
+  Seq,
+  Set as Set2,
+  Stack as Stack2,
+  fromJS,
+  get,
+  getIn,
+  has,
+  hasIn,
+  hash,
+  is as is2,
+  isAssociative,
+  isCollection,
+  isImmutable,
+  isIndexed as isIndexed2,
+  isKeyed as isKeyed2,
+  isList,
+  isMap,
+  isOrdered,
+  isOrderedMap,
+  isOrderedSet,
+  isPlainObject,
+  isRecord,
+  isSeq,
+  isSet,
+  isStack,
+  isValueObject,
+  merge,
+  mergeDeep,
+  mergeDeepWith,
+  mergeWith,
+  remove,
+  removeIn,
+  set,
+  setIn,
+  update,
+  updateIn,
+  version,
+  isMap as isMap2,
+  isOrderedMap as isOrderedMap2,
+  Map as Map3,
+  OrderedMap as OrderedMap3,
+  Set as Set3
 } from "immutable";
 var css = String.raw;
 var html = String.raw;
 var macro = (defaults, rawView) => new Macro(defaults, rawView);
-function check(_app) {
-  return { error: 0, warn: 0, hint: 0, dummyCheck: true };
-}
-async function test2(_opts) {
-  return null;
-}
-function collectIterBindings() {
-  console.warn("collectIterBindings is a no-op in the core tutuca build; use the tutuca-dev build for a functional implementation");
-  return [];
-}
 function tutuca(nodeOrSelector) {
   const rootNode = typeof nodeOrSelector === "string" ? document.querySelector(nodeOrSelector) : nodeOrSelector;
   const comps = new Components;
@@ -11280,7 +7660,6 @@ function tutuca(nodeOrSelector) {
 }
 
 // extra.js
-__reExport(exports_extra, exports_tutuca);
 async function compileClassesToStyle(app, compileClasses, styleId = "margaui-css") {
   const t1 = performance.now();
   const css2 = await compileClassesToStyleText(app, compileClasses);
@@ -11301,16 +7680,7 @@ async function compileClassesToStyleText(app, compileClasses, Ctx = ParseCtxClas
   }
   return await compileClasses(Array.from(classes));
 }
-
-// dev.js
-__reExport(exports_dev, exports_extra);
-
 // tools/core/docs.js
-var exports_docs = {};
-__export(exports_docs, {
-  getComponentsDocs: () => getComponentsDocs,
-  docComponents: () => docComponents
-});
 function getSignature(name, fn) {
   const s = fn.toString();
   const m = s.match(/^(?:\w+|function\s*\w*)\s*\(([^)]*)\)/);
@@ -11318,7 +7688,7 @@ function getSignature(name, fn) {
   return `${name}(${params})`;
 }
 function getFieldMethods(field) {
-  const { name, type: type3 } = field;
+  const { name, type } = field;
   const uname = name[0].toUpperCase() + name.slice(1);
   const methods = [
     { name: `set${uname}`, sig: `set${uname}(v)`, desc: "Set value" },
@@ -11333,7 +7703,7 @@ function getFieldMethods(field) {
       desc: "Reset to default value"
     }
   ];
-  switch (type3) {
+  switch (type) {
     case "bool":
       methods[0].desc = "Set value (coerces to boolean)";
       methods.push({
@@ -11386,7 +7756,7 @@ function getFieldMethods(field) {
       break;
     case "map":
     case "omap": {
-      const label = type3 === "omap" ? "ordered map" : "map";
+      const label = type === "omap" ? "ordered map" : "map";
       methods.push({
         name: `${name}Len`,
         sig: `${name}Len()`,
@@ -11481,10 +7851,6 @@ function docComponents(normalized, { name = null } = {}) {
   return new ComponentDocs({ items: getComponentsDocs(picked) });
 }
 // src/util/testing.js
-var exports_testing = {};
-__export(exports_testing, {
-  collectIterBindings: () => collectIterBindings2
-});
 var filterAlwaysTrue2 = () => true;
 var nullLoopWith2 = (seq) => ({ iterData: { seq } });
 var plainArrayIter = (seq, visit, start, end) => {
@@ -11519,7 +7885,7 @@ function resolveAlter(Comp, name) {
   }
   return fn;
 }
-function collectIterBindings2(Comp, compInstance, seq, opts = {}) {
+function collectIterBindings(Comp, compInstance, seq, opts = {}) {
   const whenFn = resolveAlter(Comp, opts.when) ?? filterAlwaysTrue2;
   const loopWithFn = resolveAlter(Comp, opts.loopWith) ?? nullLoopWith2;
   const enrichFn = resolveAlter(Comp, opts.enrichWith);
@@ -11539,12 +7905,12 @@ function collectIterBindings2(Comp, compInstance, seq, opts = {}) {
 }
 
 // dev.js
-async function test4(opts = {}) {
+async function test2(opts = {}) {
   const report = await runTests({ expect, ...opts });
   reportTestReportToConsole(report);
   return report;
 }
-function check2(app) {
+function check(app) {
   const counts = { error: 0, warn: 0, hint: 0 };
   for (const Comp of app.comps.byId.values()) {
     const shadowViews = {};
@@ -11587,9 +7953,9 @@ class LintClassCollectorCtx extends ParseCtxClassSetCollector {
     this.parseIssues = [];
   }
   enterMacro(macroName, macroVars, macroSlots) {
-    const { document: document2, Text, Comment, nodes, events: events2, macroNodes } = this;
+    const { document: document2, Text, Comment, nodes, events, macroNodes } = this;
     const frame = { macroName, macroVars, macroSlots };
-    const v = new LintClassCollectorCtx(document2, Text, Comment, nodes, events2, macroNodes, frame, this);
+    const v = new LintClassCollectorCtx(document2, Text, Comment, nodes, events, macroNodes, frame, this);
     v.classes = this.classes;
     v.attrs = this.attrs;
     v.parseIssues = this.parseIssues;
@@ -11605,27 +7971,61 @@ class LintClassCollectorCtx extends ParseCtxClassSetCollector {
   }
 }
 export {
+  version,
+  updateIn,
+  update,
   tutuca,
-  test4 as test,
+  test2 as test,
   suggestionToMessage,
+  setIn,
+  set,
   runTests,
   reportTestReportToConsole,
+  removeIn,
+  remove,
+  mergeWith,
+  mergeDeepWith,
+  mergeDeep,
+  merge,
   makeCollector,
   macro,
   lintIdToMessage,
-  isOrderedMap as isOMap,
-  isMap as isIMap,
+  isValueObject,
+  isStack,
+  isSet,
+  isSeq,
+  isRecord,
+  isPlainObject,
+  isOrderedSet,
+  isOrderedMap,
+  isOrdered,
+  isOrderedMap2 as isOMap,
+  isMap,
+  isList,
+  isKeyed2 as isKeyed,
+  isIndexed2 as isIndexed,
+  isImmutable,
+  isMap2 as isIMap,
+  isCollection,
+  isAssociative,
+  is2 as is,
   injectCss,
   html,
+  hash,
+  hasIn,
+  has,
+  getIn,
   getComponentsDocs,
+  get,
+  fromJS,
   docComponents,
   css,
   component,
   compileClassesToStyleText,
   compileClassesToStyle,
-  collectIterBindings2 as collectIterBindings,
+  collectIterBindings,
   checkComponent,
-  check2 as check,
+  check,
   UNSUPPORTED_EXPR_SYNTAX,
   UNKNOWN_X_OP,
   UNKNOWN_X_ATTR,
@@ -11640,22 +8040,33 @@ export {
   TestReport,
   TestIndex,
   Test,
+  Stack2 as Stack,
+  Set2 as Set,
+  Seq,
   SEQ_INFO,
+  Repeat,
   RenderedSection,
   RenderedExample,
   RenderBatch,
+  Record2 as Record,
+  Range,
   RENDER_IT_OUTSIDE_OF_LOOP,
   REDUNDANT_TEMPLATE_STRING,
   ParseContext,
+  PairSorting,
   PLACEHOLDERLESS_TEMPLATE_STRING,
-  OrderedMap2 as OMap,
+  OrderedSet,
+  OrderedMap2 as OrderedMap,
+  OrderedMap3 as OMap,
   ModuleTests,
   ModuleTestReport,
   ModuleInfo,
+  Map2 as Map,
   METHOD_VAL_NOT_DEFINED,
   METHOD_VAL_IS_FIELD,
   MAYBE_DROP_AT_PREFIX,
   MAYBE_ADD_AT_PREFIX,
+  List3 as List,
   LintReport,
   LintParseContext,
   LintFinding,
@@ -11663,13 +8074,13 @@ export {
   LintComponentResult,
   LintClassCollectorCtx,
   KList,
-  Set2 as ISet,
+  Set3 as ISet,
   INPUT_HANDLER_NOT_REFERENCED,
   INPUT_HANDLER_NOT_IMPLEMENTED,
   INPUT_HANDLER_METHOD_NOT_IMPLEMENTED,
   INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER,
   INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD,
-  Map2 as IMap,
+  Map3 as IMap,
   IF_NO_BRANCH_SET,
   FIELD_VAL_NOT_DEFINED,
   FIELD_VAL_IS_METHOD,
@@ -11683,6 +8094,7 @@ export {
   ComponentSummary,
   ComponentList,
   ComponentDocs,
+  Collection,
   COMP_FIELD_BAD_SHAPE,
   BAD_VALUE,
   ALT_HANDLER_NOT_REFERENCED,