@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/_browser-chunks/chunk-BCP2FFXF.js

@@ -0,0 +1,369 @@
+// ../../node_modules/loupe/lib/helpers.js
+var ansiColors = {
+  bold: ["1", "22"],
+  dim: ["2", "22"],
+  italic: ["3", "23"],
+  underline: ["4", "24"],
+  // 5 & 6 are blinking
+  inverse: ["7", "27"],
+  hidden: ["8", "28"],
+  strike: ["9", "29"],
+  // 10-20 are fonts
+  // 21-29 are resets for 1-9
+  black: ["30", "39"],
+  red: ["31", "39"],
+  green: ["32", "39"],
+  yellow: ["33", "39"],
+  blue: ["34", "39"],
+  magenta: ["35", "39"],
+  cyan: ["36", "39"],
+  white: ["37", "39"],
+  brightblack: ["30;1", "39"],
+  brightred: ["31;1", "39"],
+  brightgreen: ["32;1", "39"],
+  brightyellow: ["33;1", "39"],
+  brightblue: ["34;1", "39"],
+  brightmagenta: ["35;1", "39"],
+  brightcyan: ["36;1", "39"],
+  brightwhite: ["37;1", "39"],
+  grey: ["90", "39"]
+}, styles = {
+  special: "cyan",
+  number: "yellow",
+  bigint: "yellow",
+  boolean: "yellow",
+  undefined: "grey",
+  null: "bold",
+  string: "green",
+  symbol: "green",
+  date: "magenta",
+  regexp: "red"
+}, truncator = "\u2026";
+function colorise(value, styleType) {
+  let color = ansiColors[styles[styleType]] || ansiColors[styleType] || "";
+  return color ? `\x1B[${color[0]}m${String(value)}\x1B[${color[1]}m` : String(value);
+}
+function normaliseOptions({
+  showHidden = !1,
+  depth = 2,
+  colors = !1,
+  customInspect = !0,
+  showProxy = !1,
+  maxArrayLength = 1 / 0,
+  breakLength = 1 / 0,
+  seen = [],
+  // eslint-disable-next-line no-shadow
+  truncate: truncate2 = 1 / 0,
+  stylize = String
+} = {}, inspect2) {
+  let options = {
+    showHidden: !!showHidden,
+    depth: Number(depth),
+    colors: !!colors,
+    customInspect: !!customInspect,
+    showProxy: !!showProxy,
+    maxArrayLength: Number(maxArrayLength),
+    breakLength: Number(breakLength),
+    truncate: Number(truncate2),
+    seen,
+    inspect: inspect2,
+    stylize
+  };
+  return options.colors && (options.stylize = colorise), options;
+}
+function isHighSurrogate(char) {
+  return char >= "\uD800" && char <= "\uDBFF";
+}
+function truncate(string, length, tail = truncator) {
+  string = String(string);
+  let tailLength = tail.length, stringLength = string.length;
+  if (tailLength > length && stringLength > tailLength)
+    return tail;
+  if (stringLength > length && stringLength > tailLength) {
+    let end = length - tailLength;
+    return end > 0 && isHighSurrogate(string[end - 1]) && (end = end - 1), `${string.slice(0, end)}${tail}`;
+  }
+  return string;
+}
+function inspectList(list, options, inspectItem, separator = ", ") {
+  inspectItem = inspectItem || options.inspect;
+  let size = list.length;
+  if (size === 0)
+    return "";
+  let originalLength = options.truncate, output = "", peek = "", truncated = "";
+  for (let i = 0; i < size; i += 1) {
+    let last = i + 1 === list.length, secondToLast = i + 2 === list.length;
+    truncated = `${truncator}(${list.length - i})`;
+    let value = list[i];
+    options.truncate = originalLength - output.length - (last ? 0 : separator.length);
+    let string = peek || inspectItem(value, options) + (last ? "" : separator), nextLength = output.length + string.length, truncatedLength = nextLength + truncated.length;
+    if (last && nextLength > originalLength && output.length + truncated.length <= originalLength || !last && !secondToLast && truncatedLength > originalLength || (peek = last ? "" : inspectItem(list[i + 1], options) + (secondToLast ? "" : separator), !last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength))
+      break;
+    if (output += string, !last && !secondToLast && nextLength + peek.length >= originalLength) {
+      truncated = `${truncator}(${list.length - i - 1})`;
+      break;
+    }
+    truncated = "";
+  }
+  return `${output}${truncated}`;
+}
+function quoteComplexKey(key) {
+  return key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/) ? key : JSON.stringify(key).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+}
+function inspectProperty([key, value], options) {
+  return options.truncate -= 2, typeof key == "string" ? key = quoteComplexKey(key) : typeof key != "number" && (key = `[${options.inspect(key, options)}]`), options.truncate -= key.length, value = options.inspect(value, options), `${key}: ${value}`;
+}
+
+// ../../node_modules/loupe/lib/array.js
+function inspectArray(array, options) {
+  let nonIndexProperties = Object.keys(array).slice(array.length);
+  if (!array.length && !nonIndexProperties.length)
+    return "[]";
+  options.truncate -= 4;
+  let listContents = inspectList(array, options);
+  options.truncate -= listContents.length;
+  let propertyContents = "";
+  return nonIndexProperties.length && (propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty)), `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+}
+
+// ../../node_modules/loupe/lib/typedarray.js
+var getArrayName = (array) => typeof Buffer == "function" && array instanceof Buffer ? "Buffer" : array[Symbol.toStringTag] ? array[Symbol.toStringTag] : array.constructor.name;
+function inspectTypedArray(array, options) {
+  let name = getArrayName(array);
+  options.truncate -= name.length + 4;
+  let nonIndexProperties = Object.keys(array).slice(array.length);
+  if (!array.length && !nonIndexProperties.length)
+    return `${name}[]`;
+  let output = "";
+  for (let i = 0; i < array.length; i++) {
+    let string = `${options.stylize(truncate(array[i], options.truncate), "number")}${i === array.length - 1 ? "" : ", "}`;
+    if (options.truncate -= string.length, array[i] !== array.length && options.truncate <= 3) {
+      output += `${truncator}(${array.length - array[i] + 1})`;
+      break;
+    }
+    output += string;
+  }
+  let propertyContents = "";
+  return nonIndexProperties.length && (propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty)), `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+}
+
+// ../../node_modules/loupe/lib/date.js
+function inspectDate(dateObject, options) {
+  let stringRepresentation = dateObject.toJSON();
+  if (stringRepresentation === null)
+    return "Invalid Date";
+  let split = stringRepresentation.split("T"), date = split[0];
+  return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, "date");
+}
+
+// ../../node_modules/loupe/lib/function.js
+function inspectFunction(func, options) {
+  let functionType = func[Symbol.toStringTag] || "Function", name = func.name;
+  return name ? options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, "special") : options.stylize(`[${functionType}]`, "special");
+}
+
+// ../../node_modules/loupe/lib/map.js
+function inspectMapEntry([key, value], options) {
+  return options.truncate -= 4, key = options.inspect(key, options), options.truncate -= key.length, value = options.inspect(value, options), `${key} => ${value}`;
+}
+function mapToEntries(map) {
+  let entries = [];
+  return map.forEach((value, key) => {
+    entries.push([key, value]);
+  }), entries;
+}
+function inspectMap(map, options) {
+  return map.size === 0 ? "Map{}" : (options.truncate -= 7, `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`);
+}
+
+// ../../node_modules/loupe/lib/number.js
+var isNaN = Number.isNaN || ((i) => i !== i);
+function inspectNumber(number, options) {
+  return isNaN(number) ? options.stylize("NaN", "number") : number === 1 / 0 ? options.stylize("Infinity", "number") : number === -1 / 0 ? options.stylize("-Infinity", "number") : number === 0 ? options.stylize(1 / number === 1 / 0 ? "+0" : "-0", "number") : options.stylize(truncate(String(number), options.truncate), "number");
+}
+
+// ../../node_modules/loupe/lib/bigint.js
+function inspectBigInt(number, options) {
+  let nums = truncate(number.toString(), options.truncate - 1);
+  return nums !== truncator && (nums += "n"), options.stylize(nums, "bigint");
+}
+
+// ../../node_modules/loupe/lib/regexp.js
+function inspectRegExp(value, options) {
+  let flags = value.toString().split("/")[2], sourceLength = options.truncate - (2 + flags.length), source = value.source;
+  return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, "regexp");
+}
+
+// ../../node_modules/loupe/lib/set.js
+function arrayFromSet(set) {
+  let values = [];
+  return set.forEach((value) => {
+    values.push(value);
+  }), values;
+}
+function inspectSet(set, options) {
+  return set.size === 0 ? "Set{}" : (options.truncate -= 7, `Set{ ${inspectList(arrayFromSet(set), options)} }`);
+}
+
+// ../../node_modules/loupe/lib/string.js
+var stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g"), escapeCharacters = {
+  "\b": "\\b",
+  "	": "\\t",
+  "\n": "\\n",
+  "\f": "\\f",
+  "\r": "\\r",
+  "'": "\\'",
+  "\\": "\\\\"
+}, hex = 16, unicodeLength = 4;
+function escape(char) {
+  return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-unicodeLength)}`;
+}
+function inspectString(string, options) {
+  return stringEscapeChars.test(string) && (string = string.replace(stringEscapeChars, escape)), options.stylize(`'${truncate(string, options.truncate - 2)}'`, "string");
+}
+
+// ../../node_modules/loupe/lib/symbol.js
+function inspectSymbol(value) {
+  return "description" in Symbol.prototype ? value.description ? `Symbol(${value.description})` : "Symbol()" : value.toString();
+}
+
+// ../../node_modules/loupe/lib/promise.js
+var getPromiseValue = () => "Promise{\u2026}", promise_default = getPromiseValue;
+
+// ../../node_modules/loupe/lib/object.js
+function inspectObject(object, options) {
+  let properties = Object.getOwnPropertyNames(object), symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [];
+  if (properties.length === 0 && symbols.length === 0)
+    return "{}";
+  if (options.truncate -= 4, options.seen = options.seen || [], options.seen.includes(object))
+    return "[Circular]";
+  options.seen.push(object);
+  let propertyContents = inspectList(properties.map((key) => [key, object[key]]), options, inspectProperty), symbolContents = inspectList(symbols.map((key) => [key, object[key]]), options, inspectProperty);
+  options.seen.pop();
+  let sep = "";
+  return propertyContents && symbolContents && (sep = ", "), `{ ${propertyContents}${sep}${symbolContents} }`;
+}
+
+// ../../node_modules/loupe/lib/class.js
+var toStringTag = typeof Symbol < "u" && Symbol.toStringTag ? Symbol.toStringTag : !1;
+function inspectClass(value, options) {
+  let name = "";
+  return toStringTag && toStringTag in value && (name = value[toStringTag]), name = name || value.constructor.name, (!name || name === "_class") && (name = "<Anonymous Class>"), options.truncate -= name.length, `${name}${inspectObject(value, options)}`;
+}
+
+// ../../node_modules/loupe/lib/arguments.js
+function inspectArguments(args, options) {
+  return args.length === 0 ? "Arguments[]" : (options.truncate -= 13, `Arguments[ ${inspectList(args, options)} ]`);
+}
+
+// ../../node_modules/loupe/lib/error.js
+var errorKeys = [
+  "stack",
+  "line",
+  "column",
+  "name",
+  "message",
+  "fileName",
+  "lineNumber",
+  "columnNumber",
+  "number",
+  "description",
+  "cause"
+];
+function inspectObject2(error, options) {
+  let properties = Object.getOwnPropertyNames(error).filter((key) => errorKeys.indexOf(key) === -1), name = error.name;
+  options.truncate -= name.length;
+  let message = "";
+  if (typeof error.message == "string" ? message = truncate(error.message, options.truncate) : properties.unshift("message"), message = message ? `: ${message}` : "", options.truncate -= message.length + 5, options.seen = options.seen || [], options.seen.includes(error))
+    return "[Circular]";
+  options.seen.push(error);
+  let propertyContents = inspectList(properties.map((key) => [key, error[key]]), options, inspectProperty);
+  return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ""}`;
+}
+
+// ../../node_modules/loupe/lib/html.js
+function inspectAttribute([key, value], options) {
+  return options.truncate -= 3, value ? `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}` : `${options.stylize(String(key), "yellow")}`;
+}
+function inspectNodeCollection(collection, options) {
+  return inspectList(collection, options, inspectNode, `
+`);
+}
+function inspectNode(node, options) {
+  switch (node.nodeType) {
+    case 1:
+      return inspectHTML(node, options);
+    case 3:
+      return options.inspect(node.data, options);
+    default:
+      return options.inspect(node, options);
+  }
+}
+function inspectHTML(element, options) {
+  let properties = element.getAttributeNames(), name = element.tagName.toLowerCase(), head = options.stylize(`<${name}`, "special"), headClose = options.stylize(">", "special"), tail = options.stylize(`</${name}>`, "special");
+  options.truncate -= name.length * 2 + 5;
+  let propertyContents = "";
+  properties.length > 0 && (propertyContents += " ", propertyContents += inspectList(properties.map((key) => [key, element.getAttribute(key)]), options, inspectAttribute, " ")), options.truncate -= propertyContents.length;
+  let truncate2 = options.truncate, children = inspectNodeCollection(element.children, options);
+  return children && children.length > truncate2 && (children = `${truncator}(${element.children.length})`), `${head}${propertyContents}${headClose}${children}${tail}`;
+}
+
+// ../../node_modules/loupe/lib/index.js
+var symbolsSupported = typeof Symbol == "function" && typeof Symbol.for == "function", chaiInspect = symbolsSupported ? /* @__PURE__ */ Symbol.for("chai/inspect") : "@@chai/inspect", nodeInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom"), constructorMap = /* @__PURE__ */ new WeakMap(), stringTagMap = {}, baseTypesMap = {
+  undefined: (value, options) => options.stylize("undefined", "undefined"),
+  null: (value, options) => options.stylize("null", "null"),
+  boolean: (value, options) => options.stylize(String(value), "boolean"),
+  Boolean: (value, options) => options.stylize(String(value), "boolean"),
+  number: inspectNumber,
+  Number: inspectNumber,
+  bigint: inspectBigInt,
+  BigInt: inspectBigInt,
+  string: inspectString,
+  String: inspectString,
+  function: inspectFunction,
+  Function: inspectFunction,
+  symbol: inspectSymbol,
+  // A Symbol polyfill will return `Symbol` not `symbol` from typedetect
+  Symbol: inspectSymbol,
+  Array: inspectArray,
+  Date: inspectDate,
+  Map: inspectMap,
+  Set: inspectSet,
+  RegExp: inspectRegExp,
+  Promise: promise_default,
+  // WeakSet, WeakMap are totally opaque to us
+  WeakSet: (value, options) => options.stylize("WeakSet{\u2026}", "special"),
+  WeakMap: (value, options) => options.stylize("WeakMap{\u2026}", "special"),
+  Arguments: inspectArguments,
+  Int8Array: inspectTypedArray,
+  Uint8Array: inspectTypedArray,
+  Uint8ClampedArray: inspectTypedArray,
+  Int16Array: inspectTypedArray,
+  Uint16Array: inspectTypedArray,
+  Int32Array: inspectTypedArray,
+  Uint32Array: inspectTypedArray,
+  Float32Array: inspectTypedArray,
+  Float64Array: inspectTypedArray,
+  Generator: () => "",
+  DataView: () => "",
+  ArrayBuffer: () => "",
+  Error: inspectObject2,
+  HTMLCollection: inspectNodeCollection,
+  NodeList: inspectNodeCollection
+}, inspectCustom = (value, options, type, inspectFn) => chaiInspect in value && typeof value[chaiInspect] == "function" ? value[chaiInspect](options) : nodeInspect in value && typeof value[nodeInspect] == "function" ? value[nodeInspect](options.depth, options, inspectFn) : "inspect" in value && typeof value.inspect == "function" ? value.inspect(options.depth, options) : "constructor" in value && constructorMap.has(value.constructor) ? constructorMap.get(value.constructor)(value, options) : stringTagMap[type] ? stringTagMap[type](value, options) : "", toString = Object.prototype.toString;
+function inspect(value, opts = {}) {
+  let options = normaliseOptions(opts, inspect), { customInspect } = options, type = value === null ? "null" : typeof value;
+  if (type === "object" && (type = toString.call(value).slice(8, -1)), type in baseTypesMap)
+    return baseTypesMap[type](value, options);
+  if (customInspect && value) {
+    let output = inspectCustom(value, options, type, inspect);
+    if (output)
+      return typeof output == "string" ? output : inspect(output, options);
+  }
+  let proto = value ? Object.getPrototypeOf(value) : !1;
+  return proto === Object.prototype || proto === null ? inspectObject(value, options) : value && typeof HTMLElement == "function" && value instanceof HTMLElement ? inspectHTML(value, options) : "constructor" in value ? value.constructor !== Object ? inspectClass(value, options) : inspectObject(value, options) : value === Object(value) ? inspectObject(value, options) : options.stylize(String(value), type);
+}
+
+export {
+  inspect
+};