Brunobkr/llama.cpp_AlgMor24_github

1var __defProp = Object.defineProperty;2var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;3var __name = (target, value) => __defProp(target, "name", { value, configurable: true });4var __export = (target, all) => {5  for (var name in all)6    __defProp(target, name, { get: all[name], enumerable: true });7};8var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);9 10// lib/chai/utils/index.js11var utils_exports = {};12__export(utils_exports, {13  addChainableMethod: () => addChainableMethod,14  addLengthGuard: () => addLengthGuard,15  addMethod: () => addMethod,16  addProperty: () => addProperty,17  checkError: () => check_error_exports,18  compareByInspect: () => compareByInspect,19  eql: () => deep_eql_default,20  events: () => events,21  expectTypes: () => expectTypes,22  flag: () => flag,23  getActual: () => getActual,24  getMessage: () => getMessage2,25  getName: () => getName,26  getOperator: () => getOperator,27  getOwnEnumerableProperties: () => getOwnEnumerableProperties,28  getOwnEnumerablePropertySymbols: () => getOwnEnumerablePropertySymbols,29  getPathInfo: () => getPathInfo,30  hasProperty: () => hasProperty,31  inspect: () => inspect2,32  isNaN: () => isNaN2,33  isNumeric: () => isNumeric,34  isProxyEnabled: () => isProxyEnabled,35  isRegExp: () => isRegExp2,36  objDisplay: () => objDisplay,37  overwriteChainableMethod: () => overwriteChainableMethod,38  overwriteMethod: () => overwriteMethod,39  overwriteProperty: () => overwriteProperty,40  proxify: () => proxify,41  test: () => test,42  transferFlags: () => transferFlags,43  type: () => type44});45 46// node_modules/check-error/index.js47var check_error_exports = {};48__export(check_error_exports, {49  compatibleConstructor: () => compatibleConstructor,50  compatibleInstance: () => compatibleInstance,51  compatibleMessage: () => compatibleMessage,52  getConstructorName: () => getConstructorName,53  getMessage: () => getMessage54});55function isErrorInstance(obj) {56  return obj instanceof Error || Object.prototype.toString.call(obj) === "[object Error]";57}58__name(isErrorInstance, "isErrorInstance");59function isRegExp(obj) {60  return Object.prototype.toString.call(obj) === "[object RegExp]";61}62__name(isRegExp, "isRegExp");63function compatibleInstance(thrown, errorLike) {64  return isErrorInstance(errorLike) && thrown === errorLike;65}66__name(compatibleInstance, "compatibleInstance");67function compatibleConstructor(thrown, errorLike) {68  if (isErrorInstance(errorLike)) {69    return thrown.constructor === errorLike.constructor || thrown instanceof errorLike.constructor;70  } else if ((typeof errorLike === "object" || typeof errorLike === "function") && errorLike.prototype) {71    return thrown.constructor === errorLike || thrown instanceof errorLike;72  }73  return false;74}75__name(compatibleConstructor, "compatibleConstructor");76function compatibleMessage(thrown, errMatcher) {77  const comparisonString = typeof thrown === "string" ? thrown : thrown.message;78  if (isRegExp(errMatcher)) {79    return errMatcher.test(comparisonString);80  } else if (typeof errMatcher === "string") {81    return comparisonString.indexOf(errMatcher) !== -1;82  }83  return false;84}85__name(compatibleMessage, "compatibleMessage");86function getConstructorName(errorLike) {87  let constructorName = errorLike;88  if (isErrorInstance(errorLike)) {89    constructorName = errorLike.constructor.name;90  } else if (typeof errorLike === "function") {91    constructorName = errorLike.name;92    if (constructorName === "") {93      const newConstructorName = new errorLike().name;94      constructorName = newConstructorName || constructorName;95    }96  }97  return constructorName;98}99__name(getConstructorName, "getConstructorName");100function getMessage(errorLike) {101  let msg = "";102  if (errorLike && errorLike.message) {103    msg = errorLike.message;104  } else if (typeof errorLike === "string") {105    msg = errorLike;106  }107  return msg;108}109__name(getMessage, "getMessage");110 111// lib/chai/utils/flag.js112function flag(obj, key, value) {113  let flags = obj.__flags || (obj.__flags = /* @__PURE__ */ Object.create(null));114  if (arguments.length === 3) {115    flags[key] = value;116  } else {117    return flags[key];118  }119}120__name(flag, "flag");121 122// lib/chai/utils/test.js123function test(obj, args) {124  let negate = flag(obj, "negate"), expr = args[0];125  return negate ? !expr : expr;126}127__name(test, "test");128 129// lib/chai/utils/type-detect.js130function type(obj) {131  if (typeof obj === "undefined") {132    return "undefined";133  }134  if (obj === null) {135    return "null";136  }137  const stringTag = obj[Symbol.toStringTag];138  if (typeof stringTag === "string") {139    return stringTag;140  }141  const type3 = Object.prototype.toString.call(obj).slice(8, -1);142  return type3;143}144__name(type, "type");145 146// node_modules/assertion-error/index.js147var canElideFrames = "captureStackTrace" in Error;148var _AssertionError = class _AssertionError extends Error {149  constructor(message = "Unspecified AssertionError", props, ssf) {150    super(message);151    __publicField(this, "message");152    this.message = message;153    if (canElideFrames) {154      Error.captureStackTrace(this, ssf || _AssertionError);155    }156    for (const key in props) {157      if (!(key in this)) {158        this[key] = props[key];159      }160    }161  }162  get name() {163    return "AssertionError";164  }165  get ok() {166    return false;167  }168  toJSON(stack) {169    return {170      ...this,171      name: this.name,172      message: this.message,173      ok: false,174      stack: stack !== false ? this.stack : void 0175    };176  }177};178__name(_AssertionError, "AssertionError");179var AssertionError = _AssertionError;180 181// lib/chai/utils/expectTypes.js182function expectTypes(obj, types) {183  let flagMsg = flag(obj, "message");184  let ssfi = flag(obj, "ssfi");185  flagMsg = flagMsg ? flagMsg + ": " : "";186  obj = flag(obj, "object");187  types = types.map(function(t) {188    return t.toLowerCase();189  });190  types.sort();191  let str = types.map(function(t, index) {192    let art = ~["a", "e", "i", "o", "u"].indexOf(t.charAt(0)) ? "an" : "a";193    let or = types.length > 1 && index === types.length - 1 ? "or " : "";194    return or + art + " " + t;195  }).join(", ");196  let objType = type(obj).toLowerCase();197  if (!types.some(function(expected) {198    return objType === expected;199  })) {200    throw new AssertionError(201      flagMsg + "object tested must be " + str + ", but " + objType + " given",202      void 0,203      ssfi204    );205  }206}207__name(expectTypes, "expectTypes");208 209// lib/chai/utils/getActual.js210function getActual(obj, args) {211  return args.length > 4 ? args[4] : obj._obj;212}213__name(getActual, "getActual");214 215// node_modules/loupe/lib/helpers.js216var ansiColors = {217  bold: ["1", "22"],218  dim: ["2", "22"],219  italic: ["3", "23"],220  underline: ["4", "24"],221  // 5 & 6 are blinking222  inverse: ["7", "27"],223  hidden: ["8", "28"],224  strike: ["9", "29"],225  // 10-20 are fonts226  // 21-29 are resets for 1-9227  black: ["30", "39"],228  red: ["31", "39"],229  green: ["32", "39"],230  yellow: ["33", "39"],231  blue: ["34", "39"],232  magenta: ["35", "39"],233  cyan: ["36", "39"],234  white: ["37", "39"],235  brightblack: ["30;1", "39"],236  brightred: ["31;1", "39"],237  brightgreen: ["32;1", "39"],238  brightyellow: ["33;1", "39"],239  brightblue: ["34;1", "39"],240  brightmagenta: ["35;1", "39"],241  brightcyan: ["36;1", "39"],242  brightwhite: ["37;1", "39"],243  grey: ["90", "39"]244};245var styles = {246  special: "cyan",247  number: "yellow",248  bigint: "yellow",249  boolean: "yellow",250  undefined: "grey",251  null: "bold",252  string: "green",253  symbol: "green",254  date: "magenta",255  regexp: "red"256};257var truncator = "\u2026";258function colorise(value, styleType) {259  const color = ansiColors[styles[styleType]] || ansiColors[styleType] || "";260  if (!color) {261    return String(value);262  }263  return `\x1B[${color[0]}m${String(value)}\x1B[${color[1]}m`;264}265__name(colorise, "colorise");266function normaliseOptions({267  showHidden = false,268  depth = 2,269  colors = false,270  customInspect = true,271  showProxy = false,272  maxArrayLength = Infinity,273  breakLength = Infinity,274  seen = [],275  // eslint-disable-next-line no-shadow276  truncate: truncate2 = Infinity,277  stylize = String278} = {}, inspect3) {279  const options = {280    showHidden: Boolean(showHidden),281    depth: Number(depth),282    colors: Boolean(colors),283    customInspect: Boolean(customInspect),284    showProxy: Boolean(showProxy),285    maxArrayLength: Number(maxArrayLength),286    breakLength: Number(breakLength),287    truncate: Number(truncate2),288    seen,289    inspect: inspect3,290    stylize291  };292  if (options.colors) {293    options.stylize = colorise;294  }295  return options;296}297__name(normaliseOptions, "normaliseOptions");298function isHighSurrogate(char) {299  return char >= "\uD800" && char <= "\uDBFF";300}301__name(isHighSurrogate, "isHighSurrogate");302function truncate(string, length, tail = truncator) {303  string = String(string);304  const tailLength = tail.length;305  const stringLength = string.length;306  if (tailLength > length && stringLength > tailLength) {307    return tail;308  }309  if (stringLength > length && stringLength > tailLength) {310    let end = length - tailLength;311    if (end > 0 && isHighSurrogate(string[end - 1])) {312      end = end - 1;313    }314    return `${string.slice(0, end)}${tail}`;315  }316  return string;317}318__name(truncate, "truncate");319function inspectList(list, options, inspectItem, separator = ", ") {320  inspectItem = inspectItem || options.inspect;321  const size = list.length;322  if (size === 0)323    return "";324  const originalLength = options.truncate;325  let output = "";326  let peek = "";327  let truncated = "";328  for (let i = 0; i < size; i += 1) {329    const last = i + 1 === list.length;330    const secondToLast = i + 2 === list.length;331    truncated = `${truncator}(${list.length - i})`;332    const value = list[i];333    options.truncate = originalLength - output.length - (last ? 0 : separator.length);334    const string = peek || inspectItem(value, options) + (last ? "" : separator);335    const nextLength = output.length + string.length;336    const truncatedLength = nextLength + truncated.length;337    if (last && nextLength > originalLength && output.length + truncated.length <= originalLength) {338      break;339    }340    if (!last && !secondToLast && truncatedLength > originalLength) {341      break;342    }343    peek = last ? "" : inspectItem(list[i + 1], options) + (secondToLast ? "" : separator);344    if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) {345      break;346    }347    output += string;348    if (!last && !secondToLast && nextLength + peek.length >= originalLength) {349      truncated = `${truncator}(${list.length - i - 1})`;350      break;351    }352    truncated = "";353  }354  return `${output}${truncated}`;355}356__name(inspectList, "inspectList");357function quoteComplexKey(key) {358  if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) {359    return key;360  }361  return JSON.stringify(key).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");362}363__name(quoteComplexKey, "quoteComplexKey");364function inspectProperty([key, value], options) {365  options.truncate -= 2;366  if (typeof key === "string") {367    key = quoteComplexKey(key);368  } else if (typeof key !== "number") {369    key = `[${options.inspect(key, options)}]`;370  }371  options.truncate -= key.length;372  value = options.inspect(value, options);373  return `${key}: ${value}`;374}375__name(inspectProperty, "inspectProperty");376 377// node_modules/loupe/lib/array.js378function inspectArray(array, options) {379  const nonIndexProperties = Object.keys(array).slice(array.length);380  if (!array.length && !nonIndexProperties.length)381    return "[]";382  options.truncate -= 4;383  const listContents = inspectList(array, options);384  options.truncate -= listContents.length;385  let propertyContents = "";386  if (nonIndexProperties.length) {387    propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty);388  }389  return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ""} ]`;390}391__name(inspectArray, "inspectArray");392 393// node_modules/loupe/lib/typedarray.js394var getArrayName = /* @__PURE__ */ __name((array) => {395  if (typeof Buffer === "function" && array instanceof Buffer) {396    return "Buffer";397  }398  if (array[Symbol.toStringTag]) {399    return array[Symbol.toStringTag];400  }401  return array.constructor.name;402}, "getArrayName");403function inspectTypedArray(array, options) {404  const name = getArrayName(array);405  options.truncate -= name.length + 4;406  const nonIndexProperties = Object.keys(array).slice(array.length);407  if (!array.length && !nonIndexProperties.length)408    return `${name}[]`;409  let output = "";410  for (let i = 0; i < array.length; i++) {411    const string = `${options.stylize(truncate(array[i], options.truncate), "number")}${i === array.length - 1 ? "" : ", "}`;412    options.truncate -= string.length;413    if (array[i] !== array.length && options.truncate <= 3) {414      output += `${truncator}(${array.length - array[i] + 1})`;415      break;416    }417    output += string;418  }419  let propertyContents = "";420  if (nonIndexProperties.length) {421    propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty);422  }423  return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`;424}425__name(inspectTypedArray, "inspectTypedArray");426 427// node_modules/loupe/lib/date.js428function inspectDate(dateObject, options) {429  const stringRepresentation = dateObject.toJSON();430  if (stringRepresentation === null) {431    return "Invalid Date";432  }433  const split = stringRepresentation.split("T");434  const date = split[0];435  return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, "date");436}437__name(inspectDate, "inspectDate");438 439// node_modules/loupe/lib/function.js440function inspectFunction(func, options) {441  const functionType = func[Symbol.toStringTag] || "Function";442  const name = func.name;443  if (!name) {444    return options.stylize(`[${functionType}]`, "special");445  }446  return options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, "special");447}448__name(inspectFunction, "inspectFunction");449 450// node_modules/loupe/lib/map.js451function inspectMapEntry([key, value], options) {452  options.truncate -= 4;453  key = options.inspect(key, options);454  options.truncate -= key.length;455  value = options.inspect(value, options);456  return `${key} => ${value}`;457}458__name(inspectMapEntry, "inspectMapEntry");459function mapToEntries(map) {460  const entries = [];461  map.forEach((value, key) => {462    entries.push([key, value]);463  });464  return entries;465}466__name(mapToEntries, "mapToEntries");467function inspectMap(map, options) {468  if (map.size === 0)469    return "Map{}";470  options.truncate -= 7;471  return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`;472}473__name(inspectMap, "inspectMap");474 475// node_modules/loupe/lib/number.js476var isNaN = Number.isNaN || ((i) => i !== i);477function inspectNumber(number, options) {478  if (isNaN(number)) {479    return options.stylize("NaN", "number");480  }481  if (number === Infinity) {482    return options.stylize("Infinity", "number");483  }484  if (number === -Infinity) {485    return options.stylize("-Infinity", "number");486  }487  if (number === 0) {488    return options.stylize(1 / number === Infinity ? "+0" : "-0", "number");489  }490  return options.stylize(truncate(String(number), options.truncate), "number");491}492__name(inspectNumber, "inspectNumber");493 494// node_modules/loupe/lib/bigint.js495function inspectBigInt(number, options) {496  let nums = truncate(number.toString(), options.truncate - 1);497  if (nums !== truncator)498    nums += "n";499  return options.stylize(nums, "bigint");500}501__name(inspectBigInt, "inspectBigInt");502 503// node_modules/loupe/lib/regexp.js504function inspectRegExp(value, options) {505  const flags = value.toString().split("/")[2];506  const sourceLength = options.truncate - (2 + flags.length);507  const source = value.source;508  return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, "regexp");509}510__name(inspectRegExp, "inspectRegExp");511 512// node_modules/loupe/lib/set.js513function arrayFromSet(set2) {514  const values = [];515  set2.forEach((value) => {516    values.push(value);517  });518  return values;519}520__name(arrayFromSet, "arrayFromSet");521function inspectSet(set2, options) {522  if (set2.size === 0)523    return "Set{}";524  options.truncate -= 7;525  return `Set{ ${inspectList(arrayFromSet(set2), options)} }`;526}527__name(inspectSet, "inspectSet");528 529// node_modules/loupe/lib/string.js530var stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g");531var escapeCharacters = {532  "\b": "\\b",533  "	": "\\t",534  "\n": "\\n",535  "\f": "\\f",536  "\r": "\\r",537  "'": "\\'",538  "\\": "\\\\"539};540var hex = 16;541var unicodeLength = 4;542function escape(char) {543  return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-unicodeLength)}`;544}545__name(escape, "escape");546function inspectString(string, options) {547  if (stringEscapeChars.test(string)) {548    string = string.replace(stringEscapeChars, escape);549  }550  return options.stylize(`'${truncate(string, options.truncate - 2)}'`, "string");551}552__name(inspectString, "inspectString");553 554// node_modules/loupe/lib/symbol.js555function inspectSymbol(value) {556  if ("description" in Symbol.prototype) {557    return value.description ? `Symbol(${value.description})` : "Symbol()";558  }559  return value.toString();560}561__name(inspectSymbol, "inspectSymbol");562 563// node_modules/loupe/lib/promise.js564var getPromiseValue = /* @__PURE__ */ __name(() => "Promise{\u2026}", "getPromiseValue");565var promise_default = getPromiseValue;566 567// node_modules/loupe/lib/object.js568function inspectObject(object, options) {569  const properties = Object.getOwnPropertyNames(object);570  const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [];571  if (properties.length === 0 && symbols.length === 0) {572    return "{}";573  }574  options.truncate -= 4;575  options.seen = options.seen || [];576  if (options.seen.includes(object)) {577    return "[Circular]";578  }579  options.seen.push(object);580  const propertyContents = inspectList(properties.map((key) => [key, object[key]]), options, inspectProperty);581  const symbolContents = inspectList(symbols.map((key) => [key, object[key]]), options, inspectProperty);582  options.seen.pop();583  let sep = "";584  if (propertyContents && symbolContents) {585    sep = ", ";586  }587  return `{ ${propertyContents}${sep}${symbolContents} }`;588}589__name(inspectObject, "inspectObject");590 591// node_modules/loupe/lib/class.js592var toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag ? Symbol.toStringTag : false;593function inspectClass(value, options) {594  let name = "";595  if (toStringTag && toStringTag in value) {596    name = value[toStringTag];597  }598  name = name || value.constructor.name;599  if (!name || name === "_class") {600    name = "<Anonymous Class>";601  }602  options.truncate -= name.length;603  return `${name}${inspectObject(value, options)}`;604}605__name(inspectClass, "inspectClass");606 607// node_modules/loupe/lib/arguments.js608function inspectArguments(args, options) {609  if (args.length === 0)610    return "Arguments[]";611  options.truncate -= 13;612  return `Arguments[ ${inspectList(args, options)} ]`;613}614__name(inspectArguments, "inspectArguments");615 616// node_modules/loupe/lib/error.js617var errorKeys = [618  "stack",619  "line",620  "column",621  "name",622  "message",623  "fileName",624  "lineNumber",625  "columnNumber",626  "number",627  "description",628  "cause"629];630function inspectObject2(error, options) {631  const properties = Object.getOwnPropertyNames(error).filter((key) => errorKeys.indexOf(key) === -1);632  const name = error.name;633  options.truncate -= name.length;634  let message = "";635  if (typeof error.message === "string") {636    message = truncate(error.message, options.truncate);637  } else {638    properties.unshift("message");639  }640  message = message ? `: ${message}` : "";641  options.truncate -= message.length + 5;642  options.seen = options.seen || [];643  if (options.seen.includes(error)) {644    return "[Circular]";645  }646  options.seen.push(error);647  const propertyContents = inspectList(properties.map((key) => [key, error[key]]), options, inspectProperty);648  return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ""}`;649}650__name(inspectObject2, "inspectObject");651 652// node_modules/loupe/lib/html.js653function inspectAttribute([key, value], options) {654  options.truncate -= 3;655  if (!value) {656    return `${options.stylize(String(key), "yellow")}`;657  }658  return `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}`;659}660__name(inspectAttribute, "inspectAttribute");661function inspectNodeCollection(collection, options) {662  return inspectList(collection, options, inspectNode, "\n");663}664__name(inspectNodeCollection, "inspectNodeCollection");665function inspectNode(node, options) {666  switch (node.nodeType) {667    case 1:668      return inspectHTML(node, options);669    case 3:670      return options.inspect(node.data, options);671    default:672      return options.inspect(node, options);673  }674}675__name(inspectNode, "inspectNode");676function inspectHTML(element, options) {677  const properties = element.getAttributeNames();678  const name = element.tagName.toLowerCase();679  const head = options.stylize(`<${name}`, "special");680  const headClose = options.stylize(`>`, "special");681  const tail = options.stylize(`</${name}>`, "special");682  options.truncate -= name.length * 2 + 5;683  let propertyContents = "";684  if (properties.length > 0) {685    propertyContents += " ";686    propertyContents += inspectList(properties.map((key) => [key, element.getAttribute(key)]), options, inspectAttribute, " ");687  }688  options.truncate -= propertyContents.length;689  const truncate2 = options.truncate;690  let children = inspectNodeCollection(element.children, options);691  if (children && children.length > truncate2) {692    children = `${truncator}(${element.children.length})`;693  }694  return `${head}${propertyContents}${headClose}${children}${tail}`;695}696__name(inspectHTML, "inspectHTML");697 698// node_modules/loupe/lib/index.js699var symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function";700var chaiInspect = symbolsSupported ? /* @__PURE__ */ Symbol.for("chai/inspect") : "@@chai/inspect";701var nodeInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");702var constructorMap = /* @__PURE__ */ new WeakMap();703var stringTagMap = {};704var baseTypesMap = {705  undefined: /* @__PURE__ */ __name((value, options) => options.stylize("undefined", "undefined"), "undefined"),706  null: /* @__PURE__ */ __name((value, options) => options.stylize("null", "null"), "null"),707  boolean: /* @__PURE__ */ __name((value, options) => options.stylize(String(value), "boolean"), "boolean"),708  Boolean: /* @__PURE__ */ __name((value, options) => options.stylize(String(value), "boolean"), "Boolean"),709  number: inspectNumber,710  Number: inspectNumber,711  bigint: inspectBigInt,712  BigInt: inspectBigInt,713  string: inspectString,714  String: inspectString,715  function: inspectFunction,716  Function: inspectFunction,717  symbol: inspectSymbol,718  // A Symbol polyfill will return `Symbol` not `symbol` from typedetect719  Symbol: inspectSymbol,720  Array: inspectArray,721  Date: inspectDate,722  Map: inspectMap,723  Set: inspectSet,724  RegExp: inspectRegExp,725  Promise: promise_default,726  // WeakSet, WeakMap are totally opaque to us727  WeakSet: /* @__PURE__ */ __name((value, options) => options.stylize("WeakSet{\u2026}", "special"), "WeakSet"),728  WeakMap: /* @__PURE__ */ __name((value, options) => options.stylize("WeakMap{\u2026}", "special"), "WeakMap"),729  Arguments: inspectArguments,730  Int8Array: inspectTypedArray,731  Uint8Array: inspectTypedArray,732  Uint8ClampedArray: inspectTypedArray,733  Int16Array: inspectTypedArray,734  Uint16Array: inspectTypedArray,735  Int32Array: inspectTypedArray,736  Uint32Array: inspectTypedArray,737  Float32Array: inspectTypedArray,738  Float64Array: inspectTypedArray,739  Generator: /* @__PURE__ */ __name(() => "", "Generator"),740  DataView: /* @__PURE__ */ __name(() => "", "DataView"),741  ArrayBuffer: /* @__PURE__ */ __name(() => "", "ArrayBuffer"),742  Error: inspectObject2,743  HTMLCollection: inspectNodeCollection,744  NodeList: inspectNodeCollection745};746var inspectCustom = /* @__PURE__ */ __name((value, options, type3, inspectFn) => {747  if (chaiInspect in value && typeof value[chaiInspect] === "function") {748    return value[chaiInspect](options);749  }750  if (nodeInspect in value && typeof value[nodeInspect] === "function") {751    return value[nodeInspect](options.depth, options, inspectFn);752  }753  if ("inspect" in value && typeof value.inspect === "function") {754    return value.inspect(options.depth, options);755  }756  if ("constructor" in value && constructorMap.has(value.constructor)) {757    return constructorMap.get(value.constructor)(value, options);758  }759  if (stringTagMap[type3]) {760    return stringTagMap[type3](value, options);761  }762  return "";763}, "inspectCustom");764var toString = Object.prototype.toString;765function inspect(value, opts = {}) {766  const options = normaliseOptions(opts, inspect);767  const { customInspect } = options;768  let type3 = value === null ? "null" : typeof value;769  if (type3 === "object") {770    type3 = toString.call(value).slice(8, -1);771  }772  if (type3 in baseTypesMap) {773    return baseTypesMap[type3](value, options);774  }775  if (customInspect && value) {776    const output = inspectCustom(value, options, type3, inspect);777    if (output) {778      if (typeof output === "string")779        return output;780      return inspect(output, options);781    }782  }783  const proto = value ? Object.getPrototypeOf(value) : false;784  if (proto === Object.prototype || proto === null) {785    return inspectObject(value, options);786  }787  if (value && typeof HTMLElement === "function" && value instanceof HTMLElement) {788    return inspectHTML(value, options);789  }790  if ("constructor" in value) {791    if (value.constructor !== Object) {792      return inspectClass(value, options);793    }794    return inspectObject(value, options);795  }796  if (value === Object(value)) {797    return inspectObject(value, options);798  }799  return options.stylize(String(value), type3);800}801__name(inspect, "inspect");802 803// lib/chai/config.js804var config = {805  /**806   * ### config.includeStack807   *808   * User configurable property, influences whether stack trace809   * is included in Assertion error message. Default of false810   * suppresses stack trace in the error message.811   *812   *     chai.config.includeStack = true;  // enable stack on error813   *814   * @param {boolean}815   * @public816   */817  includeStack: false,818  /**819   * ### config.showDiff820   *821   * User configurable property, influences whether or not822   * the `showDiff` flag should be included in the thrown823   * AssertionErrors. `false` will always be `false`; `true`824   * will be true when the assertion has requested a diff825   * be shown.826   *827   * @param {boolean}828   * @public829   */830  showDiff: true,831  /**832   * ### config.truncateThreshold833   *834   * User configurable property, sets length threshold for actual and835   * expected values in assertion errors. If this threshold is exceeded, for836   * example for large data structures, the value is replaced with something837   * like `[ Array(3) ]` or `{ Object (prop1, prop2) }`.838   *839   * Set it to zero if you want to disable truncating altogether.840   *841   * This is especially userful when doing assertions on arrays: having this842   * set to a reasonable large value makes the failure messages readily843   * inspectable.844   *845   *     chai.config.truncateThreshold = 0;  // disable truncating846   *847   * @param {number}848   * @public849   */850  truncateThreshold: 40,851  /**852   * ### config.useProxy853   *854   * User configurable property, defines if chai will use a Proxy to throw855   * an error when a non-existent property is read, which protects users856   * from typos when using property-based assertions.857   *858   * Set it to false if you want to disable this feature.859   *860   *     chai.config.useProxy = false;  // disable use of Proxy861   *862   * This feature is automatically disabled regardless of this config value863   * in environments that don't support proxies.864   *865   * @param {boolean}866   * @public867   */868  useProxy: true,869  /**870   * ### config.proxyExcludedKeys871   *872   * User configurable property, defines which properties should be ignored873   * instead of throwing an error if they do not exist on the assertion.874   * This is only applied if the environment Chai is running in supports proxies and875   * if the `useProxy` configuration setting is enabled.876   * By default, `then` and `inspect` will not throw an error if they do not exist on the877   * assertion object because the `.inspect` property is read by `util.inspect` (for example, when878   * using `console.log` on the assertion object) and `.then` is necessary for promise type-checking.879   *880   *     // By default these keys will not throw an error if they do not exist on the assertion object881   *     chai.config.proxyExcludedKeys = ['then', 'inspect'];882   *883   * @param {Array}884   * @public885   */886  proxyExcludedKeys: ["then", "catch", "inspect", "toJSON"],887  /**888   * ### config.deepEqual889   *890   * User configurable property, defines which a custom function to use for deepEqual891   * comparisons.892   * By default, the function used is the one from the `deep-eql` package without custom comparator.893   *894   *     // use a custom comparator895   *     chai.config.deepEqual = (expected, actual) => {896   *         return chai.util.eql(expected, actual, {897   *             comparator: (expected, actual) => {898   *                 // for non number comparison, use the default behavior899   *                 if(typeof expected !== 'number') return null;900   *                 // allow a difference of 10 between compared numbers901   *                 return typeof actual === 'number' && Math.abs(actual - expected) < 10902   *             }903   *         })904   *     };905   *906   * @param {Function}907   * @public908   */909  deepEqual: null910};911 912// lib/chai/utils/inspect.js913function inspect2(obj, showHidden, depth, colors) {914  let options = {915    colors,916    depth: typeof depth === "undefined" ? 2 : depth,917    showHidden,918    truncate: config.truncateThreshold ? config.truncateThreshold : Infinity919  };920  return inspect(obj, options);921}922__name(inspect2, "inspect");923 924// lib/chai/utils/objDisplay.js925function objDisplay(obj) {926  let str = inspect2(obj), type3 = Object.prototype.toString.call(obj);927  if (config.truncateThreshold && str.length >= config.truncateThreshold) {928    if (type3 === "[object Function]") {929      return !obj.name || obj.name === "" ? "[Function]" : "[Function: " + obj.name + "]";930    } else if (type3 === "[object Array]") {931      return "[ Array(" + obj.length + ") ]";932    } else if (type3 === "[object Object]") {933      let keys = Object.keys(obj), kstr = keys.length > 2 ? keys.splice(0, 2).join(", ") + ", ..." : keys.join(", ");934      return "{ Object (" + kstr + ") }";935    } else {936      return str;937    }938  } else {939    return str;940  }941}942__name(objDisplay, "objDisplay");943 944// lib/chai/utils/getMessage.js945function getMessage2(obj, args) {946  let negate = flag(obj, "negate");947  let val = flag(obj, "object");948  let expected = args[3];949  let actual = getActual(obj, args);950  let msg = negate ? args[2] : args[1];951  let flagMsg = flag(obj, "message");952  if (typeof msg === "function") msg = msg();953  msg = msg || "";954  msg = msg.replace(/#\{this\}/g, function() {955    return objDisplay(val);956  }).replace(/#\{act\}/g, function() {957    return objDisplay(actual);958  }).replace(/#\{exp\}/g, function() {959    return objDisplay(expected);960  });961  return flagMsg ? flagMsg + ": " + msg : msg;962}963__name(getMessage2, "getMessage");964 965// lib/chai/utils/transferFlags.js966function transferFlags(assertion, object, includeAll) {967  let flags = assertion.__flags || (assertion.__flags = /* @__PURE__ */ Object.create(null));968  if (!object.__flags) {969    object.__flags = /* @__PURE__ */ Object.create(null);970  }971  includeAll = arguments.length === 3 ? includeAll : true;972  for (let flag3 in flags) {973    if (includeAll || flag3 !== "object" && flag3 !== "ssfi" && flag3 !== "lockSsfi" && flag3 != "message") {974      object.__flags[flag3] = flags[flag3];975    }976  }977}978__name(transferFlags, "transferFlags");979 980// node_modules/deep-eql/index.js981function type2(obj) {982  if (typeof obj === "undefined") {983    return "undefined";984  }985  if (obj === null) {986    return "null";987  }988  const stringTag = obj[Symbol.toStringTag];989  if (typeof stringTag === "string") {990    return stringTag;991  }992  const sliceStart = 8;993  const sliceEnd = -1;994  return Object.prototype.toString.call(obj).slice(sliceStart, sliceEnd);995}996__name(type2, "type");997function FakeMap() {998  this._key = "chai/deep-eql__" + Math.random() + Date.now();999}1000__name(FakeMap, "FakeMap");1001FakeMap.prototype = {1002  get: /* @__PURE__ */ __name(function get(key) {1003    return key[this._key];1004  }, "get"),1005  set: /* @__PURE__ */ __name(function set(key, value) {1006    if (Object.isExtensible(key)) {1007      Object.defineProperty(key, this._key, {1008        value,1009        configurable: true1010      });1011    }1012  }, "set")1013};1014var MemoizeMap = typeof WeakMap === "function" ? WeakMap : FakeMap;1015function memoizeCompare(leftHandOperand, rightHandOperand, memoizeMap) {1016  if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {1017    return null;1018  }1019  var leftHandMap = memoizeMap.get(leftHandOperand);1020  if (leftHandMap) {1021    var result = leftHandMap.get(rightHandOperand);1022    if (typeof result === "boolean") {1023      return result;1024    }1025  }1026  return null;1027}1028__name(memoizeCompare, "memoizeCompare");1029function memoizeSet(leftHandOperand, rightHandOperand, memoizeMap, result) {1030  if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {1031    return;1032  }1033  var leftHandMap = memoizeMap.get(leftHandOperand);1034  if (leftHandMap) {1035    leftHandMap.set(rightHandOperand, result);1036  } else {1037    leftHandMap = new MemoizeMap();1038    leftHandMap.set(rightHandOperand, result);1039    memoizeMap.set(leftHandOperand, leftHandMap);1040  }1041}1042__name(memoizeSet, "memoizeSet");1043var deep_eql_default = deepEqual;1044function deepEqual(leftHandOperand, rightHandOperand, options) {1045  if (options && options.comparator) {1046    return extensiveDeepEqual(leftHandOperand, rightHandOperand, options);1047  }1048  var simpleResult = simpleEqual(leftHandOperand, rightHandOperand);1049  if (simpleResult !== null) {1050    return simpleResult;1051  }1052  return extensiveDeepEqual(leftHandOperand, rightHandOperand, options);1053}1054__name(deepEqual, "deepEqual");1055function simpleEqual(leftHandOperand, rightHandOperand) {1056  if (leftHandOperand === rightHandOperand) {1057    return leftHandOperand !== 0 || 1 / leftHandOperand === 1 / rightHandOperand;1058  }1059  if (leftHandOperand !== leftHandOperand && // eslint-disable-line no-self-compare1060  rightHandOperand !== rightHandOperand) {1061    return true;1062  }1063  if (isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {1064    return false;1065  }1066  return null;1067}1068__name(simpleEqual, "simpleEqual");1069function extensiveDeepEqual(leftHandOperand, rightHandOperand, options) {1070  options = options || {};1071  options.memoize = options.memoize === false ? false : options.memoize || new MemoizeMap();1072  var comparator = options && options.comparator;1073  var memoizeResultLeft = memoizeCompare(leftHandOperand, rightHandOperand, options.memoize);1074  if (memoizeResultLeft !== null) {1075    return memoizeResultLeft;1076  }1077  var memoizeResultRight = memoizeCompare(rightHandOperand, leftHandOperand, options.memoize);1078  if (memoizeResultRight !== null) {1079    return memoizeResultRight;1080  }1081  if (comparator) {1082    var comparatorResult = comparator(leftHandOperand, rightHandOperand);1083    if (comparatorResult === false || comparatorResult === true) {1084      memoizeSet(leftHandOperand, rightHandOperand, options.memoize, comparatorResult);1085      return comparatorResult;1086    }1087    var simpleResult = simpleEqual(leftHandOperand, rightHandOperand);1088    if (simpleResult !== null) {1089      return simpleResult;1090    }1091  }1092  var leftHandType = type2(leftHandOperand);1093  if (leftHandType !== type2(rightHandOperand)) {1094    memoizeSet(leftHandOperand, rightHandOperand, options.memoize, false);1095    return false;1096  }1097  memoizeSet(leftHandOperand, rightHandOperand, options.memoize, true);1098  var result = extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options);1099  memoizeSet(leftHandOperand, rightHandOperand, options.memoize, result);1100  return result;1101}1102__name(extensiveDeepEqual, "extensiveDeepEqual");1103function extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options) {1104  switch (leftHandType) {1105    case "String":1106    case "Number":1107    case "Boolean":1108    case "Date":1109      return deepEqual(leftHandOperand.valueOf(), rightHandOperand.valueOf());1110    case "Promise":1111    case "Symbol":1112    case "function":1113    case "WeakMap":1114    case "WeakSet":1115      return leftHandOperand === rightHandOperand;1116    case "Error":1117      return keysEqual(leftHandOperand, rightHandOperand, ["name", "message", "code"], options);1118    case "Arguments":1119    case "Int8Array":1120    case "Uint8Array":1121    case "Uint8ClampedArray":1122    case "Int16Array":1123    case "Uint16Array":1124    case "Int32Array":1125    case "Uint32Array":1126    case "Float32Array":1127    case "Float64Array":1128    case "Array":1129      return iterableEqual(leftHandOperand, rightHandOperand, options);1130    case "RegExp":1131      return regexpEqual(leftHandOperand, rightHandOperand);1132    case "Generator":1133      return generatorEqual(leftHandOperand, rightHandOperand, options);1134    case "DataView":1135      return iterableEqual(new Uint8Array(leftHandOperand.buffer), new Uint8Array(rightHandOperand.buffer), options);1136    case "ArrayBuffer":1137      return iterableEqual(new Uint8Array(leftHandOperand), new Uint8Array(rightHandOperand), options);1138    case "Set":1139      return entriesEqual(leftHandOperand, rightHandOperand, options);1140    case "Map":1141      return entriesEqual(leftHandOperand, rightHandOperand, options);1142    case "Temporal.PlainDate":1143    case "Temporal.PlainTime":1144    case "Temporal.PlainDateTime":1145    case "Temporal.Instant":1146    case "Temporal.ZonedDateTime":1147    case "Temporal.PlainYearMonth":1148    case "Temporal.PlainMonthDay":1149      return leftHandOperand.equals(rightHandOperand);1150    case "Temporal.Duration":1151      return leftHandOperand.total("nanoseconds") === rightHandOperand.total("nanoseconds");1152    case "Temporal.TimeZone":1153    case "Temporal.Calendar":1154      return leftHandOperand.toString() === rightHandOperand.toString();1155    default:1156      return objectEqual(leftHandOperand, rightHandOperand, options);1157  }1158}1159__name(extensiveDeepEqualByType, "extensiveDeepEqualByType");1160function regexpEqual(leftHandOperand, rightHandOperand) {1161  return leftHandOperand.toString() === rightHandOperand.toString();1162}1163__name(regexpEqual, "regexpEqual");1164function entriesEqual(leftHandOperand, rightHandOperand, options) {1165  try {1166    if (leftHandOperand.size !== rightHandOperand.size) {1167      return false;1168    }1169    if (leftHandOperand.size === 0) {1170      return true;1171    }1172  } catch (sizeError) {1173    return false;1174  }1175  var leftHandItems = [];1176  var rightHandItems = [];1177  leftHandOperand.forEach(/* @__PURE__ */ __name(function gatherEntries(key, value) {1178    leftHandItems.push([key, value]);1179  }, "gatherEntries"));1180  rightHandOperand.forEach(/* @__PURE__ */ __name(function gatherEntries(key, value) {1181    rightHandItems.push([key, value]);1182  }, "gatherEntries"));1183  return iterableEqual(leftHandItems.sort(), rightHandItems.sort(), options);1184}1185__name(entriesEqual, "entriesEqual");1186function iterableEqual(leftHandOperand, rightHandOperand, options) {1187  var length = leftHandOperand.length;1188  if (length !== rightHandOperand.length) {1189    return false;1190  }1191  if (length === 0) {1192    return true;1193  }1194  var index = -1;1195  while (++index < length) {1196    if (deepEqual(leftHandOperand[index], rightHandOperand[index], options) === false) {1197      return false;1198    }1199  }1200  return true;

Showing the first 1,200 of 4173 lines. Download the file for the rest.