"use strict";
/* Socket Lib - Built with esbuild */
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc2) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var spinner_exports = {};
__export(spinner_exports, {
  Spinner: () => Spinner
});
module.exports = __toCommonJS(spinner_exports);
var import_convert = require("../colors/convert");
var import_abort = require("../process/abort");
var import_namespace = require("../debug/namespace");
var import_shimmer = require("../effects/shimmer");
var import_shimmer_terminal = require("../effects/shimmer-terminal");
var import_ci = require("../env/ci");
var import_yocto_spinner = __toESM(require("../external/@socketregistry/yocto-spinner"));
var import_logger = require("../logger/logger");
var import_symbols = require("../logger/symbols");
var import_array = require("../primordials/array");
var import_error = require("../primordials/error");
var import_math = require("../primordials/math");
var import_object = require("../primordials/object");
var import_predicates = require("../strings/predicates");
var import_width = require("../strings/width");
var import_context = require("../themes/context");
var import_themes = require("../themes/themes");
var import_resolve = require("../themes/resolve");
var import_registry = require("./registry");
var import_format = require("./format");
let _Spinner;
let _defaultSpinner;
// @__NO_SIDE_EFFECTS__
function Spinner(options) {
  if (_Spinner === void 0) {
    const YoctoCtor = import_yocto_spinner.default;
    const tempInstance = YoctoCtor({});
    const YoctoSpinnerClass = tempInstance.constructor;
    const logger = (0, import_logger.getDefaultLogger)();
    _Spinner = class SpinnerClass extends YoctoSpinnerClass {
      #baseText = "";
      #indentation = "";
      #progress;
      #shimmer;
      #shimmerSavedConfig;
      constructor(options2) {
        const opts = { __proto__: null, ...options2 };
        let theme = (0, import_context.getTheme)();
        if (opts.theme) {
          if (typeof opts.theme === "string") {
            theme = import_themes.THEMES[opts.theme] ?? theme;
          } else {
            theme = opts.theme;
          }
        }
        let defaultColor = theme.colors.primary;
        if (theme.effects?.spinner?.color) {
          const resolved = (0, import_resolve.resolveColor)(
            theme.effects.spinner.color,
            theme.colors
          );
          if (resolved === "inherit" || (0, import_array.ArrayIsArray)(resolved[0])) {
            defaultColor = theme.colors.primary;
          } else {
            defaultColor = resolved;
          }
        }
        const spinnerColor = opts.color ?? defaultColor;
        if ((0, import_convert.isRgbTuple)(spinnerColor) && (spinnerColor.length !== 3 || !spinnerColor.every(
          (n) => typeof n === "number" && n >= 0 && n <= 255
        ))) {
          throw new import_error.TypeErrorCtor(
            "RGB color must be an array of 3 numbers between 0 and 255"
          );
        }
        const spinnerColorRgb = (0, import_convert.toRgb)(spinnerColor);
        let shimmerInfo;
        if (opts.shimmer) {
          let shimmerDir;
          let shimmerColor;
          let shimmerSpeed = 1 / 3;
          if (typeof opts.shimmer === "string") {
            shimmerDir = opts.shimmer;
            shimmerColor = import_format.COLOR_INHERIT;
          } else {
            const shimmerConfig = {
              __proto__: null,
              ...opts.shimmer
            };
            shimmerDir = shimmerConfig.dir ?? "ltr";
            shimmerColor = shimmerConfig.color ?? import_format.COLOR_INHERIT;
            shimmerSpeed = shimmerConfig.speed ?? 1 / 3;
          }
          shimmerInfo = {
            __proto__: null,
            color: shimmerColor,
            direction: shimmerDir,
            speed: shimmerSpeed,
            frame: 0
          };
        }
        super({
          signal: (0, import_abort.getAbortSignal)(),
          ...opts,
          // Pass RGB color directly to yocto-spinner (it now supports RGB).
          color: spinnerColorRgb,
          // onRenderFrame callback provides full control over frame + text layout.
          // Calculates spacing based on frame width to prevent text jumping.
          onRenderFrame: (frame, text, applyColor) => {
            const width = (0, import_width.stringWidth)(frame);
            const spacing = width === 1 ? "  " : " ";
            return frame ? `${applyColor(frame)}${spacing}${text}` : text;
          },
          // onFrameUpdate callback is called by yocto-spinner whenever a frame advances.
          // This ensures shimmer updates are perfectly synchronized with animation beats.
          onFrameUpdate: shimmerInfo ? () => {
            if (this.#baseText) {
              super.text = this.#buildDisplayText();
            }
          } : void 0
        });
        this.#shimmer = shimmerInfo;
        this.#shimmerSavedConfig = shimmerInfo;
      }
      // Override color getter to ensure it's always RGB.
      get color() {
        const value = super.color;
        return (0, import_convert.isRgbTuple)(value) ? value : (0, import_convert.toRgb)(value);
      }
      // Override color setter to always convert to RGB before passing to yocto-spinner.
      set color(value) {
        super.color = (0, import_convert.isRgbTuple)(value) ? value : (0, import_convert.toRgb)(value);
      }
      // Getter to expose current shimmer state.
      get shimmerState() {
        if (!this.#shimmer) {
          return void 0;
        }
        return {
          __proto__: null,
          color: this.#shimmer.color,
          direction: this.#shimmer.direction,
          speed: this.#shimmer.speed,
          frame: this.#shimmer.frame
        };
      }
      /**
       * Apply a yocto-spinner method and update logger state. Handles text
       * normalization, extra arguments, and logger tracking.
       *
       * @private
       */
      #apply(methodName, args) {
        let extras;
        let text = (0, import_array.ArrayPrototypeAt)(args, 0);
        if (typeof text === "string") {
          extras = (0, import_array.ArrayPrototypeSlice)(args, 1);
        } else {
          extras = args;
          text = "";
        }
        const wasSpinning = this.isSpinning;
        const normalized = (0, import_format.normalizeText)(text);
        if (methodName === "stop" && !normalized) {
          super[methodName]();
        } else {
          super[methodName](normalized);
        }
        if (methodName === "stop") {
          if (wasSpinning && normalized) {
            logger[import_symbols.lastWasBlankSymbol]((0, import_predicates.isBlankString)(normalized));
            logger[import_symbols.incLogCallCountSymbol]();
          }
        } else {
          logger[import_symbols.lastWasBlankSymbol](false);
          logger[import_symbols.incLogCallCountSymbol]();
        }
        if (extras.length) {
          logger.log(...extras);
          logger[import_symbols.lastWasBlankSymbol](false);
        }
        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;
        if (this.#progress) {
          const progressText = (0, import_format.formatProgress)(this.#progress);
          displayText = displayText ? `${displayText} ${progressText}` : progressText;
        }
        if (displayText && this.#shimmer) {
          let shimmerColor;
          if (this.#shimmer.color === import_format.COLOR_INHERIT) {
            shimmerColor = this.color;
          } else if ((0, import_array.ArrayIsArray)(this.#shimmer.color[0])) {
            shimmerColor = this.#shimmer.color;
          } else {
            shimmerColor = (0, import_convert.toRgb)(this.#shimmer.color);
          }
          if (!(0, import_ci.getCI)() && this.#shimmer.direction !== "none") {
            const chars = [...displayText];
            const spec = (0, import_shimmer.configToSpec)(
              {
                color: shimmerColor,
                dir: this.#shimmer.direction,
                speed: this.#shimmer.speed
              },
              chars.length
            );
            const colors = (0, import_shimmer.frameColors)(spec, chars.length, this.#shimmer.frame);
            displayText = (0, import_shimmer_terminal.colorsToAnsi)(displayText, colors);
            this.#shimmer.frame++;
          }
        }
        if (this.#indentation && displayText) {
          displayText = this.#indentation + displayText;
        }
        return displayText;
      }
      /**
       * Show a status message without stopping the spinner. Outputs the symbol
       * and message to stderr, then continues spinning.
       *
       * @private
       */
      #showStatusAndKeepSpinning(symbolType, args) {
        let text = (0, import_array.ArrayPrototypeAt)(args, 0);
        let extras;
        if (typeof text === "string") {
          extras = (0, import_array.ArrayPrototypeSlice)(args, 1);
        } else {
          extras = args;
          text = "";
        }
        logger.error(`${import_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();
      }
      /**
       * Show a debug message (ℹ) without stopping the spinner. Only displays if
       * debug mode is enabled via environment variable. Outputs to stderr and
       * continues spinning.
       *
       * @param text - Debug message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      debug(text, ...extras) {
        if ((0, import_namespace.isDebug)()) {
          return this.#showStatusAndKeepSpinning("info", [text, ...extras]);
        }
        return this;
      }
      /**
       * Show a debug message (ℹ) and stop the spinner. Only displays if debug
       * mode is enabled via environment variable. Auto-clears the spinner line
       * before displaying the message.
       *
       * @param text - Debug message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      debugAndStop(text, ...extras) {
        if ((0, import_namespace.isDebug)()) {
          return this.#apply("info", [text, ...extras]);
        }
        return this;
      }
      /**
       * 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 = (0, import_math.MathMax)(0, this.#indentation.length - amount);
          this.#indentation = this.#indentation.slice(0, newLength);
        }
        this.#updateSpinnerText();
        return this;
      }
      /**
       * Disable shimmer effect. Preserves config for later re-enable via
       * enableShimmer().
       *
       * @example
       *   spinner.disableShimmer()
       *
       * @returns This spinner for chaining
       */
      disableShimmer() {
        this.#shimmer = void 0;
        this.#updateSpinnerText();
        return this;
      }
      /**
       * Show a done/success message (✓) without stopping the spinner. Alias for
       * `success()` with a shorter name.
       *
       * DESIGN DECISION: Unlike yocto-spinner, our `done()` does NOT stop the
       * spinner. Use `doneAndStop()` if you want to stop the spinner.
       *
       * @param text - Message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      done(text, ...extras) {
        return this.#showStatusAndKeepSpinning("success", [text, ...extras]);
      }
      /**
       * Show a done/success message (✓) and stop the spinner. Auto-clears the
       * spinner line before displaying the success message.
       *
       * @param text - Message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      doneAndStop(text, ...extras) {
        return this.#apply("success", [text, ...extras]);
      }
      /**
       * Enable shimmer effect. Restores saved config or uses defaults if no
       * saved config exists.
       *
       * @example
       *   spinner.enableShimmer()
       *
       * @returns This spinner for chaining
       */
      enableShimmer() {
        if (this.#shimmerSavedConfig) {
          this.#shimmer = { ...this.#shimmerSavedConfig, frame: 0 };
        } else {
          this.#shimmer = {
            __proto__: null,
            color: import_format.COLOR_INHERIT,
            direction: "ltr",
            speed: 1 / 3,
            frame: 0
          };
          this.#shimmerSavedConfig = this.#shimmer;
        }
        this.#updateSpinnerText();
        return this;
      }
      /**
       * Show a failure message (✗) without stopping the spinner. DESIGN
       * DECISION: Unlike yocto-spinner, our `fail()` does NOT stop the spinner.
       * This allows displaying errors while continuing to spin. Use
       * `failAndStop()` if you want to stop the spinner.
       *
       * @param text - Error message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      fail(text, ...extras) {
        return this.#showStatusAndKeepSpinning("fail", [text, ...extras]);
      }
      /**
       * Show a failure message (✗) and stop the spinner. Auto-clears the
       * spinner line before displaying the error message.
       *
       * @param text - Error message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      failAndStop(text, ...extras) {
        return this.#apply("error", [text, ...extras]);
      }
      /**
       * 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) {
        if (spaces === 0) {
          this.#indentation = "";
        } else {
          const amount = spaces ?? 2;
          this.#indentation += " ".repeat(amount);
        }
        this.#updateSpinnerText();
        return this;
      }
      /**
       * Show an info message (ℹ) without stopping the spinner. Outputs to
       * stderr and continues spinning.
       *
       * @param text - Info message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      info(text, ...extras) {
        return this.#showStatusAndKeepSpinning("info", [text, ...extras]);
      }
      /**
       * Show an info message (ℹ) and stop the spinner. Auto-clears the spinner
       * line before displaying the message.
       *
       * @param text - Info message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      infoAndStop(text, ...extras) {
        return this.#apply("info", [text, ...extras]);
      }
      /**
       * Log a message to stdout without stopping the spinner. Unlike other
       * status methods, this outputs to stdout for data logging.
       *
       * @param args - Values to log to stdout.
       *
       * @returns This spinner for chaining
       */
      log(...args) {
        logger.log(...args);
        return this;
      }
      /**
       * Log a message to stdout and stop the spinner. Auto-clears the spinner
       * line before displaying the message.
       *
       * @param text - Message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      logAndStop(text, ...extras) {
        return this.#apply("stop", [text, ...extras]);
      }
      /**
       * 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) {
        if (this.#progress) {
          const newCurrent = this.#progress.current + amount;
          this.#progress = {
            __proto__: null,
            current: (0, import_math.MathMax)(0, Math.min(newCurrent, this.#progress.total)),
            total: this.#progress.total,
            ...this.#progress.unit ? { unit: this.#progress.unit } : {}
          };
          this.#updateSpinnerText();
        }
        return this;
      }
      /**
       * Show a skip message (↻) without stopping the spinner. Outputs to stderr
       * and continues spinning.
       *
       * @param text - Skip message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      skip(text, ...extras) {
        return this.#showStatusAndKeepSpinning("skip", [text, ...extras]);
      }
      /**
       * Show a skip message (↻) and stop the spinner. Auto-clears the spinner
       * line before displaying the message.
       *
       * Implementation note: Unlike other *AndStop methods (successAndStop,
       * failAndStop, etc.), this method cannot use #apply() with a 'skip'
       * method name because yocto-spinner doesn't have a built-in 'skip'
       * method. Instead, we manually stop the spinner then log the message with
       * the skip symbol.
       *
       * @param text - Skip message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      skipAndStop(text, ...extras) {
        this.#apply("stop", []);
        const normalized = (0, import_format.normalizeText)(text);
        if (normalized) {
          logger.error(`${import_symbols.LOG_SYMBOLS["skip"]} ${normalized}`, ...extras);
        }
        return this;
      }
      /**
       * Set complete shimmer configuration. Replaces any existing shimmer
       * config with the provided values. Undefined properties will use default
       * values.
       *
       * @example
       *   spinner.setShimmer({
       *     color: [255, 0, 0],
       *     dir: 'rtl',
       *     speed: 0.5,
       *   })
       *
       * @param config - Complete shimmer configuration.
       *
       * @returns This spinner for chaining
       */
      setShimmer(config) {
        this.#shimmer = {
          __proto__: null,
          color: config.color ?? import_format.COLOR_INHERIT,
          direction: config.dir ?? "ltr",
          speed: config.speed ?? 1 / 3,
          frame: 0
        };
        this.#shimmerSavedConfig = this.#shimmer;
        this.#updateSpinnerText();
        return this;
      }
      /**
       * 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) {
        if (args.length) {
          const text = (0, import_array.ArrayPrototypeAt)(args, 0);
          const normalized = (0, import_format.normalizeText)(text);
          if (!normalized) {
            this.#baseText = "";
            super.text = "";
          } else {
            this.#baseText = normalized;
          }
        }
        this.#updateSpinnerText();
        return this.#apply("start", []);
      }
      /**
       * Log a main step message to stderr without stopping the spinner. Adds a
       * blank line before the message for visual separation. Aligns with
       * `logger.step()` to use stderr for status messages.
       *
       * @param text - Step message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      step(text, ...extras) {
        if (typeof text === "string") {
          logger.error("");
          logger.error(text, ...extras);
        }
        return this;
      }
      /**
       * 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;
        const result = this.#apply("stop", args);
        return result;
      }
      /**
       * Log an indented substep message to stderr without stopping the spinner.
       * Adds 2-space indentation to the message. Aligns with `logger.substep()`
       * to use stderr for status messages.
       *
       * @param text - Substep message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      substep(text, ...extras) {
        if (typeof text === "string") {
          logger.error(`  ${text}`, ...extras);
        }
        return this;
      }
      /**
       * Show a success message (✓) without stopping the spinner. DESIGN
       * DECISION: Unlike yocto-spinner, our `success()` does NOT stop the
       * spinner. This allows displaying success messages while continuing to
       * spin for multi-step operations. Use `successAndStop()` if you want to
       * stop the spinner.
       *
       * @param text - Success message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      success(text, ...extras) {
        return this.#showStatusAndKeepSpinning("success", [text, ...extras]);
      }
      /**
       * Show a success message (✓) and stop the spinner. Auto-clears the
       * spinner line before displaying the success message.
       *
       * @param text - Success message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      successAndStop(text, ...extras) {
        return this.#apply("success", [text, ...extras]);
      }
      text(value) {
        if (arguments.length === 0) {
          return this.#baseText;
        }
        this.#baseText = value ?? "";
        this.#updateSpinnerText();
        return this;
      }
      /**
       * Update partial shimmer configuration. Merges with existing config,
       * enabling shimmer if currently disabled.
       *
       * @example
       *   // Update just the speed
       *   spinner.updateShimmer({ speed: 0.5 })
       *
       *   // Update direction
       *   spinner.updateShimmer({ dir: 'rtl' })
       *
       *   // Update multiple properties
       *   spinner.updateShimmer({ color: [255, 0, 0], speed: 0.8 })
       *
       * @param config - Partial shimmer configuration to merge.
       *
       * @returns This spinner for chaining
       */
      updateShimmer(config) {
        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;
        }
        if (this.#shimmer) {
          this.#shimmer = { ...this.#shimmer, ...update };
        } else if (this.#shimmerSavedConfig) {
          this.#shimmer = {
            ...this.#shimmerSavedConfig,
            ...update,
            frame: 0
          };
        } else {
          this.#shimmer = {
            __proto__: null,
            color: import_format.COLOR_INHERIT,
            direction: "ltr",
            speed: 1 / 3,
            frame: 0,
            ...update
          };
        }
        this.#shimmerSavedConfig = this.#shimmer;
        this.#updateSpinnerText();
        return this;
      }
      /**
       * Show a warning message (⚠) without stopping the spinner. Outputs to
       * stderr and continues spinning.
       *
       * @param text - Warning message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      warn(text, ...extras) {
        return this.#showStatusAndKeepSpinning("warn", [text, ...extras]);
      }
      /**
       * Show a warning message (⚠) and stop the spinner. Auto-clears the
       * spinner line before displaying the warning message.
       *
       * @param text - Warning message to display.
       * @param extras - Additional values to log.
       *
       * @returns This spinner for chaining
       */
      warnAndStop(text, ...extras) {
        return this.#apply("warning", [text, ...extras]);
      }
    };
    (0, import_object.ObjectDefineProperties)(_Spinner.prototype, {
      error: (0, import_format.desc)(_Spinner.prototype.fail),
      errorAndStop: (0, import_format.desc)(_Spinner.prototype.failAndStop),
      warning: (0, import_format.desc)(_Spinner.prototype.warn),
      warningAndStop: (0, import_format.desc)(_Spinner.prototype.warnAndStop)
    });
    _defaultSpinner = (0, import_ci.getCI)() ? import_format.ciSpinner : (0, import_registry.getCliSpinners)("socket");
  }
  return new _Spinner({
    spinner: _defaultSpinner,
    ...options
  });
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  Spinner
});
