@fncts/base 0.0.1

package/_mjs/typeclass/Showable/show.mjs

@@ -0,0 +1,796 @@
+const fileName_1 = "(@fncts/base) src/typeclass/Showable/show.ts";
+import * as tsplus_module_1 from "@fncts/base/data/CaseClass";
+import * as tsplus_module_2 from "@fncts/base/collection/immutable/HashMap/api";
+import * as tsplus_module_3 from "@fncts/base/control/Z/runtime";
+import * as tsplus_module_4 from "@fncts/base/control/Z/api";
+import * as tsplus_module_5 from "@fncts/base/data/Maybe/destructors";
+import * as tsplus_module_6 from "@fncts/base/typeclass/Showable/definition";
+import * as tsplus_module_7 from "@fncts/base/collection/immutable/Conc/api/empty";
+import * as tsplus_module_8 from "@fncts/base/collection/immutable/Conc/definition";
+import * as tsplus_module_9 from "@fncts/base/collection/immutable/Conc/api";
+import * as tsplus_module_10 from "@fncts/base/control/Z/definition";
+import * as tsplus_module_11 from "@fncts/base/control/Z/instances";
+import * as tsplus_module_12 from "@fncts/base/collection/immutable/Conc/constructors";
+import * as tsplus_module_13 from "@fncts/base/collection/Iterable/api/traverseConc";
+import { tuple } from "@fncts/base/data/function";
+import { isShowable } from "@fncts/base/typeclass/Showable/definition";
+import { stylizeNoColor, stylizeWithColor } from "@fncts/base/typeclass/Showable/styles";
+import { ARRAY_EXTRAS_TYPE, ARRAY_TYPE, colorRegExp, escapeFn, getConstructorName, getFunctionBase, getKeys, getPrefix, getStringWidth, hex, keyStrRegExp, numberRegExp, OBJECT_TYPE, pluralize, PROTO_TYPE, strEscape, strEscapeSequencesReplacer } from "@fncts/base/typeclass/Showable/util";
+import { isAnyArrayBuffer, isArray, isArrayBuffer, isDataView, isDate, isDefined, isFunction, isMap, isObject, isPromise, isRegExp, isSet, isSymbol, isTypedArray, isWeakMap, isWeakSet } from "@fncts/base/util/predicates";
+export class ShowContext extends tsplus_module_1.CaseClass {}
+export function showComputationPrimitive(computation) {
+  return {
+    _tag: "Primitive",
+    computation
+  };
+}
+export function showComputationComplex(args) {
+  return {
+    _tag: "Complex",
+    ...args
+  };
+}
+
+function getShowContext(options) {
+  return new ShowContext({
+    maxArrayLength: 100,
+    maxStringLength: 100,
+    breakLength: 100,
+    compact: 3,
+    colors: false,
+    depth: 3,
+    showHidden: true,
+    circular: tsplus_module_2.makeDefault(),
+    seen: [],
+    budget: {},
+    indentationLevel: options?.indentationLevel ?? 0,
+    stylize: options?.colors === true ? stylizeWithColor : stylizeNoColor,
+    currentDepth: 0,
+    recurseTimes: 0,
+    ...(options || {})
+  });
+}
+
+export function show(value) {
+  return tsplus_module_3.unsafeRunStateResult_(_show(value), getShowContext());
+}
+export function showWithOptions(value, options) {
+  return tsplus_module_3.unsafeRunStateResult_(_show(value), getShowContext(options));
+}
+export function _show(value) {
+  return tsplus_module_4.getsZ(context => {
+    if (value === undefined) {
+      return tsplus_module_4.succeedNow(context.stylize("undefined", "undefined"), fileName_1 + ":138:26");
+    }
+
+    if (value === null) {
+      return tsplus_module_4.succeedNow(context.stylize("null", "null"), fileName_1 + ":141:26");
+    }
+
+    if (!isObject(value) && !isFunction(value)) {
+      return tsplus_module_4.succeedNow(_showPrimitive(context, value), fileName_1 + ":144:26");
+    }
+
+    return showValue(value);
+  });
+}
+
+function showValue(value) {
+  return tsplus_module_4.getsZ(context => {
+    if (context.seen.findIndex(v => v === value) !== -1) {
+      return tsplus_module_4.map_(tsplus_module_4.modify(context => tsplus_module_5.match_(tsplus_module_2.get_(context.circular, value), () => [context.circular.size + 1, context.copy({
+        circular: tsplus_module_2.set_(context.circular, value, context.circular.size + 1)
+      })], n => [n, context])), index => context.stylize(`[Circular *${index}]`, "special"));
+    }
+
+    return showRaw(value);
+  });
+}
+
+function inspectionInfo(args) {
+  return {
+    _tag: "InspectionInfo",
+    ...args
+  };
+}
+
+function inspectionEarlyReturn(shown) {
+  return {
+    _tag: "InspectionEarlyReturn",
+    shown
+  };
+}
+
+function inspectionExternal(computation) {
+  return {
+    _tag: "InspectionExternal",
+    computation
+  };
+}
+/**
+ * Determines the approximate type of the unknown value and collects information about
+ * the structure of that value
+ */
+
+
+function getInspectionInfo(context, value, typedArray) {
+  if (isShowable(value)) {
+    return inspectionExternal(value[tsplus_module_6._showable]);
+  } // eslint-disable-next-line prefer-const
+
+
+  let [constructor, protoProps] = getConstructorName(value);
+  let keys = [];
+  let tag = value[Symbol.toStringTag];
+  let base = "";
+
+  let formatter = _ => tsplus_module_4.succeedNow(tsplus_module_7.empty(), fileName_1 + ":225:44");
+
+  let braces = ["", ""];
+  let noIterator = true;
+  let extrasType = OBJECT_TYPE;
+
+  if (typeof tag !== "string" || tag !== "" && (context.showHidden ? Object.prototype.hasOwnProperty : Object.prototype.propertyIsEnumerable).call(value, Symbol.toStringTag)) {
+    tag = "";
+  }
+
+  if (value[Symbol.iterator] || constructor === null) {
+    noIterator = false;
+
+    if (tsplus_module_8.isConc(value)) {
+      braces = [`Chunk (${value.length}) [`, "]"];
+
+      if (value.length == 0) {
+        return inspectionEarlyReturn(`${braces[0]}]`);
+      }
+
+      protoProps = tsplus_module_7.empty();
+      extrasType = ARRAY_EXTRAS_TYPE;
+      formatter = showChunk;
+    } else if (isArray(value)) {
+      const prefix = getPrefix(constructor, tag, "Array", `(${value.length})`);
+      braces = [`${prefix}[`, "]"];
+
+      if (value.length === 0) {
+        return inspectionEarlyReturn(`${braces[0]}]`);
+      }
+
+      extrasType = ARRAY_EXTRAS_TYPE;
+      formatter = showArray;
+    } else if (isSet(value)) {
+      const size = value.size;
+      const prefix = getPrefix(constructor, tag, "Set", `(${size})`);
+      keys = getKeys(value, context.showHidden);
+      formatter = showSet;
+
+      if (size === 0 && keys.length === 0 && tsplus_module_9.isEmpty(protoProps)) {
+        return inspectionEarlyReturn(`${prefix}{}`);
+      }
+
+      braces = [`${prefix}{`, "}"];
+    } else if (isMap(value)) {
+      const size = value.size;
+      const prefix = getPrefix(constructor, tag, "Map", `(${size})`);
+      keys = getKeys(value, context.showHidden);
+      formatter = showMap;
+
+      if (size === 0 && keys.length === 0 && tsplus_module_9.isEmpty(protoProps)) {
+        return inspectionEarlyReturn(`${prefix}{}`);
+      }
+
+      braces = [`${prefix}{`, "}"];
+    } else if (isTypedArray(value)) {
+      const size = value.length;
+      const fallback = value[Symbol.toStringTag];
+      const prefix = getPrefix(constructor, tag, fallback, `(${size})`);
+      braces = [`${prefix}[`, "]"];
+
+      if (value.length === 0) {
+        return inspectionEarlyReturn(`${braces[0]}]`);
+      }
+
+      extrasType = ARRAY_EXTRAS_TYPE;
+      formatter = showTypedArray;
+    } else {
+      noIterator = true;
+    }
+  }
+
+  if (noIterator) {
+    keys = getKeys(value, context.showHidden);
+    braces = ["{", "}"];
+
+    if (constructor === "Object") {
+      if (tag !== "") {
+        braces[0] = `${getPrefix(constructor, tag, "Object")}{`;
+      }
+
+      if (keys.length === 0 && tsplus_module_9.isEmpty(protoProps)) {
+        return inspectionEarlyReturn(`${braces[0]}}`);
+      }
+    } else if (typeof value === "function") {
+      base = getFunctionBase(value, constructor, tag);
+
+      if (keys.length === 0 && tsplus_module_9.isEmpty(protoProps)) {
+        return inspectionEarlyReturn(base);
+      }
+    } else if (isRegExp(value)) {
+      base = RegExp.prototype.toString.call(constructor !== null ? value : new RegExp(value));
+      const prefix = getPrefix(constructor, tag, "RegExp");
+
+      if (prefix !== "RegExp ") {
+        base = `${prefix}${base}`;
+      }
+
+      if (keys.length === 0 && tsplus_module_9.isEmpty(protoProps)) {
+        return inspectionEarlyReturn(base);
+      }
+    } else if (isDate(value)) {
+      base = Number.isNaN(value.getTime()) ? value.toString() : value.toISOString();
+      const prefix = getPrefix(constructor, tag, "Date");
+
+      if (prefix !== "Date ") {
+        base = `${prefix}${base}`;
+      }
+
+      if (keys.length === 0 && tsplus_module_9.isEmpty(protoProps)) {
+        return inspectionEarlyReturn(base);
+      }
+    } else if (isAnyArrayBuffer(value)) {
+      const arrayType = isArrayBuffer(value) ? "ArrayBuffer" : "SharedArrayBuffer";
+      const prefix = getPrefix(constructor, tag, arrayType);
+
+      if (typedArray === undefined) {
+        formatter = showArrayBuffer;
+      } else if (keys.length === 0 && tsplus_module_9.isEmpty(protoProps)) {
+        return inspectionEarlyReturn(prefix + `{ byteLength: ${_showNumber(context, value.byteLength)} }`);
+      }
+
+      braces[0] = `${prefix}{`;
+      keys.unshift("byteLength");
+    } else if (isDataView(value)) {
+      braces[0] = `${getPrefix(constructor, tag, "DataView")}{`;
+      keys.unshift("byteLength", "byteOffset", "buffer");
+    } else if (isPromise(value)) {
+      return inspectionEarlyReturn(`${getPrefix(constructor, tag, "Promise")}{}`);
+    } else if (isWeakSet(value)) {
+      return inspectionEarlyReturn(`${getPrefix(constructor, tag, "WeakSet")}{}`);
+    } else if (isWeakMap(value)) {
+      return inspectionEarlyReturn(`${getPrefix(constructor, tag, "WeakMap")}{}`);
+    } else if (tsplus_module_10.isZ(value)) {
+      return constructor !== null ? inspectionEarlyReturn(`Z (${constructor}) {}`) : inspectionEarlyReturn("Z {}");
+    } else {
+      if (keys.length === 0) {
+        return inspectionEarlyReturn(`${getPrefix(constructor, tag, "Object")}{}`);
+      }
+
+      braces[0] = `${getPrefix(constructor, tag, "Object")}{`;
+    }
+  }
+
+  return inspectionInfo({
+    constructor,
+    keys,
+    tag,
+    base,
+    formatter,
+    braces,
+    noIterator,
+    extrasType,
+    protoProps
+  });
+}
+/**
+ * Retrieves information on the unknown value and processes that info to convert the value
+ * into a human-readable, formatted string
+ */
+
+
+function showRaw(value, typedArray) {
+  return tsplus_module_4.flatMap_(tsplus_module_4.gets(context => tuple(context, getInspectionInfo(context, value, typedArray))), ([context, info]) => {
+    if (info._tag === "InspectionInfo" && context.recurseTimes > context.depth) {
+      let constructorName = getPrefix(info.constructor, info.tag, "Object").slice(0, -1);
+
+      if (info.constructor !== null) {
+        constructorName = `[${constructorName}]`;
+      }
+
+      return tsplus_module_4.apSecond_(tsplus_module_4.update(context => context.copy({
+        recurseTimes: context.recurseTimes - 1,
+        currentDepth: context.currentDepth - 1
+      })), tsplus_module_4.succeedNow(context.stylize(constructorName, "special"), fileName_1 + ":384:32"));
+    }
+
+    if (info._tag === "InspectionEarlyReturn") {
+      return tsplus_module_4.succeedNow(info.shown, fileName_1 + ":387:28");
+    } else {
+      return tsplus_module_4.apSecond_(tsplus_module_4.update(context => {
+        context.seen.push(value);
+        return context;
+      }), tsplus_module_4.defer(() => {
+        let keys;
+        let indices;
+        let base;
+        let braces;
+        let extrasType;
+
+        switch (info._tag) {
+          case "InspectionInfo":
+            {
+              base = tsplus_module_4.succeedNow(info.base, fileName_1 + ":401:36");
+              keys = tsplus_module_4.crossWith_(tsplus_module_9.traverseSelf(tsplus_module_12.from(info.keys))(tsplus_module_11.Applicative)(key => showProperty(value, key, info.extrasType)), tsplus_module_9.traverseSelf(info.protoProps)(tsplus_module_11.Applicative)(key => showProperty(value, key, PROTO_TYPE)), (k1, k2) => tsplus_module_9.concat_(k1, k2));
+              indices = info.formatter(value);
+              braces = info.braces;
+              extrasType = info.extrasType;
+              break;
+            }
+
+          case "InspectionExternal":
+            {
+              const externalComputation = info.computation;
+
+              if (externalComputation._tag === "Primitive") {
+                return tsplus_module_4.getsZ(context => tsplus_module_4.map_(externalComputation.computation, str => str.replace(/\n/g, `\n${" ".repeat(context.indentationLevel)}`)));
+              } else {
+                base = externalComputation.base || tsplus_module_4.succeedNow("", fileName_1 + ":422:72");
+                keys = externalComputation.keys || tsplus_module_4.succeedNow(tsplus_module_7.empty(), fileName_1 + ":423:72");
+                indices = externalComputation.indices || tsplus_module_4.succeedNow(tsplus_module_7.empty(), fileName_1 + ":424:75");
+                braces = externalComputation.braces || ["", ""];
+                extrasType = externalComputation.extrasType || OBJECT_TYPE;
+              }
+
+              break;
+            }
+        }
+
+        const output = tsplus_module_4.crossWith_(indices, keys, (idxs, ks) => tsplus_module_9.concat_(idxs, ks));
+        const baseWithRef = tsplus_module_4.getsZ(context => tsplus_module_5.match_(tsplus_module_2.get_(context.circular, value), () => base, index => tsplus_module_4.map_(base, base => {
+          const ref = context.stylize(`<ref *${index}>`, "special");
+          return base === "" ? ref : `${ref} ${base}`;
+        })));
+        return tsplus_module_4.apFirst_(tsplus_module_4.flatMap_(tsplus_module_4.cross_(tsplus_module_4.apSecond_(tsplus_module_4.update(_ => _.copy({
+          recurseTimes: context.recurseTimes + 1,
+          currentDepth: _.recurseTimes + 1
+        })), output), baseWithRef), ([output, base]) => tsplus_module_4.modify(context => {
+          const res = reduceToSingleString(context, output, base, braces, extrasType, value);
+          const budget = context.budget[context.indentationLevel] || 0;
+          const newLength = budget + res.length;
+          const newBudget = { ...context.budget,
+            [context.indentationLevel]: newLength
+          };
+          let newContext;
+
+          if (newLength > 2 ** 27) {
+            newContext = context.copy({
+              budget: newBudget,
+              depth: -1
+            });
+          } else {
+            newContext = context.copy({
+              budget: newBudget
+            });
+          }
+
+          return [res, newContext];
+        })), tsplus_module_4.update(context => {
+          context.seen.pop();
+          return context.copy({
+            recurseTimes: context.recurseTimes - 1
+          });
+        }));
+      }, fileName_1 + ":393:18"));
+    }
+  });
+}
+/**
+ * Converts a Chunk of strings containing the formatted keys/values of the original value
+ * into a single formatted string
+ */
+
+
+function reduceToSingleString(context, input, base, braces, extrasType, value) {
+  let output = input;
+
+  if (context.compact >= 1) {
+    const entries = output.length;
+
+    if (extrasType === ARRAY_EXTRAS_TYPE && entries > 6) {
+      output = groupElements(context, output, value);
+    }
+
+    if (context.currentDepth - context.recurseTimes < context.compact && entries === output.length) {
+      const start = output.length + context.indentationLevel + braces[0].length + base.length + 10;
+
+      if (isBelowBreakLength(context, output, start, base)) {
+        return `${base ? `${base} ` : ""}${braces[0]} ${tsplus_module_9.join_(output, ", ")} ${braces[1]}`;
+      }
+    }
+  }
+
+  const indentation = `\n${" ".repeat(context.indentationLevel)}`;
+  return `${base ? `${base} ` : ""}${braces[0]}${indentation}  ` + `${tsplus_module_9.join_(output, `,${indentation}  `)}${indentation}${braces[1]}`;
+}
+
+function isBelowBreakLength(context, input, start, base) {
+  let totalLength = input.length + start;
+
+  if (totalLength + input.length > context.breakLength) {
+    return false;
+  }
+
+  for (let i = 0; i < input.length; i++) {
+    if (context.colors) {
+      totalLength += removeColors(tsplus_module_9.unsafeGet_(input, i)).length;
+    } else {
+      totalLength += tsplus_module_9.unsafeGet_(input, i).length;
+    }
+
+    if (totalLength > context.breakLength) {
+      return false;
+    }
+  }
+
+  return base === "" || !base.includes("\n");
+}
+
+function removeColors(str) {
+  return str.replace(colorRegExp, "");
+}
+
+function showSet(value) {
+  return tsplus_module_4.apFirst_(tsplus_module_4.apSecond_(tsplus_module_4.update(_ => _.copy({
+    indentationLevel: _.indentationLevel + 2
+  })), tsplus_module_13.traverseToConc_(value)(tsplus_module_11.Applicative)(_show)), tsplus_module_4.update(_ => _.copy({
+    indentationLevel: _.indentationLevel - 2
+  })));
+}
+
+function showMap(value) {
+  return tsplus_module_4.apFirst_(tsplus_module_4.apSecond_(tsplus_module_4.update(_ => _.copy({
+    indentationLevel: _.indentationLevel + 2
+  })), tsplus_module_13.traverseToConc_(value)(tsplus_module_11.Applicative)(([k, v]) => tsplus_module_4.crossWith_(_show(k), _show(v), (k, v) => `${k} => ${v}`))), tsplus_module_4.update(_ => _.copy({
+    indentationLevel: _.indentationLevel - 2
+  })));
+}
+
+function showTypedArray(value) {
+  return tsplus_module_4.getsZ(context => tsplus_module_4.defer(() => {
+    const maxLength = Math.min(Math.max(0, context.maxArrayLength), value.length);
+    const remaining = value.length - maxLength;
+    let output = tsplus_module_7.empty();
+    const elementFormatter = value.length > 0 && typeof value[0] === "number" ? _showNumber : _showBigInt;
+
+    for (let i = 0; i < maxLength; ++i) {
+      output = tsplus_module_9.append_(output, elementFormatter(context, value[i]));
+    }
+
+    if (remaining > 0) {
+      output = tsplus_module_9.append_(output, `... ${remaining} more item${pluralize(remaining)}`);
+    }
+
+    if (context.showHidden) {
+      return tsplus_module_4.apFirst_(tsplus_module_4.apSecond_(tsplus_module_4.update(_ => _.copy({
+        indentationLevel: _.indentationLevel + 2
+      })), tsplus_module_4.flatMap_(tsplus_module_4.succeedNow(output, fileName_1 + ":578:25"), output => tsplus_module_4.map_(tsplus_module_9.traverseSelf(tsplus_module_12.make("BYTES_PER_ELEMENT", "length", "byteLength", "byteOffset", "buffer"))(tsplus_module_11.Applicative)(key => tsplus_module_4.map_(_show(value[key]), shown => `[${key}]: ${shown}`)), shownKeys => tsplus_module_9.concat_(output, shownKeys)))), tsplus_module_4.update(_ => _.copy({
+        indentationLevel: _.indentationLevel - 2
+      })));
+    } else {
+      return tsplus_module_4.succeedNow(output, fileName_1 + ":588:28");
+    }
+  }, fileName_1 + ":562:12"));
+}
+
+function showArrayBuffer(value) {
+  return tsplus_module_4.gets(context => {
+    let buffer;
+
+    try {
+      buffer = new Uint8Array(value);
+    } catch {
+      return tsplus_module_12.single("(detached)");
+    }
+
+    let str = hex(buffer.slice(0, Math.min(context.maxArrayLength, buffer.length))).replace(/(.{2})/g, "$1 ").trim();
+    const remaining = buffer.length - context.maxArrayLength;
+
+    if (remaining > 0) {
+      str += ` ... ${remaining} more byte${pluralize(remaining)}`;
+    }
+
+    return tsplus_module_12.single(`[Uint8Contents]: <${str}>`);
+  });
+}
+
+const maxEntries = 2 ** 32 - 2;
+
+function showSpecialArray(value, maxLength, currentComputation, currentIndex, currentLength) {
+  return tsplus_module_4.getsZ(context => {
+    const keys = Object.keys(value);
+    let index = currentIndex;
+    let i = currentIndex;
+    let outputLength = currentLength;
+    let computation = currentComputation;
+
+    for (; i < keys.length && outputLength < maxLength; i++) {
+      const key = keys[i];
+      const tmp = +key;
+
+      if (tmp > maxEntries) {
+        break;
+      }
+
+      if (`${index}` !== key) {
+        if (!numberRegExp.test(key)) {
+          break;
+        }
+
+        const emptyItems = tmp - index;
+        const message = `<${emptyItems} empty item${pluralize(emptyItems)}>`;
+        computation = tsplus_module_4.map_(computation, ks => tsplus_module_9.append_(ks, context.stylize(message, "undefined")));
+        outputLength++;
+        index = tmp;
+
+        if (outputLength === maxLength) {
+          break;
+        }
+      }
+
+      computation = tsplus_module_4.crossWith_(computation, showProperty(value, key, ARRAY_TYPE), (as, b) => tsplus_module_9.append_(as, b));
+      outputLength++;
+      index++;
+    }
+
+    const remaining = value.length - index;
+
+    if (outputLength !== maxLength) {
+      if (remaining > 0) {
+        computation = tsplus_module_4.map_(computation, as => tsplus_module_9.append_(as, context.stylize(`<${remaining} empty item${pluralize(remaining)}>`, "undefined")));
+      }
+    } else if (remaining > 0) {
+      computation = tsplus_module_4.map_(computation, as => tsplus_module_9.append_(as, `... ${remaining} more item${pluralize(remaining)}`));
+    }
+
+    return computation;
+  });
+}
+
+function showArray(value) {
+  return tsplus_module_4.flatMap_(tsplus_module_4.gets(context => {
+    let chunk = tsplus_module_12.from(value);
+    const valLen = chunk.length;
+    const len = Math.min(Math.max(0, context.maxArrayLength), valLen);
+    const remaining = valLen - len;
+    chunk = tsplus_module_9.take_(chunk, len);
+    return tuple(remaining, chunk);
+  }), ([remaining, chunk]) => {
+    let computation = tsplus_module_4.succeedNow(tsplus_module_7.empty(), fileName_1 + ":677:35");
+
+    for (let i = 0; i < chunk.length; i++) {
+      if (!Object.prototype.hasOwnProperty.call(value, i)) {
+        return showSpecialArray(value, chunk.length, computation, i, i);
+      }
+
+      computation = tsplus_module_4.crossWith_(computation, showProperty(value, i, ARRAY_TYPE), (props, p) => tsplus_module_9.append_(props, p));
+    }
+
+    if (remaining > 0) {
+      computation = tsplus_module_4.map_(computation, props => tsplus_module_9.append_(props, `... ${remaining} more item${pluralize(remaining)}`));
+    }
+
+    return computation;
+  });
+}
+
+function showChunk(value) {
+  return tsplus_module_4.flatMap_(tsplus_module_4.gets(context => {
+    const valLen = value.length;
+    const len = Math.min(Math.max(0, context.maxArrayLength), valLen);
+    const remaining = valLen - len;
+    const chunk = tsplus_module_9.take_(value, len);
+    return tuple(remaining, chunk);
+  }), ([remaining, chunk]) => tsplus_module_4.map_(tsplus_module_9.traverseSelf(chunk)(tsplus_module_11.Applicative)(_show), chunk => remaining > 0 ? tsplus_module_9.append_(chunk, `... ${remaining} more item${pluralize(remaining)}`) : chunk));
+}
+
+export function showProperty(value, key, type, desc) {
+  return tsplus_module_4.getsZ(context => tsplus_module_4.map_(tsplus_module_4.defer(() => {
+    const descriptor = desc || Object.getOwnPropertyDescriptor(value, key) || {
+      value: value[key],
+      enumerable: true
+    };
+
+    if (isDefined(descriptor.value)) {
+      const diff = context.compact !== true || type !== OBJECT_TYPE && type !== PROTO_TYPE ? 2 : 3;
+      return tsplus_module_4.apFirst_(tsplus_module_4.flatMap_(tsplus_module_4.apSecond_(tsplus_module_4.update(_ => _.copy({
+        indentationLevel: _.indentationLevel + diff
+      })), _show(descriptor.value)), shown => tsplus_module_4.gets(_ => diff === 3 && _.breakLength < getStringWidth(shown, _.colors) ? tuple(descriptor, `\n${" ".repeat(_.indentationLevel)}`, shown) : tuple(descriptor, " ", shown))), tsplus_module_4.update(_ => _.copy({
+        indentationLevel: _.indentationLevel - diff
+      })));
+    } else if (isDefined(descriptor.get)) {
+      return tsplus_module_4.succeedNow(tuple(descriptor, " ", `[${descriptor.set ? "Getter/Settter" : "Getter"}]`), fileName_1 + ":732:28");
+    } else if (isDefined(descriptor.set)) {
+      return tsplus_module_4.succeedNow(tuple(descriptor, " ", "Setter"), fileName_1 + ":734:28");
+    } else {
+      return tsplus_module_4.succeedNow(tuple(descriptor, " ", "undefined"), fileName_1 + ":736:28");
+    }
+  }, fileName_1 + ":712:12"), ([descriptor, extra, shown]) => {
+    if (type === ARRAY_TYPE) {
+      return shown;
+    }
+
+    let name;
+
+    if (isSymbol(key)) {
+      const tmp = key.toString().replace(strEscapeSequencesReplacer, escapeFn);
+      name = `[${context.stylize(tmp, "symbol")}]`;
+    } else if (key === "__proto__") {
+      name = "['__proto__']";
+    } else if (descriptor.enumerable === false) {
+      const tmp = key.toString().replace(strEscapeSequencesReplacer, escapeFn);
+      name = `[${tmp}]`;
+    } else if (keyStrRegExp.test(String(key))) {
+      name = String(key);
+    } else {
+      name = context.stylize(strEscape(String(key)), "string");
+    }
+
+    if (type === PROTO_TYPE) {
+      return context.stylize(`${name}:${extra}${shown}`, "dim");
+    }
+
+    return `${name}:${extra}${shown}`;
+  }));
+}
+/**
+ * Groups the formatted elements of an array-like structure into chunks limited by the
+ * maximum character width set in the context
+ */
+
+function groupElements(context, input, value) {
+  let totalLength = 0;
+  let maxLength = 0;
+  let i = 0;
+  const outputLength = context.maxArrayLength < input.length ? input.length - 1 : input.length;
+  const separatorSpace = 2;
+  const dataLength = Array(outputLength);
+  let output = input;
+
+  for (; i < outputLength; i++) {
+    const len = getStringWidth(tsplus_module_9.unsafeGet_(input, i), context.colors);
+    dataLength[i] = len;
+    totalLength += len + separatorSpace;
+
+    if (maxLength < len) {
+      maxLength = len;
+    }
+  }
+
+  const actualMax = maxLength + separatorSpace;
+
+  if (actualMax * 3 + context.indentationLevel < context.breakLength && (totalLength / actualMax > 5 || maxLength <= 6)) {
+    const approxCharHeights = 2.5;
+    const averageBias = Math.sqrt(actualMax - totalLength / input.length);
+    const biasedMax = Math.max(actualMax - 3 - averageBias, 1);
+    const columns = Math.min( // Ideally a square should be drawn. We expect a character to be about 2.5
+    // times as high as wide. This is the area formula to calculate a square
+    // which contains n rectangles of size `actualMax * approxCharHeights`.
+    // Divide that by `actualMax` to receive the correct number of columns.
+    // The added bias increases the columns for short entries.
+    Math.round(Math.sqrt(approxCharHeights * biasedMax * outputLength) / biasedMax), // Do not exceed the breakLength.
+    Math.floor((context.breakLength - context.indentationLevel) / actualMax), // Limit array grouping for small `compact` modes as the user requested
+    // minimal grouping.
+    Number(context.compact) * 4, // Limit the columns to a maximum of fifteen.
+    15);
+
+    if (columns <= 1) {
+      return input;
+    }
+
+    let tmp = tsplus_module_7.empty();
+    const maxLineLength = [];
+
+    for (let i = 0; i < columns; i++) {
+      let lineMaxLength = 0;
+
+      for (let k = i; k < output.length; k += columns) {
+        if (dataLength[k] > lineMaxLength) {
+          lineMaxLength = dataLength[k];
+        }
+      }
+
+      lineMaxLength += separatorSpace;
+      maxLineLength[i] = lineMaxLength;
+    }
+
+    let order = String.prototype.padStart;
+
+    if (value !== undefined && isArray(value)) {
+      for (let i = 0; i < output.length; i++) {
+        if (typeof value[i] !== "number" && typeof value[i] !== "bigint") {
+          order = String.prototype.padEnd;
+          break;
+        }
+      }
+    }
+
+    for (let i = 0; i < outputLength; i += columns) {
+      const max = Math.min(i + columns, outputLength);
+      let str = "";
+      let k = i;
+
+      for (; k < max - 1; k++) {
+        const padding = maxLineLength[k - i] + tsplus_module_9.unsafeGet_(output, k).length - dataLength[k];
+        str += order.call(`${tsplus_module_9.unsafeGet_(output, k)}, `, padding, " ");
+      }
+
+      if (order === String.prototype.padStart) {
+        const padding = maxLineLength[k - i] + tsplus_module_9.unsafeGet_(output, k).length - dataLength[k] - separatorSpace;
+        str += tsplus_module_9.unsafeGet_(output, k).padStart(padding, " ");
+      } else {
+        str += tsplus_module_9.unsafeGet_(output, k);
+      }
+
+      tmp = tsplus_module_9.append_(tmp, str);
+    }
+
+    if (context.maxArrayLength < output.length) {
+      tmp = tsplus_module_9.append_(tmp, tsplus_module_9.unsafeGet_(output, outputLength));
+    }
+
+    output = tmp;
+  }
+
+  return output;
+}
+
+function _showPrimitive(context, value) {
+  switch (typeof value) {
+    case "string":
+      return _showString(context, value);
+
+    case "number":
+      return _showNumber(context, value);
+
+    case "boolean":
+      return _showBoolean(context, value);
+
+    case "bigint":
+      return _showBigInt(context, value);
+
+    case "symbol":
+      return _showSymbol(context, value);
+  }
+}
+
+function _showString(context, value) {
+  let result = value;
+  let trailer = "";
+
+  if (value.length > context.maxStringLength) {
+    const remaining = value.length - context.maxStringLength;
+    result = result.slice(0, context.maxStringLength);
+    trailer = `... ${remaining} more character${pluralize(remaining)}`;
+  }
+
+  if (context.compact !== true && result.length > 16 && result.length > context.breakLength - context.indentationLevel - 4) {
+    return result.split(/(?<=\n)/).map(line => context.stylize(strEscape(line), "string")).join(` +\n${" ".repeat(context.indentationLevel + 2)}`) + trailer;
+  }
+
+  return context.stylize(strEscape(value), "string") + trailer;
+}
+
+function _showNumber(context, value) {
+  return context.stylize(value.toString(10), "number");
+}
+
+function _showBoolean(context, value) {
+  return context.stylize(value === true ? "true" : "false", "boolean");
+}
+
+function _showBigInt(context, value) {
+  return context.stylize(`${value.toString()}n`, "bigint");
+}
+
+function _showSymbol(context, value) {
+  return context.stylize(value.toString(), "symbol");
+}
+//# sourceMappingURL=show.mjs.map