@socketsecurity/lib 6.0.5 → 6.0.7

package/dist/logger/console-methods.d.ts

@@ -0,0 +1,132 @@
+/**
+ * @file Free-function bodies for the `Logger` methods that are thin, chainable
+ *   mirrors of the underlying `node:console` API (`assert`, `count`, `dir`,
+ *   `dirxml`, `table`, `time`, `timeEnd`, `timeLog`, `trace`). Each takes the
+ *   calling logger plus its already-resolved `node:console` instance, delegates
+ *   to the matching console method, updates the shared blank-line / call-count
+ *   tracking via the exported logger symbols, and returns the logger for
+ *   chaining. Pulling these out of `./node` keeps the `Logger` class body under
+ *   the file-size cap while preserving the per-method documentation here. The
+ *   class retains one-line delegators that supply `this` and
+ *   `this.#getConsole()`.
+ */
+import { incLogCallCountSymbol, lastWasBlankSymbol } from './symbols';
+/**
+ * The slice of `node:console` the mirror methods call into, plus the internal
+ * `_stderr` / `_stdout` slots reached elsewhere. Modeled structurally so the
+ * cast from the lazily-built per-instance Console stays explicit.
+ */
+export type ConsoleLike = typeof console & Record<string, unknown>;
+/**
+ * The slice of `Logger` the mirror methods need: the two symbol-keyed tracking
+ * methods. Typed structurally to avoid a circular import with `./node`.
+ */
+export interface LoggerTrackable {
+    [incLogCallCountSymbol](): LoggerTrackable;
+    [lastWasBlankSymbol](value: unknown, stream?: 'stderr' | 'stdout'): unknown;
+}
+/**
+ * Logs an assertion failure message if the value is falsy.
+ *
+ * Works like `console.assert()` but returns the logger for chaining. If the
+ * value is truthy, nothing is logged. If falsy, logs an error message with an
+ * assertion failure.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param value - The value to test.
+ * @param message - Optional message and additional arguments to log.
+ */
+export declare function assertMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, value: unknown, message: unknown[]): T;
+/**
+ * Increments and logs a counter for the given label.
+ *
+ * Each unique label maintains its own counter. Works like `console.count()`.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param label - Optional label for the counter (defaults to 'default').
+ */
+export declare function countMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, label?: string | undefined): T;
+/**
+ * Displays an object's properties in a formatted way.
+ *
+ * Works like `console.dir()` with customizable options for depth, colors, etc.
+ * Useful for inspecting complex objects.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param obj - The object to display.
+ * @param options - Optional formatting options (Node.js inspect options).
+ */
+export declare function dirMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, obj: unknown, options?: unknown | undefined): T;
+/**
+ * Displays data as XML/HTML in a formatted way.
+ *
+ * Works like `console.dirxml()`. In Node.js, behaves the same as `dir()`.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param data - The data to display.
+ */
+export declare function dirxmlMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, data: unknown[]): T;
+/**
+ * Displays data in a table format.
+ *
+ * Works like `console.table()`. Accepts arrays of objects or objects with
+ * nested objects. Optionally specify which properties to include in the table.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param tabularData - The data to display as a table.
+ * @param properties - Optional array of property names to include.
+ */
+export declare function tableMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, tabularData: unknown, properties?: readonly string[] | undefined): T;
+/**
+ * Ends a timer and logs the elapsed time.
+ *
+ * Logs the duration since `console.time()` or `logger.time()` was called with
+ * the same label. The timer is stopped and removed.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param label - Optional label for the timer (defaults to 'default').
+ */
+export declare function timeEndMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, label?: string | undefined): T;
+/**
+ * Logs the current value of a timer without stopping it.
+ *
+ * Logs the duration since `console.time()` was called with the same label, but
+ * keeps the timer running. Can include additional data to log alongside the
+ * time.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param label - Optional label for the timer (defaults to 'default').
+ * @param data - Additional data to log with the time.
+ */
+export declare function timeLogMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, label: string | undefined, data: unknown[]): T;
+/**
+ * Starts a timer for measuring elapsed time.
+ *
+ * Creates a timer with the given label. Use `timeEnd()` with the same label to
+ * stop the timer and log the elapsed time, or use `timeLog()` to check the time
+ * without stopping the timer.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param label - Optional label for the timer (defaults to 'default').
+ */
+export declare function timeMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, label?: string | undefined): T;
+/**
+ * Logs a stack trace to the console.
+ *
+ * Works like `console.trace()`. Shows the call stack leading to where this
+ * method was called. Useful for debugging.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param message - Optional message to display with the trace.
+ * @param args - Additional arguments to log.
+ */
+export declare function traceMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, message: unknown | undefined, args: unknown[]): T;

package/dist/logger/console-methods.js

@@ -0,0 +1,169 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_logger_symbols = require('./symbols.js');
+
+//#region src/logger/console-methods.ts
+/**
+* @file Free-function bodies for the `Logger` methods that are thin, chainable
+*   mirrors of the underlying `node:console` API (`assert`, `count`, `dir`,
+*   `dirxml`, `table`, `time`, `timeEnd`, `timeLog`, `trace`). Each takes the
+*   calling logger plus its already-resolved `node:console` instance, delegates
+*   to the matching console method, updates the shared blank-line / call-count
+*   tracking via the exported logger symbols, and returns the logger for
+*   chaining. Pulling these out of `./node` keeps the `Logger` class body under
+*   the file-size cap while preserving the per-method documentation here. The
+*   class retains one-line delegators that supply `this` and
+*   `this.#getConsole()`.
+*/
+/**
+* Logs an assertion failure message if the value is falsy.
+*
+* Works like `console.assert()` but returns the logger for chaining. If the
+* value is truthy, nothing is logged. If falsy, logs an error message with an
+* assertion failure.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param value - The value to test.
+* @param message - Optional message and additional arguments to log.
+*/
+function assertMethod(logger, con, value, message) {
+	con.assert(value, message[0], ...message.slice(1));
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return value ? logger : logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Increments and logs a counter for the given label.
+*
+* Each unique label maintains its own counter. Works like `console.count()`.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param label - Optional label for the counter (defaults to 'default').
+*/
+function countMethod(logger, con, label) {
+	con.count(label);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Displays an object's properties in a formatted way.
+*
+* Works like `console.dir()` with customizable options for depth, colors, etc.
+* Useful for inspecting complex objects.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param obj - The object to display.
+* @param options - Optional formatting options (Node.js inspect options).
+*/
+function dirMethod(logger, con, obj, options) {
+	con.dir(obj, options);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Displays data as XML/HTML in a formatted way.
+*
+* Works like `console.dirxml()`. In Node.js, behaves the same as `dir()`.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param data - The data to display.
+*/
+function dirxmlMethod(logger, con, data) {
+	con.dirxml(data);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Displays data in a table format.
+*
+* Works like `console.table()`. Accepts arrays of objects or objects with
+* nested objects. Optionally specify which properties to include in the table.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param tabularData - The data to display as a table.
+* @param properties - Optional array of property names to include.
+*/
+function tableMethod(logger, con, tabularData, properties) {
+	con.table(tabularData, properties);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Ends a timer and logs the elapsed time.
+*
+* Logs the duration since `console.time()` or `logger.time()` was called with
+* the same label. The timer is stopped and removed.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param label - Optional label for the timer (defaults to 'default').
+*/
+function timeEndMethod(logger, con, label) {
+	con.timeEnd(label);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Logs the current value of a timer without stopping it.
+*
+* Logs the duration since `console.time()` was called with the same label, but
+* keeps the timer running. Can include additional data to log alongside the
+* time.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param label - Optional label for the timer (defaults to 'default').
+* @param data - Additional data to log with the time.
+*/
+function timeLogMethod(logger, con, label, data) {
+	con.timeLog(label, ...data);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Starts a timer for measuring elapsed time.
+*
+* Creates a timer with the given label. Use `timeEnd()` with the same label to
+* stop the timer and log the elapsed time, or use `timeLog()` to check the time
+* without stopping the timer.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param label - Optional label for the timer (defaults to 'default').
+*/
+function timeMethod(logger, con, label) {
+	con.time(label);
+	return logger;
+}
+/**
+* Logs a stack trace to the console.
+*
+* Works like `console.trace()`. Shows the call stack leading to where this
+* method was called. Useful for debugging.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param message - Optional message to display with the trace.
+* @param args - Additional arguments to log.
+*/
+function traceMethod(logger, con, message, args) {
+	con.trace(message, ...args);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+
+//#endregion
+exports.assertMethod = assertMethod;
+exports.countMethod = countMethod;
+exports.dirMethod = dirMethod;
+exports.dirxmlMethod = dirxmlMethod;
+exports.tableMethod = tableMethod;
+exports.timeEndMethod = timeEndMethod;
+exports.timeLogMethod = timeLogMethod;
+exports.timeMethod = timeMethod;
+exports.traceMethod = traceMethod;

package/dist/logger/console.d.ts

@@ -19,6 +19,7 @@
  *     `ensurePrototypeInitialized` actually runs, both modules are fully
  *     evaluated. Same pattern as `fs/path-cache` ↔ `fs/_internal`.
  */
+import { Logger } from './node';
 /**
  * Construct a new Console instance.
  */
@@ -31,3 +32,14 @@ export declare function constructConsole(...args: unknown[]): Console;
  * ready.
  */
 export declare function ensurePrototypeInitialized(): void;
+/**
+ * Resolve (and lazily construct + cache) the per-instance `Console` for a
+ * logger. Ensures the prototype is initialized, then returns the cached Console
+ * from the `privateConsole` WeakMap, building one from the stored constructor
+ * args (or the default stdout/stderr pair) on first access. This lazy path is
+ * what lets the logger be imported during early Node.js bootstrap before stdout
+ * is ready, avoiding `ERR_CONSOLE_WRITABLE_STREAM`.
+ *
+ * @param logger - The logger whose Console to resolve.
+ */
+export declare function resolveConsole(logger: Logger): typeof console & Record<string, unknown>;

package/dist/logger/console.js

@@ -32,16 +32,15 @@ node_process = require_runtime.__toESM(node_process);
 *     `ensurePrototypeInitialized` actually runs, both modules are fully
 *     evaluated. Same pattern as `fs/path-cache` ↔ `fs/_internal`.
 */
-let _Console;
-let _prototypeInitialized = false;
+let cachedConsole;
+let prototypeInitialized = false;
 /**
 * Construct a new Console instance.
 */
-/* @__NO_SIDE_EFFECTS__ */
 function constructConsole(...args) {
 	/* c8 ignore next - Lazy-init second-call branch; module-singleton. */
-	if (_Console === void 0) _Console = (/* @__PURE__ */ require("node:console")).Console;
-	return require_primordials_reflect.ReflectConstruct(_Console, args);
+	if (cachedConsole === void 0) cachedConsole = (/* @__PURE__ */ require("node:console")).Console;
+	return require_primordials_reflect.ReflectConstruct(cachedConsole, args);
 }
 /**
 * Lazily add dynamic console methods to Logger prototype.
@@ -51,8 +50,8 @@ function constructConsole(...args) {
 * ready.
 */
 function ensurePrototypeInitialized() {
-	if (_prototypeInitialized) return;
-	_prototypeInitialized = true;
+	if (prototypeInitialized) return;
+	prototypeInitialized = true;
 	const entries = [[require_logger_symbols.getKGroupIndentationWidthSymbol(), {
 		...require_logger__internal.consolePropAttributes,
 		value: 2
@@ -68,9 +67,9 @@ function ensurePrototypeInitialized() {
 			if (con === void 0) {
 				const ctorArgs = require_logger__internal.privateConstructorArgs.get(this) ?? [];
 				require_logger__internal.privateConstructorArgs.delete(this);
-				if (ctorArgs.length) con = /* @__PURE__ */ constructConsole(...ctorArgs);
+				if (ctorArgs.length) con = constructConsole(...ctorArgs);
 				else {
-					con = /* @__PURE__ */ constructConsole({
+					con = constructConsole({
 						stdout: node_process.default.stdout,
 						stderr: node_process.default.stderr
 					});
@@ -78,7 +77,6 @@ function ensurePrototypeInitialized() {
 				}
 				require_logger__internal.privateConsole.set(this, con);
 			}
-			/* c8 ignore stop */
 			const result = con[key](...args);
 			/* c8 ignore next */
 			return result === void 0 || result === con ? this : result;
@@ -90,7 +88,40 @@ function ensurePrototypeInitialized() {
 	}
 	require_primordials_object.ObjectDefineProperties(require_logger_node.Logger.prototype, require_primordials_object.ObjectFromEntries(entries));
 }
+/**
+* Resolve (and lazily construct + cache) the per-instance `Console` for a
+* logger. Ensures the prototype is initialized, then returns the cached Console
+* from the `privateConsole` WeakMap, building one from the stored constructor
+* args (or the default stdout/stderr pair) on first access. This lazy path is
+* what lets the logger be imported during early Node.js bootstrap before stdout
+* is ready, avoiding `ERR_CONSOLE_WRITABLE_STREAM`.
+*
+* @param logger - The logger whose Console to resolve.
+*/
+function resolveConsole(logger) {
+	ensurePrototypeInitialized();
+	let con = require_logger__internal.privateConsole.get(logger);
+	/* c8 ignore start - ctorArgs.length-truthy fires when caller seeded
+	constructor args; both arms are exercised across tests but not always
+	in the same run. */
+	if (!con) {
+		const ctorArgs = require_logger__internal.privateConstructorArgs.get(logger) ?? [];
+		if (ctorArgs.length) con = constructConsole(...ctorArgs);
+		else {
+			con = constructConsole({
+				stdout: node_process.default.stdout,
+				stderr: node_process.default.stderr
+			});
+			for (const { 0: key, 1: method } of require_logger__internal.boundConsoleEntries) con[key] = method;
+		}
+		require_logger__internal.privateConsole.set(logger, con);
+		require_logger__internal.privateConstructorArgs.delete(logger);
+	}
+	/* c8 ignore stop */
+	return con;
+}
 
 //#endregion
 exports.constructConsole = constructConsole;
-exports.ensurePrototypeInitialized = ensurePrototypeInitialized;
+exports.ensurePrototypeInitialized = ensurePrototypeInitialized;
+exports.resolveConsole = resolveConsole;

package/dist/logger/indentation-methods.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @file Free-function bodies for the `Logger` indentation-domain methods
+ *   (`indent`, `dedent`, `resetIndent`, `group`, `groupCollapsed`, `groupEnd`).
+ *   Indentation is tracked at the prefix layer (a per-stream string of spaces)
+ *   rather than via `node:console`'s frozen `Symbol(kGroupIndent)`, so these
+ *   helpers read and write that prefix through a small accessor context handed
+ *   in by the calling `Logger`. Pulling these out of `./node` keeps the
+ *   `Logger` class body under the file-size cap; the class retains one-line
+ *   delegators that build the context from its private state.
+ */
+import type { LoggerTrackable } from './console-methods';
+/**
+ * The slice of `Logger` the indentation helpers need: the bound-stream marker
+ * (`undefined` on the root logger, `'stderr'` / `'stdout'` on a stream-bound
+ * instance) plus per-stream indent prefix read / write accessors. Modeled
+ * structurally to avoid a circular import with `./node`; the class supplies
+ * closures over its private `#getIndent` / `#setIndent`.
+ */
+export interface IndentContext {
+    boundStream: 'stderr' | 'stdout' | undefined;
+    getIndent(stream: 'stderr' | 'stdout'): string;
+    setIndent(stream: 'stderr' | 'stdout', value: string): void;
+}
+/**
+ * Decrease the indentation prefix by `spaces`.
+ *
+ * On the root logger (`boundStream` undefined) both streams shrink; on a
+ * stream-bound logger only the bound stream shrinks. Returns the logger for
+ * chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param ctx - The logger's indentation accessor context.
+ * @param spaces - Number of spaces to remove (default 2).
+ */
+export declare function dedentMethod<T extends LoggerTrackable>(logger: T, ctx: IndentContext, spaces: number): T;
+/**
+ * End the current log group and decrease indentation by the group-indent width.
+ *
+ * Call once per `groupMethod` / `groupCollapsed`. Returns the logger for
+ * chaining.
+ *
+ * @param logger - The calling logger instance.
+ */
+export declare function groupEndMethod<T extends {
+    dedent(spaces?: number): T;
+}>(logger: T): T;
+/**
+ * Start a new indented log group.
+ *
+ * A provided label is logged via the logger's own `log` before indentation
+ * increases by the group-indent width (default 2). Groups nest; close with
+ * `groupEndMethod`. Returns the logger for chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param label - Optional label to display before the group.
+ */
+export declare function groupMethod<T extends LoggerTrackable & {
+    indent(spaces?: number): T;
+    log(...args: unknown[]): T;
+}>(logger: T, label: unknown[]): T;
+/**
+ * Increase the indentation prefix by `spaces`, capped at `maxIndentation`.
+ *
+ * On the root logger both streams grow; on a stream-bound logger only the bound
+ * stream grows. Returns the logger for chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param ctx - The logger's indentation accessor context.
+ * @param spaces - Number of spaces to add (default 2).
+ */
+export declare function indentMethod<T extends LoggerTrackable>(logger: T, ctx: IndentContext, spaces: number): T;
+/**
+ * Reset all indentation to zero.
+ *
+ * On the root logger both streams reset; on a stream-bound logger only the
+ * bound stream resets. Returns the logger for chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param ctx - The logger's indentation accessor context.
+ */
+export declare function resetIndentMethod<T extends LoggerTrackable>(logger: T, ctx: IndentContext): T;

package/dist/logger/indentation-methods.js

@@ -0,0 +1,121 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_math = require('../primordials/math.js');
+const require_primordials_reflect = require('../primordials/reflect.js');
+const require_logger__internal = require('./_internal.js');
+const require_logger_symbols = require('./symbols.js');
+
+//#region src/logger/indentation-methods.ts
+/**
+* @file Free-function bodies for the `Logger` indentation-domain methods
+*   (`indent`, `dedent`, `resetIndent`, `group`, `groupCollapsed`, `groupEnd`).
+*   Indentation is tracked at the prefix layer (a per-stream string of spaces)
+*   rather than via `node:console`'s frozen `Symbol(kGroupIndent)`, so these
+*   helpers read and write that prefix through a small accessor context handed
+*   in by the calling `Logger`. Pulling these out of `./node` keeps the
+*   `Logger` class body under the file-size cap; the class retains one-line
+*   delegators that build the context from its private state.
+*/
+/**
+* Decrease the indentation prefix by `spaces`.
+*
+* On the root logger (`boundStream` undefined) both streams shrink; on a
+* stream-bound logger only the bound stream shrinks. Returns the logger for
+* chaining.
+*
+* @param logger - The calling logger instance.
+* @param ctx - The logger's indentation accessor context.
+* @param spaces - Number of spaces to remove (default 2).
+*/
+function dedentMethod(logger, ctx, spaces) {
+	if (ctx.boundStream) {
+		const current = ctx.getIndent(ctx.boundStream);
+		ctx.setIndent(ctx.boundStream, current.slice(0, -spaces));
+	} else {
+		const stderrCurrent = ctx.getIndent("stderr");
+		const stdoutCurrent = ctx.getIndent("stdout");
+		ctx.setIndent("stderr", stderrCurrent.slice(0, -spaces));
+		ctx.setIndent("stdout", stdoutCurrent.slice(0, -spaces));
+	}
+	return logger;
+}
+/**
+* End the current log group and decrease indentation by the group-indent width.
+*
+* Call once per `groupMethod` / `groupCollapsed`. Returns the logger for
+* chaining.
+*
+* @param logger - The calling logger instance.
+*/
+function groupEndMethod(logger) {
+	logger.dedent(logger[require_logger_symbols.getKGroupIndentationWidthSymbol()]);
+	return logger;
+}
+/**
+* Start a new indented log group.
+*
+* A provided label is logged via the logger's own `log` before indentation
+* increases by the group-indent width (default 2). Groups nest; close with
+* `groupEndMethod`. Returns the logger for chaining.
+*
+* @param logger - The calling logger instance.
+* @param label - Optional label to display before the group.
+*/
+function groupMethod(logger, label) {
+	const { length } = label;
+	if (length) require_primordials_reflect.ReflectApply(logger.log, logger, label);
+	logger.indent(logger[require_logger_symbols.getKGroupIndentationWidthSymbol()]);
+	if (length) {
+		logger[require_logger_symbols.lastWasBlankSymbol](false);
+		logger[require_logger_symbols.incLogCallCountSymbol]();
+	}
+	return logger;
+}
+/**
+* Increase the indentation prefix by `spaces`, capped at `maxIndentation`.
+*
+* On the root logger both streams grow; on a stream-bound logger only the bound
+* stream grows. Returns the logger for chaining.
+*
+* @param logger - The calling logger instance.
+* @param ctx - The logger's indentation accessor context.
+* @param spaces - Number of spaces to add (default 2).
+*/
+function indentMethod(logger, ctx, spaces) {
+	const spacesToAdd = " ".repeat(require_primordials_math.MathMin(spaces, require_logger__internal.maxIndentation));
+	if (ctx.boundStream) {
+		const current = ctx.getIndent(ctx.boundStream);
+		ctx.setIndent(ctx.boundStream, current + spacesToAdd);
+	} else {
+		const stderrCurrent = ctx.getIndent("stderr");
+		const stdoutCurrent = ctx.getIndent("stdout");
+		ctx.setIndent("stderr", stderrCurrent + spacesToAdd);
+		ctx.setIndent("stdout", stdoutCurrent + spacesToAdd);
+	}
+	return logger;
+}
+/**
+* Reset all indentation to zero.
+*
+* On the root logger both streams reset; on a stream-bound logger only the
+* bound stream resets. Returns the logger for chaining.
+*
+* @param logger - The calling logger instance.
+* @param ctx - The logger's indentation accessor context.
+*/
+function resetIndentMethod(logger, ctx) {
+	if (ctx.boundStream) ctx.setIndent(ctx.boundStream, "");
+	else {
+		ctx.setIndent("stderr", "");
+		ctx.setIndent("stdout", "");
+	}
+	return logger;
+}
+
+//#endregion
+exports.dedentMethod = dedentMethod;
+exports.groupEndMethod = groupEndMethod;
+exports.groupMethod = groupMethod;
+exports.indentMethod = indentMethod;
+exports.resetIndentMethod = resetIndentMethod;