@mmutils/logger 0.0.0-stage → 0.1.1

package/dist/esm/utils/text.js

@@ -0,0 +1,621 @@
+/**
+ * Centers `text` by padding it left and right. Text longer than `length` is
+ * returned unchanged.
+ */
+const padTextMiddle = (text, length, padString = ' ') => text
+    .padStart(text.length + Math.floor((length - text.length) / 2), padString)
+    .padEnd(length, padString);
+/**
+ * Justifies two strings to the left and right of a column. If the column is
+ * too narrow, each text is placed on its own line.
+ */
+const justifyLeftRight = (leftText, rightText, columnWidth) => columnWidth < leftText.length + rightText.length ?
+    `${leftText}\n${rightText}`
+    : `${leftText.padEnd(columnWidth - rightText.length)}${rightText}`;
+/* eslint-disable no-control-regex -- matching control characters is the point */
+/**
+ * SGR (color and text style) sequence.
+ */
+const SGR = /\x1B\[[0-9;:]*m/g;
+/* eslint-enable no-control-regex */
+const SGR_RESET = '\x1b[0m';
+const INDENT = '  ';
+/**
+ * Source of a character class with the control characters to replace.
+ *
+ * @param newlines Include `\n`.
+ * @param esc Include ESC.
+ */
+const controlClass = (newlines, esc) => `[\\x00-\\x08${newlines ? '\\x0A' : ''}\\x0B-${esc ? '\\x1F' : '\\x1A\\x1C-\\x1F'}\\x7F-\\x9F]`;
+/**
+ * Replaces every `\n`. Faster than `replaceAll`, which matters for multi-line
+ * messages.
+ */
+const replaceNewlines = (text, newline) => {
+    let index = text.indexOf('\n');
+    if (index === -1)
+        return text;
+    let result = '';
+    let start = 0;
+    while (index !== -1) {
+        result += `${text.slice(start, index)}${newline}`;
+        start = index + 1;
+        index = text.indexOf('\n', start);
+    }
+    return `${result}${text.slice(start)}`;
+};
+const toHexEscape = (char) => `\\x${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')}`;
+/**
+ * Builds the regular expressions once and returns the escape function. Clean
+ * text costs one regex scan. Text with only kept colors and newlines is
+ * handled natively; the replacer runs only for other control characters.
+ */
+const createEscape = (keepColors, newlines) => {
+    const matchNewlines = newlines !== 'keep';
+    const control = controlClass(matchNewlines, true);
+    const test = new RegExp(control);
+    // control characters the native fast path can't handle
+    const unsafe = new RegExp(keepColors ?
+        `${controlClass(false, false)}|\\x1B(?!\\[[0-9;:]*m)`
+        : controlClass(false, true));
+    const newline = newlines === 'indent' ? `\n${INDENT}` : '\\x0A';
+    const replaceControl = (char) => char === '\n' ? newline : toHexEscape(char);
+    if (!keepColors) {
+        const controls = new RegExp(control, 'g');
+        return (text) => {
+            if (!test.test(text))
+                return text;
+            // only newlines
+            if (!unsafe.test(text))
+                return replaceNewlines(text, newline);
+            return text.replace(controls, replaceControl);
+        };
+    }
+    const sgrOrControls = new RegExp(`${SGR.source}|${control}`, 'g');
+    return (text) => {
+        if (!test.test(text))
+            return text;
+        // only colors and newlines, e.g. multi-line text with baked styles
+        if (!unsafe.test(text)) {
+            const result = matchNewlines ? replaceNewlines(text, newline) : text;
+            return result.includes('\x1b') ? `${result}${SGR_RESET}` : result;
+        }
+        // set by the replacer, which control flow analysis doesn't follow
+        let colored = false;
+        const escaped = text.replace(sgrOrControls, (match) => {
+            if (match.length === 1)
+                return replaceControl(match);
+            colored = true;
+            return match;
+        });
+        return colored ? `${escaped}${SGR_RESET}` : escaped;
+    };
+};
+const keepText = (text) => text;
+const NO_SANITIZER = { text: keepText, label: keepText };
+/**
+ * Creates the sanitizing functions of a given setting. Create it once (e.g. in
+ * a plugin factory) and reuse it for every log.
+ *
+ * @param sanitize Preset or custom rules. Default: `'safe'`.
+ */
+const createSanitizer = (sanitize = 'safe') => {
+    if (sanitize === 'none')
+        return NO_SANITIZER;
+    const rules = sanitize === 'safe' ? {}
+        : sanitize === 'strict' ? { colors: 'escape', newlines: 'escape' }
+            : sanitize;
+    const { colors = 'keep', newlines = 'indent' } = rules;
+    // the functions keep no state, so equal rules share them and their regexes
+    const key = `${colors}:${newlines}`;
+    const cached = sanitizers.get(key);
+    if (cached !== undefined)
+        return cached;
+    const label = createEscape(colors === 'keep', 'escape');
+    const sanitizer = {
+        text: newlines === 'escape' ? label : createEscape(colors === 'keep', newlines),
+        label,
+    };
+    sanitizers.set(key, sanitizer);
+    return sanitizer;
+};
+/**
+ * Sanitizers by resolved rules: building one compiles several regular
+ * expressions (about 2 µs).
+ */
+const sanitizers = new Map();
+/**
+ * Length of text without SGR sequences: the columns it takes on a terminal,
+ * for single-width characters. Sanitized text contains no other sequences.
+ * `textWidth` also counts wide characters as two columns.
+ */
+const visibleLength = (text) => {
+    if (!text.includes('\x1b'))
+        return text.length;
+    let length = text.length;
+    for (const [sequence] of text.matchAll(SGR))
+        length -= sequence.length;
+    return length;
+};
+/* eslint-disable no-control-regex -- matching control characters is the point */
+const SGR_AT = /\x1B\[[0-9;:]*m/y;
+/* eslint-enable no-control-regex */
+/**
+ * Characters that are not one terminal column wide, escape codes and tabs:
+ * lines without them are wrapped by slicing. Box drawing and block
+ * characters (graphs) are not in it.
+ */
+/* eslint-disable no-misleading-character-class -- ranges of combining marks, matched one code unit at a time on purpose */
+const SLOW_CHARS = new RegExp('[\\x00-\\x1f\\x7f-\\x9f\\u0300-\\u036f\\u1100-\\u115f\\u200b-\\u200f' +
+    '\\u231a-\\u23f3\\u25fd-\\u27bf\\u2b1b-\\u2b55\\u2e80-\\ua4cf' +
+    '\\ua960-\\ua97f\\uac00-\\ud7a3\\ud800-\\udfff\\uf900-\\ufaff' +
+    '\\ufe00-\\ufe6f\\uff00-\\uff60\\uffe0-\\uffe6]');
+/* eslint-enable no-misleading-character-class */
+/**
+ * East Asian Wide and Fullwidth ranges and emoji shown as two columns, as
+ * `first, last` pairs in ascending order. An approximation: emoji
+ * sequences (ZWJ, flags) are measured per code point.
+ */
+const WIDE_RANGES = [
+    0x1100, 0x115f, 0x231a, 0x231b, 0x2329, 0x232a, 0x23e9, 0x23ec, 0x23f0,
+    0x23f0, 0x23f3, 0x23f3, 0x25fd, 0x25fe, 0x2614, 0x2615, 0x2648, 0x2653,
+    0x267f, 0x267f, 0x2693, 0x2693, 0x26a1, 0x26a1, 0x26aa, 0x26ab, 0x26bd,
+    0x26be, 0x26c4, 0x26c5, 0x26ce, 0x26ce, 0x26d4, 0x26d4, 0x26ea, 0x26ea,
+    0x26f2, 0x26f3, 0x26f5, 0x26f5, 0x26fa, 0x26fa, 0x26fd, 0x26fd, 0x2705,
+    0x2705, 0x270a, 0x270b, 0x2728, 0x2728, 0x274c, 0x274c, 0x274e, 0x274e,
+    0x2753, 0x2755, 0x2757, 0x2757, 0x2795, 0x2797, 0x27b0, 0x27b0, 0x27bf,
+    0x27bf, 0x2b1b, 0x2b1c, 0x2b50, 0x2b50, 0x2b55, 0x2b55, 0x2e80, 0x303e,
+    0x3041, 0x33ff, 0x3400, 0x4dbf, 0x4e00, 0x9fff, 0xa000, 0xa4cf, 0xa960,
+    0xa97f, 0xac00, 0xd7a3, 0xf900, 0xfaff, 0xfe10, 0xfe19, 0xfe30, 0xfe6f,
+    0xff00, 0xff60, 0xffe0, 0xffe6, 0x16fe0, 0x18aff, 0x1b000, 0x1b2ff, 0x1f004,
+    0x1f004, 0x1f0cf, 0x1f0cf, 0x1f18e, 0x1f18e, 0x1f191, 0x1f19a, 0x1f200,
+    0x1f251, 0x1f300, 0x1f320, 0x1f32d, 0x1f335, 0x1f337, 0x1f37c, 0x1f37e,
+    0x1f393, 0x1f3a0, 0x1f3ca, 0x1f3cf, 0x1f3d3, 0x1f3e0, 0x1f3f0, 0x1f3f4,
+    0x1f3f4, 0x1f3f8, 0x1f43e, 0x1f440, 0x1f440, 0x1f442, 0x1f4fc, 0x1f4ff,
+    0x1f53d, 0x1f54b, 0x1f54e, 0x1f550, 0x1f567, 0x1f57a, 0x1f57a, 0x1f595,
+    0x1f596, 0x1f5a4, 0x1f5a4, 0x1f5fb, 0x1f64f, 0x1f680, 0x1f6c5, 0x1f6cc,
+    0x1f6cc, 0x1f6d0, 0x1f6d2, 0x1f6d5, 0x1f6d7, 0x1f6eb, 0x1f6ec, 0x1f6f4,
+    0x1f6fc, 0x1f7e0, 0x1f7eb, 0x1f90c, 0x1f93a, 0x1f93c, 0x1f945, 0x1f947,
+    0x1f9ff, 0x1fa70, 0x1faff, 0x20000, 0x3fffd,
+];
+const isWide = (codePoint) => {
+    // binary search over the ranges
+    let low = 0;
+    let high = WIDE_RANGES.length / 2 - 1;
+    while (low <= high) {
+        const middle = (low + high) >> 1;
+        if (codePoint < (WIDE_RANGES[middle * 2] ?? 0))
+            high = middle - 1;
+        else if (codePoint > (WIDE_RANGES[middle * 2 + 1] ?? 0))
+            low = middle + 1;
+        else
+            return true;
+    }
+    return false;
+};
+const isZeroWidth = (codePoint) => codePoint < 0x20 ||
+    (codePoint >= 0x7f && codePoint <= 0x9f) ||
+    (codePoint >= 0x300 && codePoint <= 0x36f) ||
+    (codePoint >= 0x200b && codePoint <= 0x200f) ||
+    (codePoint >= 0xfe00 && codePoint <= 0xfe0f) ||
+    (codePoint >= 0x1f3fb && codePoint <= 0x1f3ff) ||
+    (codePoint >= 0xe0100 && codePoint <= 0xe01ef);
+/**
+ * Terminal columns a code point takes: 0 for controls, combining marks,
+ * zero-width characters, variation selectors and skin tones, 2 for East
+ * Asian wide characters and most emoji, 1 otherwise.
+ */
+const charWidth = (codePoint) => isZeroWidth(codePoint) ? 0
+    : isWide(codePoint) ? 2
+        : 1;
+/**
+ * Terminal columns a text takes: SGR sequences take none, wide characters
+ * two. Tabs count as one column; `wrapText` expands them.
+ */
+const textWidth = (text) => {
+    if (!SLOW_CHARS.test(text))
+        return text.length;
+    let width = 0;
+    for (let index = 0; index < text.length;) {
+        if (text.charCodeAt(index) === 0x1b) {
+            SGR_AT.lastIndex = index;
+            const sgr = SGR_AT.exec(text);
+            if (sgr !== null) {
+                index += sgr[0].length;
+                continue;
+            }
+        }
+        const codePoint = text.codePointAt(index) ?? 0;
+        width += codePoint === 0x09 ? 1 : charWidth(codePoint);
+        index += codePoint > 0xffff ? 2 : 1;
+    }
+    return width;
+};
+/**
+ * Describes a thrown value as `Name: message`. Never throws, even for thrown
+ * values with throwing getters or revoked proxies.
+ */
+const describeThrown = (thrown) => {
+    try {
+        return thrown instanceof Error ?
+            `${thrown.name}: ${thrown.message}`
+            : String(thrown);
+    }
+    catch {
+        return 'unknown error';
+    }
+};
+/**
+ * Splits an error to its `name: message` head, which can span multiple
+ * lines, and its stack frames. Never throws: a head or stack that can't be
+ * read (throwing getters, `Error.prepareStackTrace`) becomes a placeholder.
+ */
+const splitError = (error) => {
+    let head;
+    try {
+        head = String(error);
+    }
+    catch (thrown) {
+        head = `[Unreadable error: ${describeThrown(thrown)}]`;
+    }
+    let stack;
+    try {
+        stack = error.stack;
+    }
+    catch (thrown) {
+        return [head, [`[Unreadable stack: ${describeThrown(thrown)}]`]];
+    }
+    if (typeof stack !== 'string')
+        return [head, []];
+    const frames = stack.startsWith(head) ? stack.slice(head.length) : stack;
+    return [head, frames.split('\n').filter(Boolean)];
+};
+const DEFAULT_OUTPUT_LIMITS = {
+    items: 100,
+    stringLength: 10_000,
+};
+/**
+ * No output limits: the default of the text utilities, which only truncate
+ * when given limits.
+ */
+const NO_OUTPUT_LIMITS = {
+    items: Infinity,
+    stringLength: Infinity,
+};
+/**
+ * Fills in the default output limits and validates them.
+ *
+ * @param what Prefix of error messages, e.g. `messagePlugin`.
+ * @throws RangeError if a limit is not a positive integer or `Infinity`.
+ */
+const resolveOutputLimits = (limits, what) => {
+    const resolved = {
+        items: limits?.items ?? DEFAULT_OUTPUT_LIMITS.items,
+        stringLength: limits?.stringLength ?? DEFAULT_OUTPUT_LIMITS.stringLength,
+    };
+    for (const [name, value] of Object.entries(resolved))
+        if (value !== Infinity && !(Number.isInteger(value) && value >= 1))
+            throw new RangeError(`${what}: limits.${name} must be a positive integer or Infinity, got ${String(value)}.`);
+    return resolved;
+};
+/**
+ * Note on what output limits left out: `… 3 more items`, `… 1 more item`.
+ */
+const describeLeftOut = (count, unit) => `… ${String(count)} more ${count === 1 ? unit
+    : unit === 'entry' ? 'entries'
+        : `${unit}s`}`;
+/**
+ * Cuts text to `maxLength` characters, never inside a surrogate pair, and
+ * tells how many were left out: `xxx… 1000 more characters`. Shorter text is
+ * returned as is.
+ */
+const truncate = (text, maxLength) => {
+    if (text.length <= maxLength)
+        return text;
+    const end = cutIndex(text, maxLength);
+    return `${text.slice(0, end)}${describeLeftOut(text.length - end, 'character')}`;
+};
+/**
+ * Where to cut text longer than `maxLength`, so a surrogate pair stays whole.
+ */
+const cutIndex = (text, maxLength) => {
+    const code = text.charCodeAt(maxLength - 1);
+    return code >= 0xd800 && code <= 0xdbff ? maxLength - 1 : maxLength;
+};
+/**
+ * Keys of an object to render, at most `items`. Large arrays are indexed
+ * without listing all their keys first.
+ *
+ * @returns The keys and the number of keys left out.
+ */
+const limitKeys = (data, items) => {
+    if (Array.isArray(data) && data.length > items) {
+        const keys = [];
+        for (let index = 0; index < items; index++)
+            keys.push(String(index));
+        return [keys, data.length - items];
+    }
+    const keys = Object.keys(data);
+    return keys.length > items ?
+        [keys.slice(0, items), keys.length - items]
+        : [keys, 0];
+};
+/**
+ * JSON of an object property. Never throws: a getter that throws gives a
+ * placeholder, so one bad property doesn't hide the others.
+ */
+const stringifyProperty = (data, key, limits = NO_OUTPUT_LIMITS) => {
+    let value;
+    try {
+        value = data[key];
+    }
+    catch (thrown) {
+        return `[Getter threw: ${describeThrown(thrown)}]`;
+    }
+    return safeStringify(value, limits);
+};
+/**
+ * Short description of a function, like `util.inspect`: `[Function: name]`
+ * or `[class Name]`, never its source code.
+ */
+const describeFunction = (fn) => {
+    const { name } = fn;
+    const label = typeof name === 'string' && name ? name : '(anonymous)';
+    // V8 returns a slice of the cached source: checking the prefix copies nothing
+    return Function.prototype.toString.call(fn).startsWith('class') ?
+        `[class ${label}]`
+        : `[Function: ${label}]`;
+};
+/**
+ * Describes buffers and typed arrays in one line, like `util.inspect`:
+ * `<Buffer 68 69 … 998 more bytes>`, `Uint8Array(3) [1, 2, 3]`. Their JSON
+ * (and their keys) would list every element.
+ */
+const describeBinary = (view, items) => {
+    if (view instanceof DataView)
+        return `DataView(${String(view.byteLength)})`;
+    const elements = view;
+    const { name } = view.constructor ?? {};
+    const isBuffer = name === 'Buffer';
+    const shown = Math.min(elements.length, items);
+    let text = '';
+    for (let index = 0; index < shown; index++) {
+        const element = elements[index] ?? 0;
+        text +=
+            isBuffer ?
+                `${index ? ' ' : ''}${element.toString(16).padStart(2, '0')}`
+                : `${index ? ', ' : ''}${String(element)}${typeof element === 'bigint' ? 'n' : ''}`;
+    }
+    const more = elements.length - shown;
+    if (isBuffer)
+        return `<Buffer${text ? ` ${text}` : ''}${more ? ` ${describeLeftOut(more, 'byte')}` : ''}>`;
+    return `${typeof name === 'string' ? name : 'TypedArray'}(${String(elements.length)}) [${text}${more ? `, ${describeLeftOut(more, 'item')}` : ''}]`;
+};
+/**
+ * Checks for errors of other realms (`vm` contexts, workers), which fail
+ * `instanceof Error`.
+ */
+const isForeignError = (value) => Object.prototype.toString.call(value) === '[object Error]';
+/**
+ * `Name: message` of an error, followed by the JSON of its own enumerable
+ * properties, if any, e.g. `Error: refused {"code":"ECONNREFUSED"}`.
+ */
+const describeErrorValue = (error) => {
+    const head = describeThrown(error);
+    let props;
+    try {
+        props = JSON.stringify(error);
+    }
+    catch {
+        // properties that can't be serialized are left out
+    }
+    return props === undefined || props === '{}' ? head : `${head} ${props}`;
+};
+/**
+ * Entries of a map or set, at most `items`, stopping early once longer than
+ * `stringLength`.
+ */
+const describeEntries = (entries, size, limits, describeEntry) => {
+    let text = '';
+    let shown = 0;
+    for (const entry of entries) {
+        if (shown === limits.items || text.length > limits.stringLength)
+            break;
+        text += `${shown ? ', ' : ''}${describeEntry(entry)}`;
+        shown++;
+    }
+    const more = size - shown;
+    return more ? `${text}, ${describeLeftOut(more, 'entry')}` : text;
+};
+/**
+ * Describes objects JSON shows as `{}`: dates (ISO), maps, sets, regular
+ * expressions and errors of other realms, like `util.inspect`. Entries of
+ * maps and sets are JSON, so nesting can't recurse.
+ *
+ * @returns `undefined` for other objects.
+ */
+const describeObject = (value, limits = NO_OUTPUT_LIMITS) => {
+    if (value instanceof Date)
+        return Number.isNaN(value.getTime()) ? 'Invalid Date' : value.toISOString();
+    if (value instanceof Map)
+        return `Map(${String(value.size)}) {${describeEntries(value, value.size, limits, (entry) => {
+            const [key, item] = entry;
+            return `${stringifyValue(key, false, limits)} => ${stringifyValue(item, false, limits)}`;
+        })}}`;
+    if (value instanceof Set)
+        return `Set(${String(value.size)}) {${describeEntries(value, value.size, limits, (item) => stringifyValue(item, false, limits))}}`;
+    if (value instanceof RegExp)
+        return String(value);
+    if (isForeignError(value))
+        return describeErrorValue(value);
+    return undefined;
+};
+/**
+ * @param describe Describe objects JSON shows as `{}` (see `describeObject`).
+ */
+const stringifyValue = (value, describe, limits) => {
+    let text;
+    try {
+        // long strings are cut before JSON, which would copy them whole
+        if (typeof value === 'string' && value.length > limits.stringLength) {
+            const end = cutIndex(value, limits.stringLength);
+            return `${JSON.stringify(value.slice(0, end))}${describeLeftOut(value.length - end, 'character')}`;
+        }
+        if (typeof value === 'function')
+            text = describeFunction(value);
+        else if (typeof value === 'bigint')
+            text = `${String(value)}n`;
+        else if (value instanceof Error)
+            text = describeErrorValue(value);
+        else if (ArrayBuffer.isView(value))
+            text = describeBinary(value, limits.items);
+        else {
+            // undefined for symbols and undefined, despite the lib typing
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            text = JSON.stringify(value) ?? String(value);
+            if (describe &&
+                text === '{}' &&
+                typeof value === 'object' &&
+                value !== null)
+                text = describeObject(value, limits) ?? text;
+        }
+    }
+    catch {
+        return '"[Unserializable]"';
+    }
+    return truncate(text, limits.stringLength);
+};
+/**
+ * `JSON.stringify` that never throws and describes what JSON can't:
+ * - functions and classes: `[Function: name]`, `[class Name]`, no source;
+ * - bigints: `1n`;
+ * - errors: `Name: message` and their own properties' JSON;
+ * - buffers and typed arrays: see `describeBinary`;
+ * - dates, maps, sets, regular expressions and errors of other realms that
+ *   JSON shows as `{}`: see `describeObject`;
+ * - symbols and `undefined`: `String`;
+ * - circular structures: `"[Unserializable]"`.
+ *
+ * Nested values are serialized whole by the native `JSON.stringify` and the
+ * result is cut to `limits.stringLength`.
+ *
+ * @param limits Output limits. Default: none.
+ */
+const safeStringify = (value, limits = NO_OUTPUT_LIMITS) => stringifyValue(value, true, limits);
+/**
+ * Text of a top-level value that is neither a string nor an object:
+ * functions and classes are described, bigints get their `n` suffix.
+ */
+const stringifyPrimitive = (value) => typeof value === 'function' ? describeFunction(value)
+    : typeof value === 'bigint' ? `${String(value)}n`
+        : String(value);
+const stringifyError = (error, { text, label }, { items, stringLength }) => {
+    const [head, frames] = splitError(error);
+    let result = text(truncate(head, stringLength));
+    const shown = Math.min(frames.length, items);
+    for (let index = 0; index < shown; index++)
+        result += `\n${label(truncate(frames[index] ?? '', stringLength))}`;
+    if (frames.length > shown)
+        result += `\n${describeLeftOut(frames.length - shown, 'frame')}`;
+    return result;
+};
+/**
+ * Converts any log data to text:
+ * - strings are returned as is;
+ * - errors are represented by their `name: message` and stack frames;
+ * - buffers and typed arrays are described in one line;
+ * - objects and arrays print each own property as `key: JSON` on a new line;
+ * - everything else is converted with `String`.
+ *
+ * Never throws: data that can't be read (throwing getters, revoked proxies,
+ * broken errors) gives placeholders.
+ *
+ * @param sanitizer Sanitizes strings (`text`), keys, values and stack frames
+ * (`label`). Default: none.
+ * @param limits Output limits. Default: none.
+ */
+const stringifyData = (data, sanitizer = NO_SANITIZER, limits = NO_OUTPUT_LIMITS) => {
+    const { text, label } = sanitizer;
+    const { items, stringLength } = limits;
+    try {
+        if (typeof data === 'string')
+            return text(truncate(data, stringLength));
+        if (data instanceof Error)
+            return stringifyError(data, sanitizer, limits);
+        if (typeof data === 'object' && data !== null) {
+            if (ArrayBuffer.isView(data))
+                return label(describeBinary(data, items));
+            const [keys, more] = limitKeys(data, items);
+            if (!keys.length) {
+                // errors of other realms have no enumerable keys either
+                if (isForeignError(data))
+                    return stringifyError(data, sanitizer, limits);
+                return label(truncate(describeObject(data, limits) ?? safeStringify(data), stringLength));
+            }
+            const lines = [];
+            for (const key of keys)
+                lines.push(`${label(truncate(key, stringLength))}: ${label(stringifyProperty(data, key, limits))}`);
+            if (more)
+                lines.push(describeLeftOut(more, 'item'));
+            return lines.join('\n');
+        }
+        return text(truncate(stringifyPrimitive(data), stringLength));
+    }
+    catch (thrown) {
+        return `[Unrenderable: ${label(describeThrown(thrown))}]`;
+    }
+};
+/**
+ * Overlaps below this are floating point noise at bucket edges, not real
+ * overlaps, and must not leak a neighbour's peak into `'max'`/`'min'`.
+ */
+const MIN_OVERLAP = 1e-9;
+/**
+ * Scales an array to a new length by combining the overlapping source cells
+ * of each new cell.
+ *
+ * @param data Values to scale.
+ * @param newLength Length of the result.
+ * @param aggregate How overlapping cells are combined. Default: `'average'`.
+ * @throws TypeError if `newLength` is not a non-negative integer.
+ */
+const scaleArray = (data, newLength, aggregate = 'average') => {
+    if (!Number.isInteger(newLength) || newLength < 0)
+        throw new TypeError('scaleArray: new length is not a positive integer.');
+    const dataLength = data.length;
+    if (dataLength === newLength)
+        return [...data];
+    if (dataLength === 0)
+        return Array(newLength).fill(0);
+    const bucketSize = dataLength / newLength;
+    const result = [];
+    for (let i = 0; i < newLength; i++) {
+        const bucketStart = i * bucketSize;
+        const bucketEnd = bucketStart + bucketSize;
+        const indexEnd = Math.min(dataLength, Math.ceil(bucketEnd));
+        let sum = 0;
+        let totalWeight = 0;
+        let max = -Infinity;
+        let min = Infinity;
+        for (let n = Math.floor(bucketStart); n < indexEnd; n++) {
+            const weight = Math.min(bucketEnd, n + 1) - Math.max(bucketStart, n);
+            if (weight < MIN_OVERLAP)
+                continue;
+            const value = data[n] ?? 0;
+            sum += value * weight;
+            totalWeight += weight;
+            if (value > max)
+                max = value;
+            if (value < min)
+                min = value;
+        }
+        result.push(!totalWeight ? 0
+            : aggregate === 'max' ? max
+                : aggregate === 'min' ? min
+                    : sum / totalWeight);
+    }
+    return result;
+};
+
+export { DEFAULT_OUTPUT_LIMITS, NO_OUTPUT_LIMITS, SLOW_CHARS, charWidth, createSanitizer, describeBinary, describeFunction, describeLeftOut, describeObject, describeThrown, isForeignError, justifyLeftRight, limitKeys, padTextMiddle, resolveOutputLimits, safeStringify, scaleArray, splitError, stringifyData, stringifyPrimitive, stringifyProperty, textWidth, truncate, visibleLength };
+//# sourceMappingURL=text.js.map