@socketsecurity/lib 6.0.6 → 6.0.8

package/dist/spinner/create-spinner-class.js

@@ -0,0 +1,302 @@
+"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_object = require('../primordials/object.js');
+const require_primordials_array = require('../primordials/array.js');
+const require_process_abort = require('../process/abort.js');
+const require_logger_symbols = require('../logger/symbols.js');
+const require_strings_predicates = require('../strings/predicates.js');
+const require_colors_convert = require('../colors/convert.js');
+const require_strings_width = require('../strings/width.js');
+const require_spinner_format = require('./format.js');
+const require_spinner_spinner_internals = require('./spinner-internals.js');
+const require_spinner_spinner_shimmer_methods = require('./spinner-shimmer-methods.js');
+const require_spinner_spinner_status_methods = require('./spinner-status-methods.js');
+
+//#region src/spinner/create-spinner-class.ts
+/**
+* Build the Socket `Spinner` class as a subclass of the live `yocto-spinner`
+* constructor. Passing the parent class in keeps the `super()` binding against
+* the runtime constructor while letting the bulk of the class body live outside
+* the factory module.
+*
+* @param YoctoSpinnerClass - Runtime `yocto-spinner` constructor to extend.
+* @param logger - Default logger used for status output.
+*
+* @returns The constructed Socket spinner constructor.
+*/
+function createSpinnerClass(YoctoSpinnerClass, logger) {
+	const SpinnerCtor = class SpinnerClass extends YoctoSpinnerClass {
+		#baseText = "";
+		#indentation = "";
+		#progress;
+		#shimmer;
+		#shimmerSavedConfig;
+		constructor(ctorOptions) {
+			const opts = {
+				__proto__: null,
+				...ctorOptions
+			};
+			const spinnerColorRgb = require_spinner_spinner_internals.resolveSpinnerColorRgb(opts);
+			const shimmerInfo = require_spinner_spinner_internals.parseShimmerOption(opts.shimmer);
+			super({
+				signal: require_process_abort.getAbortSignal(),
+				...opts,
+				color: spinnerColorRgb,
+				onRenderFrame: (frame, text, applyColor) => {
+					const spacing = require_strings_width.stringWidth(frame) === 1 ? "  " : " ";
+					return frame ? `${applyColor(frame)}${spacing}${text}` : text;
+				},
+				onFrameUpdate: shimmerInfo ? () => {
+					if (this.#baseText) super["text"] = this.#buildDisplayText();
+				} : void 0
+			});
+			this.#shimmer = shimmerInfo;
+			this.#shimmerSavedConfig = shimmerInfo;
+		}
+		get color() {
+			const value = super.color;
+			return require_colors_convert.isRgbTuple(value) ? value : require_colors_convert.toRgb(value);
+		}
+		set color(value) {
+			super.color = require_colors_convert.isRgbTuple(value) ? value : require_colors_convert.toRgb(value);
+		}
+		/**
+		* Apply a yocto-spinner method and update logger state. Handles text
+		* normalization, extra arguments, and logger tracking. Exposed under
+		* `applyStatusSymbol` so the status methods installed from
+		* `spinner-status-methods.ts` can drive it.
+		*/
+		[require_spinner_spinner_status_methods.applyStatusSymbol](methodName, args) {
+			let extras;
+			let text = require_primordials_array.ArrayPrototypeAt(args, 0);
+			if (typeof text === "string") extras = require_primordials_array.ArrayPrototypeSlice(args, 1);
+			else {
+				extras = args;
+				text = "";
+			}
+			const wasSpinning = this.isSpinning;
+			const normalized = require_spinner_format.normalizeText(text);
+			const superMethod = super[methodName];
+			if (methodName === "stop" && !normalized) superMethod.call(this);
+			else superMethod.call(this, normalized);
+			if (methodName === "stop") {
+				if (wasSpinning && normalized) {
+					logger[require_logger_symbols.lastWasBlankSymbol](require_strings_predicates.isBlankString(normalized));
+					logger[require_logger_symbols.incLogCallCountSymbol]();
+				}
+			} else {
+				logger[require_logger_symbols.lastWasBlankSymbol](false);
+				logger[require_logger_symbols.incLogCallCountSymbol]();
+			}
+			/* c8 ignore start - extras-empty no-op arm fires when log called without extras */
+			if (extras.length) {
+				logger.log(...extras);
+				logger[require_logger_symbols.lastWasBlankSymbol](false);
+			}
+			/* c8 ignore stop */
+			return this;
+		}
+		/**
+		* Build the complete display text with progress, shimmer, and indentation.
+		* Combines base text, progress bar, shimmer effects, and indentation.
+		*
+		* @private
+		*/
+		#buildDisplayText() {
+			let displayText = this.#baseText;
+			/* c8 ignore start - progress + shimmer paths fire only when caller seeded those configs */
+			if (this.#progress) {
+				const progressText = require_spinner_format.formatProgress(this.#progress);
+				displayText = displayText ? `${displayText} ${progressText}` : progressText;
+			}
+			if (displayText && this.#shimmer) displayText = require_spinner_spinner_internals.applyShimmer(displayText, this.#shimmer, this.color);
+			if (this.#indentation && displayText) displayText = this.#indentation + displayText;
+			/* c8 ignore stop */
+			return displayText;
+		}
+		/**
+		* Show a status message without stopping the spinner. Outputs the symbol
+		* and message to stderr, then continues spinning. Exposed under
+		* `showStatusSymbol` so the status methods installed from
+		* `spinner-status-methods.ts` can drive it.
+		*/
+		[require_spinner_spinner_status_methods.showStatusSymbol](symbolType, args) {
+			let text = require_primordials_array.ArrayPrototypeAt(args, 0);
+			let extras;
+			if (typeof text === "string") extras = require_primordials_array.ArrayPrototypeSlice(args, 1);
+			else {
+				extras = args;
+				text = "";
+			}
+			logger.error(`${require_logger_symbols.LOG_SYMBOLS[symbolType]} ${text}`, ...extras);
+			return this;
+		}
+		/**
+		* Update the spinner's displayed text. Rebuilds display text and triggers
+		* render.
+		*
+		* @private
+		*/
+		#updateSpinnerText() {
+			super["text"] = this.#buildDisplayText();
+		}
+		[require_spinner_spinner_shimmer_methods.getShimmerSymbol]() {
+			return this.#shimmer;
+		}
+		[require_spinner_spinner_shimmer_methods.setShimmerSymbol](value) {
+			this.#shimmer = value;
+		}
+		[require_spinner_spinner_shimmer_methods.getSavedShimmerSymbol]() {
+			return this.#shimmerSavedConfig;
+		}
+		[require_spinner_spinner_shimmer_methods.setSavedShimmerSymbol](value) {
+			this.#shimmerSavedConfig = value;
+		}
+		[require_spinner_spinner_shimmer_methods.updateTextSymbol]() {
+			this.#updateSpinnerText();
+		}
+		/**
+		* Decrease indentation level by removing spaces from the left. Pass 0 to
+		* reset indentation to zero completely.
+		*
+		* @default spaces=2
+		*
+		* @param spaces - Number of spaces to remove.
+		*
+		* @returns This spinner for chaining
+		*/
+		dedent(spaces) {
+			if (spaces === 0) this.#indentation = "";
+			else {
+				const amount = spaces ?? 2;
+				const newLength = require_primordials_math.MathMax(0, this.#indentation.length - amount);
+				this.#indentation = this.#indentation.slice(0, newLength);
+			}
+			this.#updateSpinnerText();
+			return this;
+		}
+		/**
+		* Increase indentation level by adding spaces to the left. Pass 0 to reset
+		* indentation to zero completely.
+		*
+		* @default spaces=2
+		*
+		* @param spaces - Number of spaces to add.
+		*
+		* @returns This spinner for chaining
+		*/
+		indent(spaces) {
+			/* c8 ignore start - spaces===0 fires when caller passes 0; else-branch + default fire for omitted/non-zero */
+			if (spaces === 0) this.#indentation = "";
+			else {
+				const amount = spaces ?? 2;
+				this.#indentation += " ".repeat(amount);
+			}
+			/* c8 ignore stop */
+			this.#updateSpinnerText();
+			return this;
+		}
+		/**
+		* Update progress information displayed with the spinner. Shows a progress
+		* bar with percentage and optional unit label.
+		*
+		* @param current - Current progress value.
+		* @param total - Total/maximum progress value.
+		* @param unit - Optional unit label (e.g., 'files', 'items')
+		*
+		* @returns This spinner for chaining
+		*/
+		progress = (current, total, unit) => {
+			this.#progress = {
+				__proto__: null,
+				current,
+				total,
+				...unit ? { unit } : {}
+			};
+			this.#updateSpinnerText();
+			return this;
+		};
+		/**
+		* Increment progress by a specified amount. Updates the progress bar
+		* displayed with the spinner. Clamps the result between 0 and the total
+		* value.
+		*
+		* @default amount=1
+		*
+		* @param amount - Amount to increment by.
+		*
+		* @returns This spinner for chaining
+		*/
+		progressStep(amount = 1) {
+			/* c8 ignore start - no-progress no-op fires before progress() seed; unit-spread arm fires when seeded with unit */
+			if (this.#progress) {
+				const newCurrent = this.#progress.current + amount;
+				this.#progress = {
+					__proto__: null,
+					current: require_primordials_math.MathMax(0, Math.min(newCurrent, this.#progress.total)),
+					total: this.#progress.total,
+					...this.#progress.unit ? { unit: this.#progress.unit } : {}
+				};
+				this.#updateSpinnerText();
+			}
+			return this;
+			/* c8 ignore stop */
+		}
+		/**
+		* Start the spinner animation with optional text. Begins displaying the
+		* animated spinner on stderr.
+		*
+		* @param text - Optional text to display with the spinner.
+		*
+		* @returns This spinner for chaining
+		*/
+		start(...args) {
+			/* c8 ignore start - args-length and normalized-falsy arms exercised across calls; some test paths skip both */
+			if (args.length) {
+				const normalized = require_spinner_format.normalizeText(require_primordials_array.ArrayPrototypeAt(args, 0));
+				if (!normalized) {
+					this.#baseText = "";
+					super["text"] = "";
+				} else this.#baseText = normalized;
+			}
+			/* c8 ignore stop */
+			this.#updateSpinnerText();
+			return this[require_spinner_spinner_status_methods.applyStatusSymbol]("start", []);
+		}
+		/**
+		* Stop the spinner animation and clear internal state. Auto-clears the
+		* spinner line via yocto-spinner.stop(). Resets progress, shimmer, and text
+		* state.
+		*
+		* @param text - Optional final text to display after stopping.
+		*
+		* @returns This spinner for chaining
+		*/
+		stop(...args) {
+			this.#baseText = "";
+			this.#progress = void 0;
+			this.#shimmer = void 0;
+			return this[require_spinner_spinner_status_methods.applyStatusSymbol]("stop", args);
+		}
+		text(value) {
+			if (arguments.length === 0) return this.#baseText;
+			this.#baseText = value ?? "";
+			this.#updateSpinnerText();
+			return this;
+		}
+	};
+	require_spinner_spinner_status_methods.installStatusMethods(SpinnerCtor.prototype, logger);
+	require_spinner_spinner_shimmer_methods.installShimmerMethods(SpinnerCtor.prototype);
+	require_primordials_object.ObjectDefineProperties(SpinnerCtor.prototype, {
+		error: require_spinner_format.desc(SpinnerCtor.prototype.fail),
+		errorAndStop: require_spinner_format.desc(SpinnerCtor.prototype.failAndStop),
+		warning: require_spinner_format.desc(SpinnerCtor.prototype.warn),
+		warningAndStop: require_spinner_format.desc(SpinnerCtor.prototype.warnAndStop)
+	});
+	return SpinnerCtor;
+}
+
+//#endregion
+exports.createSpinnerClass = createSpinnerClass;

package/dist/spinner/default.js

@@ -16,8 +16,8 @@ src_external__socketregistry_yocto_spinner = require_runtime.__toESM(src_externa
 *   and memoized; `getDefaultSpinner()` defers `Spinner()` construction until
 *   first call so module initialization stays cheap.
 */
-let _cliSpinners;
-let _spinner;
+let cliSpinners;
+let spinner;
 /**
 * Get available CLI spinner styles or a specific style by name. Extends the
 * standard cli-spinners collection with Socket custom spinners.
@@ -42,17 +42,16 @@ let _spinner;
 *
 * @see https://github.com/sindresorhus/cli-spinners/blob/main/spinners.json
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getCliSpinners(styleName) {
-	if (_cliSpinners === void 0)
+	if (cliSpinners === void 0)
  /* c8 ignore stop */
-	_cliSpinners = {
+	cliSpinners = {
 		__proto__: null,
 		...(0, src_external__socketregistry_yocto_spinner.default)({}).constructor.spinners,
 		socket: require_effects_pulse_frames.generateSocketSpinnerFrames()
 	};
-	if (typeof styleName === "string" && _cliSpinners) return /* @__PURE__ */ require_objects_predicates.hasOwn(_cliSpinners, styleName) ? _cliSpinners[styleName] : void 0;
-	return _cliSpinners;
+	if (typeof styleName === "string" && cliSpinners) return require_objects_predicates.hasOwn(cliSpinners, styleName) ? cliSpinners[styleName] : void 0;
+	return cliSpinners;
 }
 /**
 * Get the default spinner instance. Lazily creates the spinner to avoid
@@ -70,8 +69,8 @@ function getCliSpinners(styleName) {
 * @returns Shared default spinner instance
 */
 function getDefaultSpinner() {
-	if (_spinner === void 0) _spinner = /* @__PURE__ */ require_spinner_spinner.Spinner();
-	return _spinner;
+	if (spinner === void 0) spinner = require_spinner_spinner.Spinner();
+	return spinner;
 }
 
 //#endregion

package/dist/spinner/spinner-internals.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @file Pure helpers extracted from the Socket `Spinner` class body: option
+ *   parsing (theme/color resolution, shimmer config) and the shimmer rendering
+ *   pass. Keeping these side-effect-free and outside the class keeps the class
+ *   module focused on method wiring and under the file-size cap.
+ */
+import type { ColorRgb } from '../colors/types';
+import type { ShimmerInfo, SpinnerOptions } from './types';
+/**
+ * Apply the shimmer effect to display text. Mutates the shimmer frame counter
+ * as it advances. Skips work in CI or when the direction is 'none'.
+ *
+ * @param displayText - Text to colorize.
+ * @param shimmer - Mutable shimmer state (frame counter is advanced).
+ * @param currentColor - The spinner's current RGB color (used for inherit).
+ *
+ * @returns Colorized text, or the input unchanged when shimmer is skipped.
+ */
+export declare function applyShimmer(displayText: string, shimmer: ShimmerInfo, currentColor: ColorRgb): string;
+/**
+ * Parse the shimmer option (object or direction string) into a `ShimmerInfo`.
+ *
+ * @param shimmer - The `shimmer` option value.
+ *
+ * @returns Parsed shimmer state, or undefined when shimmer is disabled.
+ */
+export declare function parseShimmerOption(shimmer: SpinnerOptions['shimmer']): ShimmerInfo | undefined;
+/**
+ * Resolve the spinner's RGB color from options and the active theme. Validates
+ * RGB tuples and falls back to the theme's primary color.
+ *
+ * @param opts - Normalized spinner options.
+ *
+ * @returns Resolved RGB color tuple.
+ */
+export declare function resolveSpinnerColorRgb(options: SpinnerOptions): ColorRgb;

package/dist/spinner/spinner-internals.js

@@ -0,0 +1,105 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_error = require('../primordials/error.js');
+const require_primordials_array = require('../primordials/array.js');
+const require_env_ci = require('../env/ci.js');
+const require_themes_themes = require('../themes/themes.js');
+const require_themes_context = require('../themes/context.js');
+const require_colors_convert = require('../colors/convert.js');
+const require_spinner_format = require('./format.js');
+const require_effects_shimmer = require('../effects/shimmer.js');
+const require_effects_shimmer_terminal = require('../effects/shimmer-terminal.js');
+const require_themes_resolve = require('../themes/resolve.js');
+
+//#region src/spinner/spinner-internals.ts
+/**
+* Apply the shimmer effect to display text. Mutates the shimmer frame counter
+* as it advances. Skips work in CI or when the direction is 'none'.
+*
+* @param displayText - Text to colorize.
+* @param shimmer - Mutable shimmer state (frame counter is advanced).
+* @param currentColor - The spinner's current RGB color (used for inherit).
+*
+* @returns Colorized text, or the input unchanged when shimmer is skipped.
+*/
+function applyShimmer(displayText, shimmer, currentColor) {
+	let shimmerColor;
+	if (shimmer.color === "inherit") shimmerColor = currentColor;
+	else if (require_primordials_array.ArrayIsArray(shimmer.color[0])) shimmerColor = shimmer.color;
+	else shimmerColor = require_colors_convert.toRgb(shimmer.color);
+	if (!require_env_ci.getCI() && shimmer.direction !== "none") {
+		const chars = [...displayText];
+		const colors = require_effects_shimmer.frameColors(require_effects_shimmer.configToSpec({
+			color: shimmerColor,
+			dir: shimmer.direction,
+			speed: shimmer.speed
+		}, chars.length), chars.length, shimmer.frame);
+		shimmer.frame++;
+		return require_effects_shimmer_terminal.colorsToAnsi(displayText, colors);
+	}
+	return displayText;
+}
+/**
+* Parse the shimmer option (object or direction string) into a `ShimmerInfo`.
+*
+* @param shimmer - The `shimmer` option value.
+*
+* @returns Parsed shimmer state, or undefined when shimmer is disabled.
+*/
+function parseShimmerOption(shimmer) {
+	if (!shimmer) return;
+	let shimmerDir;
+	let shimmerColor;
+	let shimmerSpeed = 1 / 3;
+	if (typeof shimmer === "string") {
+		shimmerDir = shimmer;
+		shimmerColor = require_spinner_format.COLOR_INHERIT;
+	} else {
+		const shimmerConfig = {
+			__proto__: null,
+			...shimmer
+		};
+		shimmerDir = shimmerConfig.dir ?? "ltr";
+		shimmerColor = shimmerConfig.color ?? "inherit";
+		shimmerSpeed = shimmerConfig.speed ?? 1 / 3;
+	}
+	return {
+		__proto__: null,
+		color: shimmerColor,
+		direction: shimmerDir,
+		speed: shimmerSpeed,
+		frame: 0
+	};
+}
+/**
+* Resolve the spinner's RGB color from options and the active theme. Validates
+* RGB tuples and falls back to the theme's primary color.
+*
+* @param opts - Normalized spinner options.
+*
+* @returns Resolved RGB color tuple.
+*/
+function resolveSpinnerColorRgb(options) {
+	options = {
+		__proto__: null,
+		...options
+	};
+	let theme = require_themes_context.getTheme();
+	if (options.theme) if (typeof options.theme === "string") theme = require_themes_themes.THEMES[options.theme] ?? theme;
+	else theme = options.theme;
+	let defaultColor = theme.colors.primary;
+	if (theme.effects?.spinner?.color) {
+		const resolved = require_themes_resolve.resolveColor(theme.effects.spinner.color, theme.colors);
+		if (resolved === "inherit" || require_primordials_array.ArrayIsArray(resolved[0])) defaultColor = theme.colors.primary;
+		else defaultColor = resolved;
+	}
+	const spinnerColor = options.color ?? defaultColor;
+	if (require_colors_convert.isRgbTuple(spinnerColor) && (spinnerColor.length !== 3 || !spinnerColor.every((n) => typeof n === "number" && n >= 0 && n <= 255))) throw new require_primordials_error.TypeErrorCtor("RGB color must be an array of 3 numbers between 0 and 255");
+	return require_colors_convert.toRgb(spinnerColor);
+}
+
+//#endregion
+exports.applyShimmer = applyShimmer;
+exports.parseShimmerOption = parseShimmerOption;
+exports.resolveSpinnerColorRgb = resolveSpinnerColorRgb;

package/dist/spinner/spinner-shimmer-methods.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @file Shimmer-configuration methods for the Socket `Spinner` class, split out
+ *   of `create-spinner-class.ts` to keep that module under the file-size cap.
+ *   The methods read and write the spinner's shimmer state through well-known
+ *   symbols (`getShimmerSymbol`, `setShimmerSymbol`, `getSavedShimmerSymbol`,
+ *   `setSavedShimmerSymbol`, `updateTextSymbol`) the class exposes, so they
+ *   share the same private state without crossing the private-field boundary.
+ *   `installShimmerMethods()` defines them on the prototype after the class is
+ *   built.
+ */
+import type { ShimmerInfo, SpinnerInstance } from './types';
+/**
+ * Well-known symbol the spinner class exposes to read its current shimmer
+ * state.
+ */
+export declare const getShimmerSymbol: unique symbol;
+/**
+ * Well-known symbol the spinner class exposes to replace its current shimmer
+ * state.
+ */
+export declare const setShimmerSymbol: unique symbol;
+/**
+ * Well-known symbol the spinner class exposes to read the saved shimmer config
+ * that `enableShimmer()` restores from.
+ */
+export declare const getSavedShimmerSymbol: unique symbol;
+/**
+ * Well-known symbol the spinner class exposes to replace the saved shimmer
+ * config.
+ */
+export declare const setSavedShimmerSymbol: unique symbol;
+/**
+ * Well-known symbol the spinner class exposes for its `#updateSpinnerText`
+ * helper so the shimmer methods can trigger a re-render after a state change.
+ */
+export declare const updateTextSymbol: unique symbol;
+/**
+ * Runtime shape of the spinner instance the shimmer methods operate on.
+ */
+export type ShimmerHost = SpinnerInstance & {
+    [getShimmerSymbol]: () => ShimmerInfo | undefined;
+    [setShimmerSymbol]: (value: ShimmerInfo | undefined) => void;
+    [getSavedShimmerSymbol]: () => ShimmerInfo | undefined;
+    [setSavedShimmerSymbol]: (value: ShimmerInfo | undefined) => void;
+    [updateTextSymbol]: () => void;
+};
+/**
+ * Install the shimmer-configuration methods + `shimmerState` getter onto the
+ * spinner prototype. The methods reach the spinner's private shimmer state
+ * through the well-known symbols the class exposes.
+ *
+ * @param proto - The spinner class prototype to augment.
+ */
+export declare function installShimmerMethods(proto: object): void;

package/dist/spinner/spinner-shimmer-methods.js

@@ -0,0 +1,143 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_spinner_format = require('./format.js');
+
+//#region src/spinner/spinner-shimmer-methods.ts
+/**
+* Well-known symbol the spinner class exposes to read its current shimmer
+* state.
+*/
+const getShimmerSymbol = Symbol.for("socket.spinner.getShimmer");
+/**
+* Well-known symbol the spinner class exposes to replace its current shimmer
+* state.
+*/
+const setShimmerSymbol = Symbol.for("socket.spinner.setShimmer");
+/**
+* Well-known symbol the spinner class exposes to read the saved shimmer config
+* that `enableShimmer()` restores from.
+*/
+const getSavedShimmerSymbol = Symbol.for("socket.spinner.getSavedShimmer");
+/**
+* Well-known symbol the spinner class exposes to replace the saved shimmer
+* config.
+*/
+const setSavedShimmerSymbol = Symbol.for("socket.spinner.setSavedShimmer");
+/**
+* Well-known symbol the spinner class exposes for its `#updateSpinnerText`
+* helper so the shimmer methods can trigger a re-render after a state change.
+*/
+const updateTextSymbol = Symbol.for("socket.spinner.updateText");
+/**
+* Install the shimmer-configuration methods + `shimmerState` getter onto the
+* spinner prototype. The methods reach the spinner's private shimmer state
+* through the well-known symbols the class exposes.
+*
+* @param proto - The spinner class prototype to augment.
+*/
+function installShimmerMethods(proto) {
+	const target = proto;
+	function shimmerState() {
+		const shimmer = this[getShimmerSymbol]();
+		if (!shimmer) return;
+		return {
+			__proto__: null,
+			color: shimmer.color,
+			direction: shimmer.direction,
+			speed: shimmer.speed,
+			frame: shimmer.frame
+		};
+	}
+	function disableShimmer() {
+		this[setShimmerSymbol](void 0);
+		this[updateTextSymbol]();
+		return this;
+	}
+	function enableShimmer() {
+		const saved = this[getSavedShimmerSymbol]();
+		if (saved) this[setShimmerSymbol]({
+			...saved,
+			frame: 0
+		});
+		else {
+			const next = {
+				__proto__: null,
+				color: require_spinner_format.COLOR_INHERIT,
+				direction: "ltr",
+				speed: 1 / 3,
+				frame: 0
+			};
+			this[setShimmerSymbol](next);
+			this[setSavedShimmerSymbol](next);
+		}
+		this[updateTextSymbol]();
+		return this;
+	}
+	function setShimmer(config) {
+		const next = {
+			__proto__: null,
+			color: config.color ?? "inherit",
+			direction: config.dir ?? "ltr",
+			speed: config.speed ?? 1 / 3,
+			frame: 0
+		};
+		this[setShimmerSymbol](next);
+		this[setSavedShimmerSymbol](next);
+		this[updateTextSymbol]();
+		return this;
+	}
+	function updateShimmer(config) {
+		/* c8 ignore start - each partial-config field branch fires only when caller updates that field; shimmer-state cascade covers three init paths */
+		const partialConfig = {
+			__proto__: null,
+			...config
+		};
+		const update = { __proto__: null };
+		if (partialConfig.color !== void 0) update.color = partialConfig.color;
+		if (partialConfig.dir !== void 0) update.direction = partialConfig.dir;
+		if (partialConfig.speed !== void 0) update.speed = partialConfig.speed;
+		const shimmer = this[getShimmerSymbol]();
+		const saved = this[getSavedShimmerSymbol]();
+		let next;
+		if (shimmer) next = {
+			...shimmer,
+			...update
+		};
+		else if (saved) next = {
+			...saved,
+			...update,
+			frame: 0
+		};
+		else next = {
+			__proto__: null,
+			color: require_spinner_format.COLOR_INHERIT,
+			direction: "ltr",
+			speed: 1 / 3,
+			frame: 0,
+			...update
+		};
+		this[setShimmerSymbol](next);
+		this[setSavedShimmerSymbol](next);
+		this[updateTextSymbol]();
+		return this;
+		/* c8 ignore stop */
+	}
+	Object.defineProperty(target, "shimmerState", {
+		configurable: true,
+		enumerable: false,
+		get: shimmerState
+	});
+	target["disableShimmer"] = disableShimmer;
+	target["enableShimmer"] = enableShimmer;
+	target["setShimmer"] = setShimmer;
+	target["updateShimmer"] = updateShimmer;
+}
+
+//#endregion
+exports.getSavedShimmerSymbol = getSavedShimmerSymbol;
+exports.getShimmerSymbol = getShimmerSymbol;
+exports.installShimmerMethods = installShimmerMethods;
+exports.setSavedShimmerSymbol = setSavedShimmerSymbol;
+exports.setShimmerSymbol = setShimmerSymbol;
+exports.updateTextSymbol = updateTextSymbol;