@mmutils/logger 0.0.0-stage → 0.1.0

package/dist/cjs/plugins/json.cjs

@@ -0,0 +1,644 @@
+'use strict';
+
+var levels = require('../levels.cjs');
+var text = require('../utils/text.cjs');
+var time = require('../time.cjs');
+
+/**
+ * Most causes serialized per error; deeper causes are summarized as
+ * `"Name: message"`. A cause already in the chain is `"[Circular]"`.
+ */
+const MAX_CAUSES = 5;
+const NO_CAUSES = [];
+/**
+ * Depth of a value in the logged data. Values at `DATA` (the data itself)
+ * and `PROPERTY` (its properties or elements) get special handling: errors,
+ * binary data, bigints, functions, long strings and arrays. Objects at `DATA`
+ * are also walked key by key when native JSON would lose something. `LEAF`
+ * values (error properties) are handled like `PROPERTY` ones, except nested
+ * errors, which are summarized, so error graphs can't multiply.
+ */
+const DATA = 0;
+const PROPERTY = 1;
+const LEAF = 2;
+const quote = (text) => JSON.stringify(text);
+const quoteLimited = (text$1, limits) => JSON.stringify(text.truncate(text$1, limits.stringLength));
+const placeholder = (prefix, thrown, limits) => quoteLimited(`[${prefix}: ${text.describeThrown(thrown)}]`, limits);
+/**
+ * Appends `"key":json` to the inside of an object. Values without JSON
+ * (`undefined`) are left out, like `JSON.stringify` does.
+ */
+const appendProperty = (text, quotedKey, json) => json === undefined ? text : `${text}${text ? ',' : ''}${quotedKey}:${json}`;
+/**
+ * Levels a too long value is cut into while keeping its type; deeper, the
+ * value becomes a cut string.
+ */
+const MAX_CUT_LEVELS = 4;
+const NO_ANCESTORS = [];
+/**
+ * Objects native JSON writes as objects from their own enumerable keys: not
+ * arrays, and without `toJSON` (dates are written as strings).
+ */
+const isKeyedObject = (value) => typeof value === 'object' &&
+    value !== null &&
+    !Array.isArray(value) &&
+    typeof value.toJSON !== 'function';
+/**
+ * Native JSON of a value, like `JSON.stringify` (`undefined` for functions,
+ * symbols and `undefined`), or a placeholder if it can't be serialized.
+ */
+const elementJson = (value, limits) => {
+    try {
+        return JSON.stringify(value);
+    }
+    catch (thrown) {
+        return placeholder('Unserializable', thrown, limits);
+    }
+};
+/**
+ * JSON of an element or property inside a cut value: `"[Circular]"` if it
+ * is one of the values being cut around it, native JSON when that works,
+ * otherwise (a cycle further down, a nested bigint) cut the same way, so it
+ * keeps its type too. A throwing getter gives a placeholder.
+ *
+ * @param ancestors The values being cut, the container included.
+ */
+const childJson = (read, room, limits, ancestors) => {
+    let child;
+    try {
+        child = read();
+    }
+    catch (thrown) {
+        return placeholder('Getter threw', thrown, limits);
+    }
+    if (typeof child === 'object' && child !== null && ancestors.includes(child))
+        return '"[Circular]"';
+    try {
+        return JSON.stringify(child);
+    }
+    catch {
+        return cutJson(child, room, limits, ancestors);
+    }
+};
+/**
+ * JSON of a value that is too long, cut to about `budget` characters while
+ * keeping its type, so collectors that map fields by type (Elasticsearch)
+ * accept the line: see `cutArray` and `cutObject`. Other values (strings,
+ * dates, values deeper than `MAX_CUT_LEVELS`) become a cut string. A value
+ * that contains itself is `"[Circular]"`.
+ *
+ * @param ancestors Arrays and objects being cut around this value.
+ */
+const cutJson = (value, budget, limits, ancestors) => {
+    if (typeof value === 'object' && value !== null && ancestors.includes(value))
+        return '"[Circular]"';
+    if (ancestors.length < MAX_CUT_LEVELS) {
+        if (Array.isArray(value))
+            return cutArray(value, budget, limits, ancestors);
+        if (isKeyedObject(value))
+            return cutObject(value, budget, limits, ancestors);
+    }
+    // a JSON number with every digit, like bigints elsewhere in the data
+    if (typeof value === 'bigint')
+        return String(value);
+    const json = elementJson(value, limits) ?? 'null';
+    if (json.length <= budget)
+        return json;
+    // cut the text of strings (also placeholders), the JSON of other values
+    const text$1 = typeof value === 'string' ? value
+        : json.startsWith('"') ? JSON.parse(json)
+            : json;
+    return quote(text.truncate(text$1, Math.max(1, budget - 2)));
+};
+/**
+ * An array cut to about `budget` characters: elements while they fit, at
+ * most `items`, then a `"… N more items"` element. A first element that
+ * alone doesn't fit is cut the same way. The cost grows with `budget`, not
+ * with the array: elements are serialized one by one until one doesn't fit.
+ */
+const cutArray = (array, budget, limits, ancestors) => {
+    const max = Math.min(array.length, limits.items);
+    const inner = [...ancestors, array];
+    let text$1 = '';
+    let shown = 0;
+    for (; shown < max; shown++) {
+        const index = shown;
+        // room inside the brackets, after the separator
+        const room = budget - text$1.length - 2 - (shown ? 1 : 0);
+        const json = childJson(() => array[index], room, limits, inner) ?? 'null';
+        if (json.length <= room) {
+            text$1 += `${shown ? ',' : ''}${json}`;
+            continue;
+        }
+        if (!shown) {
+            text$1 = cutJson(array[0], room, limits, inner);
+            shown = 1;
+        }
+        break;
+    }
+    const more = array.length - shown;
+    return `[${text$1}${more ? `${text$1 ? ',' : ''}${quote(text.describeLeftOut(more, 'item'))}` : ''}]`;
+};
+/**
+ * An object cut to about `budget` characters: properties while they fit, at
+ * most `items`, then `"…": "… N more items"`. A first property whose value
+ * alone doesn't fit is cut the same way.
+ */
+const cutObject = (object, budget, limits, ancestors) => {
+    const keys = Object.keys(object);
+    const max = Math.min(keys.length, limits.items);
+    const inner = [...ancestors, object];
+    const read = (key) => object[key];
+    let text$1 = '';
+    let shown = 0;
+    for (; shown < max; shown++) {
+        const key = keys[shown] ?? '';
+        const property = `${quoteLimited(key, limits)}:`;
+        const room = budget - text$1.length - 2 - (text$1 ? 1 : 0) - property.length;
+        const json = childJson(() => read(key), room, limits, inner);
+        // left out by JSON (functions, symbols, undefined): counted as shown
+        if (json === undefined)
+            continue;
+        if (json.length <= room) {
+            text$1 += `${text$1 ? ',' : ''}${property}${json}`;
+            continue;
+        }
+        if (!text$1) {
+            text$1 = `${property}${cutJson(read(key), room, limits, inner)}`;
+            shown++;
+        }
+        break;
+    }
+    const more = keys.length - shown;
+    return `{${text$1}${more ? `${text$1 ? ',' : ''}"…":${quote(text.describeLeftOut(more, 'item'))}` : ''}}`;
+};
+/**
+ * Counts own enumerable keys, stopping after `max + 1`: enough to know if
+ * an object has more than `max` without listing all keys.
+ */
+const countKeys = (object, max) => {
+    let count = 0;
+    // no hasOwn check (it doubles the cost): enumerable keys added to
+    // Object.prototype by other code can only overcount, which cuts with
+    // Object.keys and still writes the object's real keys
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- counting
+    for (const _ in object)
+        if (++count > max)
+            break;
+    return count;
+};
+/**
+ * Native JSON of an object. A text longer than `stringLength` is cut
+ * keeping its type (`cutJson`); plain objects with more than `items` keys
+ * are cut the same way. Objects JSON shows as `{}` (maps, sets, regular
+ * expressions) are described instead.
+ *
+ * @throws Whatever `JSON.stringify` throws: callers catch it.
+ */
+const nativeJson = (value, limits) => {
+    if (isKeyedObject(value) && countKeys(value, limits.items) > limits.items)
+        return cutObject(value, limits.stringLength, limits, NO_ANCESTORS);
+    const text$1 = JSON.stringify(value);
+    if (text$1 === undefined)
+        return undefined;
+    if (text$1 === '{}') {
+        const described = text.describeObject(value, limits);
+        if (described !== undefined)
+            return quoteLimited(described, limits);
+    }
+    return text$1.length > limits.stringLength ?
+        cutJson(value, limits.stringLength, limits, NO_ANCESTORS)
+        : text$1;
+};
+/**
+ * Prototypes whose instances native JSON serializes completely, as long as
+ * their own values do: plain objects, null-prototype objects, arrays, dates.
+ */
+const isPlainPrototype = (proto) => proto === Object.prototype ||
+    proto === null ||
+    proto === Array.prototype ||
+    proto === Date.prototype;
+/**
+ * A property value native JSON serializes the same as the walk does, within
+ * the limits. One cheap check per value of the logged data, so ordinary data
+ * keeps the speed of a single native `JSON.stringify`.
+ */
+const isNativeSafe = (value, limits) => {
+    switch (typeof value) {
+        case 'string':
+            return value.length <= limits.stringLength;
+        case 'number':
+        case 'boolean':
+        case 'undefined':
+            return true;
+        case 'object':
+            return (value === null ||
+                (isPlainPrototype(Object.getPrototypeOf(value)) &&
+                    !(Array.isArray(value) && value.length > limits.items)));
+        default:
+            // bigint (native JSON throws), function and symbol (left out)
+            return false;
+    }
+};
+/**
+ * Data whose values are all native safe: one native `JSON.stringify`.
+ * `undefined` when a value is not, or reading or serializing throws
+ * (circular structures, throwing getters, revoked proxies, nested bigints),
+ * or the text exceeds `stringLength`: the data is walked instead.
+ */
+const tryNative = (data, isArray, limits) => {
+    try {
+        if (isArray) {
+            const array = data;
+            const { length } = array;
+            if (length > limits.items)
+                return undefined;
+            for (let index = 0; index < length; index++)
+                if (!isNativeSafe(array[index], limits))
+                    return undefined;
+        }
+        else {
+            let count = 0;
+            for (const key in data)
+                if (++count > limits.items ||
+                    !isNativeSafe(data[key], limits))
+                    return undefined;
+        }
+        const text = JSON.stringify(data);
+        if (text.length > limits.stringLength)
+            return undefined;
+        // a key takes at least 5 characters (`"":0,`): shorter text can't hold
+        // an object with more than `items` keys, so ordinary data skips the scan
+        if (text.length > MIN_KEY_LENGTH * limits.items &&
+            hasLongObject(data, isArray, limits))
+            return undefined;
+        return text;
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Shortest JSON of an object key with its value and separator: `"":0,`.
+ */
+const MIN_KEY_LENGTH = 5;
+/**
+ * Whether a value of the data (one level deep, like errors) is an object
+ * with more than `items` keys, which native JSON would write whole.
+ */
+const hasLongObject = (data, isArray, limits) => {
+    const isLong = (value) => isKeyedObject(value) && countKeys(value, limits.items) > limits.items;
+    if (isArray) {
+        for (const value of data)
+            if (isLong(value))
+                return true;
+        return false;
+    }
+    // no Object.values: it allocates an array per log
+    for (const key in data)
+        if (isLong(data[key]))
+            return true;
+    return false;
+};
+/**
+ * JSON of a property, element or error property. A throwing getter gives a
+ * placeholder, so one bad property doesn't hide the others.
+ */
+const readProperty = (data, key, depth, limits) => {
+    let value;
+    try {
+        value = data[key];
+    }
+    catch (thrown) {
+        return placeholder('Getter threw', thrown, limits);
+    }
+    return stringifyValue(value, depth, limits);
+};
+/**
+ * Logged data that is an array: each element serialized on its own (errors,
+ * binary data, ...), at most `items`, then a `"… N more items"` element.
+ */
+const walkArray = (array, limits) => {
+    const shown = Math.min(array.length, limits.items);
+    let text$1 = '';
+    for (let index = 0; index < shown; index++)
+        text$1 += `${index ? ',' : ''}${readProperty(array, index, PROPERTY, limits) ?? 'null'}`;
+    if (array.length > shown)
+        text$1 += `,${quote(text.describeLeftOut(array.length - shown, 'item'))}`;
+    return `[${text$1}]`;
+};
+/**
+ * Logged data that is an object: own enumerable keys (like JSON), each value
+ * serialized on its own, at most `items` keys, then `"…": "… N more items"`.
+ * A throwing getter gives a placeholder and the other keys still render.
+ */
+const walkObject = (data, limits) => {
+    if (typeof data.toJSON === 'function')
+        return nativeJson(data, limits);
+    const keys = Object.keys(data);
+    const shown = Math.min(keys.length, limits.items);
+    let text$1 = '';
+    for (let index = 0; index < shown; index++) {
+        const key = keys[index] ?? '';
+        text$1 = appendProperty(text$1, quoteLimited(key, limits), readProperty(data, key, PROPERTY, limits));
+    }
+    if (keys.length > shown)
+        text$1 = appendProperty(text$1, '"…"', quote(text.describeLeftOut(keys.length - shown, 'item')));
+    return `{${text$1}}`;
+};
+/**
+ * A property or element that is an array: longer than `items`, its first
+ * `items` elements (native JSON) and a `"… N more items"` element, without
+ * serializing the rest.
+ */
+const limitArray = (array, limits) => {
+    if (array.length <= limits.items)
+        return nativeJson(array, limits);
+    const head = JSON.stringify(array.slice(0, limits.items));
+    const text$1 = `${head.slice(0, -1)},${quote(text.describeLeftOut(array.length - limits.items, 'item'))}]`;
+    return text$1.length > limits.stringLength ?
+        cutArray(array, limits.stringLength, limits, NO_ANCESTORS)
+        : text$1;
+};
+/**
+ * Error properties written first (or last, `cause`), not repeated when an
+ * error makes them enumerable.
+ */
+const ERROR_KEYS = new Set(['name', 'message', 'stack', 'cause']);
+const isErrorLike = (value) => value instanceof Error ||
+    (typeof value === 'object' && value !== null && text.isForeignError(value));
+/**
+ * `{"name","message","stack",...own enumerable properties,"cause"}`. Name,
+ * message and stack are not enumerable, so native JSON drops them. Each part
+ * is read on its own: an unreadable one gives a placeholder, the others
+ * still render.
+ *
+ * @param chain Errors this one is the cause of, outermost first.
+ */
+const stringifyError = (error, chain, limits) => {
+    let text$1 = appendProperty('', '"name"', readProperty(error, 'name', LEAF, limits));
+    text$1 = appendProperty(text$1, '"message"', readProperty(error, 'message', LEAF, limits));
+    text$1 = appendProperty(text$1, '"stack"', readProperty(error, 'stack', LEAF, limits));
+    let keys = [];
+    try {
+        keys = Object.keys(error).filter((key) => !ERROR_KEYS.has(key));
+    }
+    catch {
+        // keys of a throwing proxy are left out; name, message and stack stay
+    }
+    const shown = Math.min(keys.length, limits.items);
+    for (let index = 0; index < shown; index++) {
+        const key = keys[index] ?? '';
+        text$1 = appendProperty(text$1, quoteLimited(key, limits), readProperty(error, key, LEAF, limits));
+    }
+    if (keys.length > shown)
+        text$1 = appendProperty(text$1, '"…"', quote(text.describeLeftOut(keys.length - shown, 'item')));
+    let cause;
+    try {
+        if (!Object.hasOwn(error, 'cause'))
+            return `{${text$1}}`;
+        cause = error.cause;
+    }
+    catch (thrown) {
+        return `{${appendProperty(text$1, '"cause"', placeholder('Getter threw', thrown, limits))}}`;
+    }
+    const json = !isErrorLike(cause) ? stringifyValue(cause, LEAF, limits)
+        : cause === error || chain.includes(cause) ? '"[Circular]"'
+            : chain.length < MAX_CAUSES ?
+                stringifyError(cause, [...chain, error], limits)
+                : quoteLimited(text.describeThrown(cause), limits);
+    return `{${appendProperty(text$1, '"cause"', json)}}`;
+};
+/**
+ * Native JSON of a nested array or object, or, when native JSON throws (a
+ * circular element, a throwing getter, a nested bigint), the same value cut
+ * element by element: the bad element becomes a placeholder and the value
+ * keeps its type.
+ */
+const keepingType = (native, value, limits) => {
+    try {
+        return native();
+    }
+    catch {
+        return cutJson(value, limits.stringLength, limits, NO_ANCESTORS);
+    }
+};
+const stringifyObject = (value, depth, limits) => {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null)
+        return depth === DATA ?
+            (tryNative(value, false, limits) ?? walkObject(value, limits))
+            : keepingType(() => nativeJson(value, limits), value, limits);
+    if (Array.isArray(value))
+        return depth === DATA ?
+            (tryNative(value, true, limits) ?? walkArray(value, limits))
+            : keepingType(() => limitArray(value, limits), value, limits);
+    if (value instanceof Error || text.isForeignError(value))
+        return depth === LEAF ?
+            quoteLimited(text.describeThrown(value), limits)
+            : stringifyError(value, NO_CAUSES, limits);
+    if (ArrayBuffer.isView(value))
+        return quoteLimited(text.describeBinary(value, limits.items), limits);
+    // dates, class instances, maps, sets, ...
+    return nativeJson(value, limits);
+};
+/**
+ * JSON of a value, or `undefined` for values JSON leaves out.
+ */
+const stringifyValue = (value, depth, limits) => {
+    try {
+        switch (typeof value) {
+            case 'string':
+                return value.length > limits.stringLength ?
+                    quoteLimited(value, limits)
+                    : quote(value);
+            case 'number':
+                return Number.isFinite(value) ? String(value) : 'null';
+            case 'boolean':
+                return value ? 'true' : 'false';
+            case 'bigint':
+                // a JSON number with every digit; `JSON.parse` rounds large ones
+                return String(value);
+            case 'undefined':
+                return undefined;
+            case 'function':
+                return quote(text.describeFunction(value));
+            case 'symbol':
+                return quoteLimited(String(value), limits);
+            default:
+                // objects: the remaining type
+                return value === null ? 'null' : (stringifyObject(value, depth, limits));
+        }
+    }
+    catch (thrown) {
+        return placeholder('Unserializable', thrown, limits);
+    }
+};
+/**
+ * Serializes logged data to JSON text. Never throws, and always returns
+ * valid JSON (or `undefined`, like `JSON.stringify`, for `undefined`):
+ * - ordinary data is one native `JSON.stringify`;
+ * - errors, also as property values and from other realms:
+ *   `{"name","message","stack",...own properties,"cause"}`, causes up to 5
+ *   deep;
+ * - buffers and typed arrays: a one-line description (`describeBinary`);
+ * - bigints: JSON numbers with every digit; functions and symbols:
+ *   `"[Function: name]"`, `"Symbol(x)"`, never source code;
+ * - maps, sets and regular expressions: a description (`describeObject`);
+ * - strings longer than `stringLength`: cut, with `… N more characters`;
+ * - arrays and objects longer than `items` (the data and its direct
+ *   properties): the first `items` and `"… N more items"`;
+ * - arrays and objects whose JSON is longer than `stringLength`: cut
+ *   structurally, keeping their type (`cutJson`);
+ * - throwing getters and revoked proxies: placeholder strings; circular
+ *   references: `"[Circular]"`; the rest of the data still renders and
+ *   keeps its type.
+ *
+ * Errors, binary data, bigints, functions and long arrays are found one
+ * level deep only: in the data and in its direct properties (`{ err }`).
+ * This is for performance: ordinary data is one native `JSON.stringify`,
+ * and a walker for every object would slow down all logs. Deeper ones get
+ * native JSON, so a deeper error keeps only its own enumerable properties
+ * (`{ request: { err } }` loses message and stack).
+ *
+ * @param limits Output limits. Default: `DEFAULT_OUTPUT_LIMITS`.
+ */
+const renderJsonData = (data, limits = text.DEFAULT_OUTPUT_LIMITS) => stringifyValue(data, DATA, limits);
+const epochTime = (time, timeNs) => timeNs === undefined ?
+    String(time)
+    : `${String(time)},"ns":${String(timeNs)}`;
+/**
+ * ISO 8601 in UTC, through the timestamp compiler: the text up to the
+ * seconds is cached per second.
+ */
+const createIsoTime = () => {
+    const milliseconds = time.compileTimestamp('["]YYYY-MM-DD[T]HH:mm:ss.SSS[Z"]', {
+        utc: true,
+    });
+    const nanoseconds = time.compileTimestamp('["]YYYY-MM-DD[T]HH:mm:ss.SSSSSSSSS[Z"]', {
+        utc: true,
+    });
+    return (time, timeNs) => timeNs === undefined ? milliseconds(time, 0) : nanoseconds(time, timeNs);
+};
+const createTimeFormatter = (time) => {
+    if (time === false)
+        return undefined;
+    if (time === undefined || time === 'iso')
+        return createIsoTime();
+    if (time === 'epoch')
+        return epochTime;
+    throw new RangeError(`jsonPlugin: time must be 'iso', 'epoch' or false, got ${typeof time === 'string' ? `'${time}'` : typeof time}.`);
+};
+const DEL_C1 = /[\x7F-\x9F]/;
+const DEL_C1_ALL = /[\x7F-\x9F]/g;
+const escapeControl = (char) => `\\u00${char.charCodeAt(0).toString(16)}`;
+/**
+ * Escapes DEL and C1 controls. They can only be inside JSON strings (the
+ * rest of a line is printable ASCII), where `\u00XX` is the same character.
+ */
+const escapeControls = (line) => DEL_C1.test(line) ? line.replace(DEL_C1_ALL, escapeControl) : line;
+const keepLine = (line) => line;
+/**
+ * JSON line of an entry: `id`, `time` (from `timestamp`), `type`, `kind`
+ * (only with `writeKind`), `data`, then properties added by transformers.
+ * The known properties are collected and joined by one template, which is
+ * faster than appending property by property.
+ */
+const renderJsonLine = (entry, time, ownKind, limits) => {
+    let id;
+    let type;
+    let kind;
+    let data;
+    let timed = false;
+    let extra = '';
+    for (const key in entry)
+        switch (key) {
+            case 'id':
+                id = stringifyValue(entry[key], DATA, limits);
+                break;
+            case 'timestamp':
+                timed = true;
+                break;
+            case 'type': {
+                const value = entry[key];
+                // log types need no escaping: skips a native call per log
+                type =
+                    (typeof value === 'string' &&
+                        typeof levels.LOG_TYPE_VALUES[value] === 'number') ?
+                        `"${value}"`
+                        : stringifyValue(value, DATA, limits);
+                break;
+            }
+            case 'kind':
+                if (ownKind !== undefined)
+                    kind =
+                        entry[key] === ownKind.name ?
+                            ownKind.json
+                            : stringifyValue(entry[key], DATA, limits);
+                break;
+            case 'data':
+                data = stringifyValue(entry[key], DATA, limits);
+                break;
+            default:
+                extra = appendProperty(extra, quote(key), stringifyValue(entry[key], DATA, limits));
+        }
+    if (!timed)
+        time = undefined;
+    if (id !== undefined && type !== undefined && data !== undefined) {
+        const typed = kind === undefined ? type : `${type},"kind":${kind}`;
+        return time === undefined ?
+            `{"id":${id},"type":${typed},"data":${data}${extra && `,${extra}`}}`
+            : `{"id":${id},"time":${time},"type":${typed},"data":${data}${extra && `,${extra}`}}`;
+    }
+    // properties removed by transformers or `undefined` data
+    let text = appendProperty('', '"id"', id);
+    text = appendProperty(text, '"time"', time);
+    text = appendProperty(text, '"type"', type);
+    text = appendProperty(text, '"kind"', kind);
+    text = appendProperty(text, '"data"', data);
+    return `{${text}${text && extra ? ',' : ''}${extra}}`;
+};
+/**
+ * Writes logs of a given kind as JSON lines (NDJSON) and, by default, makes
+ * that kind the logger's default, so `logger.info({ user: 'alice' })`
+ * writes:
+ *
+ * ```
+ * {"id":1,"time":"2026-03-16T15:35:00.000Z","type":"info","data":{"user":"alice"}}
+ * ```
+ *
+ * Logging never throws because of the data; see `renderJsonData`. Errors of
+ * `write` propagate.
+ *
+ * @throws RangeError if `time` or `limits` are invalid.
+ * @throws TypeError if `write` is not a function.
+ */
+const jsonPlugin = (options = {}) => {
+    const kind = options.kind ?? 'json';
+    const limits = text.resolveOutputLimits(options.limits, 'jsonPlugin');
+    const formatTime = createTimeFormatter(options.time);
+    const escape = options.escapeControls === true ? escapeControls : keepLine;
+    // quoted once: the output only receives its own kind (unless a
+    // transformer changes it)
+    const ownKind = options.writeKind === true ? { name: kind, json: quote(kind) } : undefined;
+    // checked for untyped callers: it would otherwise throw on the first log
+    const write = options.write ?? console.log;
+    if (typeof write !== 'function')
+        throw new TypeError(`jsonPlugin: write is not a function, got ${write === null ? 'null' : typeof write}.`);
+    const writeLine = write;
+    return {
+        name: `json:${kind}`,
+        ...((options.setAsDefault ?? true) && { defaultKind: kind }),
+        outputs: {
+            [kind]: (entry, { time, timeNs }) => {
+                writeLine(escape(renderJsonLine(entry, time === undefined || formatTime === undefined ?
+                    undefined
+                    : formatTime(time, timeNs), ownKind, limits)));
+            },
+        },
+    };
+};
+
+exports.jsonPlugin = jsonPlugin;
+exports.renderJsonData = renderJsonData;
+//# sourceMappingURL=json.cjs.map