tiny-essentials 1.7.1 → 1.8.1

package/dist/v1/libs/ColorSafeStringify.cjs

@@ -0,0 +1,196 @@
+'use strict';
+
+/**
+ * @typedef {Record<string, string>} ColorsList
+ * Represents a mapping of color keys to ANSI escape codes.
+ */
+
+class ColorSafeStringify {
+  /**
+   * Currently active color configuration.
+   * @type {ColorsList}
+   */
+  #colors;
+
+  /**
+   * Preset collections (internal and user-defined).
+   * @type {Record<string, ColorsList>}
+   * @static
+   */
+  static #PRESETS = {
+    default: {
+      reset: '\x1b[0m',
+      key: '\x1b[36m', // Cyan (object keys)
+      string: '\x1b[32m', // Green (regular strings)
+      string_url: '\x1b[34m', // Blue (URLs)
+      string_bool: '\x1b[35m', // Magenta (boolean/null in string form)
+      string_number: '\x1b[33m', // Yellow (numbers in string form)
+      number: '\x1b[33m', // Yellow (raw numbers)
+      boolean: '\x1b[35m', // Magenta (true/false)
+      null: '\x1b[1;30m', // Gray (null)
+      special: '\x1b[31m', // Red (e.g., [Circular], [undefined])
+      func: '\x1b[90m', // Dim (function string representations)
+    },
+    solarized: {
+      reset: '\x1b[0m',
+      key: '\x1b[38;5;37m',
+      string: '\x1b[38;5;136m',
+      string_url: '\x1b[38;5;33m',
+      string_bool: '\x1b[38;5;166m',
+      string_number: '\x1b[38;5;136m',
+      number: '\x1b[38;5;136m',
+      boolean: '\x1b[38;5;166m',
+      null: '\x1b[38;5;241m',
+      special: '\x1b[38;5;160m',
+      func: '\x1b[38;5;244m',
+    },
+    monokai: {
+      reset: '\x1b[0m',
+      key: '\x1b[38;5;81m',
+      string: '\x1b[38;5;114m',
+      string_url: '\x1b[38;5;75m',
+      string_bool: '\x1b[38;5;204m',
+      string_number: '\x1b[38;5;221m',
+      number: '\x1b[38;5;221m',
+      boolean: '\x1b[38;5;204m',
+      null: '\x1b[38;5;241m',
+      special: '\x1b[38;5;160m',
+      func: '\x1b[38;5;102m',
+    },
+  };
+
+  /**
+   * Constructs a new instance with an optional base preset or custom override.
+   * @param {ColorsList} [defaultColors] - Optional override for the default color scheme.
+   */
+  constructor(defaultColors = {}) {
+    this.#colors = { ...ColorSafeStringify.#PRESETS.default, ...defaultColors };
+  }
+
+  /**
+   * Internal method to apply ANSI color codes to different parts of a JSON string.
+   * @param {string} str - Raw JSON string to be colorized.
+   * @param {ColorsList} colors - ANSI color mapping to be applied to each JSON element type.
+   * @returns {string} Colorized JSON string.
+   */
+  #colorizeJSON(str, colors) {
+    /** @type {{ marker: string, key: string }[]} */
+    const keyMatches = [];
+
+    // Colorize numeric values
+    str = str.replace(
+      /(?<!")\b(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b(?!")/g,
+      `${colors.number}$1${colors.reset}`,
+    );
+
+    // Replace keys with temporary markers for later colorization
+    str = str.replace(/"([^"]+)":/g, (_, key) => {
+      const marker = `___KEY${keyMatches.length}___`;
+      keyMatches.push({ marker, key });
+      return `${marker}:`; // Keep the colon for valid syntax
+    });
+
+    // Replace strings and apply specific colors based on their content
+    str = str.replace(/"(?:\\.|[^"\\])*?"/g, (match) => {
+      const val = match.slice(1, -1); // Remove surrounding quotes
+
+      if (/^(https?|ftp):\/\/[^\s]+$/i.test(val)) {
+        return `${colors.string_url}${match}${colors.reset}`;
+      }
+
+      if (/^(true|false|null)$/.test(val)) {
+        return `${colors.string_bool}${match}${colors.reset}`;
+      }
+
+      if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(val)) {
+        return `${colors.string_number}${match}${colors.reset}`;
+      }
+
+      return `${colors.string}${match}${colors.reset}`;
+    });
+
+    // Replace markers with colorized keys
+    for (const { marker, key } of keyMatches) {
+      const regex = new RegExp(marker, 'g');
+      str = str.replace(regex, `${colors.key}"${key}"${colors.reset}`);
+    }
+
+    // Colorize boolean values
+    str = str.replace(/(?<!")\b(true|false)\b(?!")/g, `${colors.boolean}$1${colors.reset}`);
+
+    // Colorize null values
+    str = str.replace(/(?<!")\bnull\b(?!")/g, `${colors.null}null${colors.reset}`);
+
+    // Highlight special placeholder values
+    str = str.replace(/\[Circular\]/g, `${colors.special}[Circular]${colors.reset}`);
+    str = str.replace(/\[undefined\]/g, `${colors.special}[undefined]${colors.reset}`);
+
+    // Colorize function string representations
+    str = str.replace(/"function.*?[^\\]"/gs, `${colors.func}$&${colors.reset}`);
+    return str;
+  }
+
+  /**
+   * Colorizes a JSON string using the active or optionally overridden color set.
+   * @param {string} json - The JSON string to format.
+   * @param {ColorsList} [customColors] - Optional temporary color override.
+   * @returns {string}
+   */
+  colorize(json, customColors = {}) {
+    const colors = { ...this.#colors, ...customColors };
+    return this.#colorizeJSON(json, colors);
+  }
+
+  /**
+   * Returns the currently active color scheme.
+   * @returns {ColorsList}
+   */
+  getColors() {
+    return { ...this.#colors };
+  }
+
+  /**
+   * Updates the current color scheme with a partial override.
+   * @param {Partial<ColorsList>} newColors
+   */
+  updateColors(newColors) {
+    Object.assign(this.#colors, newColors);
+  }
+
+  /**
+   * Resets the current color scheme to the default preset.
+   */
+  resetColors() {
+    this.#colors = { ...ColorSafeStringify.#PRESETS.default };
+  }
+
+  /**
+   * Loads a color preset by name.
+   * @param {string} presetName - Name of the preset to load.
+   * @throws Will throw if the preset doesn't exist.
+   */
+  loadColorPreset(presetName) {
+    const preset = ColorSafeStringify.#PRESETS[presetName];
+    if (!preset) throw new Error(`Preset "${presetName}" not found.`);
+    this.#colors = { ...preset };
+  }
+
+  /**
+   * Saves a new custom color preset.
+   * @param {string} name - Name of the new preset.
+   * @param {ColorsList} colors - ANSI color map to save.
+   */
+  saveColorPreset(name, colors) {
+    ColorSafeStringify.#PRESETS[name] = { ...colors };
+  }
+
+  /**
+   * Returns a list of all available color preset names.
+   * @returns {string[]}
+   */
+  getAvailablePresets() {
+    return Object.keys(ColorSafeStringify.#PRESETS);
+  }
+}
+
+module.exports = ColorSafeStringify;

package/dist/v1/libs/ColorSafeStringify.d.mts

@@ -0,0 +1,62 @@
+export default ColorSafeStringify;
+/**
+ * Represents a mapping of color keys to ANSI escape codes.
+ */
+export type ColorsList = Record<string, string>;
+/**
+ * @typedef {Record<string, string>} ColorsList
+ * Represents a mapping of color keys to ANSI escape codes.
+ */
+declare class ColorSafeStringify {
+    /**
+     * Preset collections (internal and user-defined).
+     * @type {Record<string, ColorsList>}
+     * @static
+     */
+    static "__#1@#PRESETS": Record<string, ColorsList>;
+    /**
+     * Constructs a new instance with an optional base preset or custom override.
+     * @param {ColorsList} [defaultColors] - Optional override for the default color scheme.
+     */
+    constructor(defaultColors?: ColorsList);
+    /**
+     * Colorizes a JSON string using the active or optionally overridden color set.
+     * @param {string} json - The JSON string to format.
+     * @param {ColorsList} [customColors] - Optional temporary color override.
+     * @returns {string}
+     */
+    colorize(json: string, customColors?: ColorsList): string;
+    /**
+     * Returns the currently active color scheme.
+     * @returns {ColorsList}
+     */
+    getColors(): ColorsList;
+    /**
+     * Updates the current color scheme with a partial override.
+     * @param {Partial<ColorsList>} newColors
+     */
+    updateColors(newColors: Partial<ColorsList>): void;
+    /**
+     * Resets the current color scheme to the default preset.
+     */
+    resetColors(): void;
+    /**
+     * Loads a color preset by name.
+     * @param {string} presetName - Name of the preset to load.
+     * @throws Will throw if the preset doesn't exist.
+     */
+    loadColorPreset(presetName: string): void;
+    /**
+     * Saves a new custom color preset.
+     * @param {string} name - Name of the new preset.
+     * @param {ColorsList} colors - ANSI color map to save.
+     */
+    saveColorPreset(name: string, colors: ColorsList): void;
+    /**
+     * Returns a list of all available color preset names.
+     * @returns {string[]}
+     */
+    getAvailablePresets(): string[];
+    #private;
+}
+//# sourceMappingURL=ColorSafeStringify.d.mts.map

package/dist/v1/libs/ColorSafeStringify.mjs

@@ -0,0 +1,168 @@
+/**
+ * @typedef {Record<string, string>} ColorsList
+ * Represents a mapping of color keys to ANSI escape codes.
+ */
+class ColorSafeStringify {
+    /**
+     * Currently active color configuration.
+     * @type {ColorsList}
+     */
+    #colors;
+    /**
+     * Preset collections (internal and user-defined).
+     * @type {Record<string, ColorsList>}
+     * @static
+     */
+    static #PRESETS = {
+        default: {
+            reset: '\x1b[0m',
+            key: '\x1b[36m', // Cyan (object keys)
+            string: '\x1b[32m', // Green (regular strings)
+            string_url: '\x1b[34m', // Blue (URLs)
+            string_bool: '\x1b[35m', // Magenta (boolean/null in string form)
+            string_number: '\x1b[33m', // Yellow (numbers in string form)
+            number: '\x1b[33m', // Yellow (raw numbers)
+            boolean: '\x1b[35m', // Magenta (true/false)
+            null: '\x1b[1;30m', // Gray (null)
+            special: '\x1b[31m', // Red (e.g., [Circular], [undefined])
+            func: '\x1b[90m', // Dim (function string representations)
+        },
+        solarized: {
+            reset: '\x1b[0m',
+            key: '\x1b[38;5;37m',
+            string: '\x1b[38;5;136m',
+            string_url: '\x1b[38;5;33m',
+            string_bool: '\x1b[38;5;166m',
+            string_number: '\x1b[38;5;136m',
+            number: '\x1b[38;5;136m',
+            boolean: '\x1b[38;5;166m',
+            null: '\x1b[38;5;241m',
+            special: '\x1b[38;5;160m',
+            func: '\x1b[38;5;244m',
+        },
+        monokai: {
+            reset: '\x1b[0m',
+            key: '\x1b[38;5;81m',
+            string: '\x1b[38;5;114m',
+            string_url: '\x1b[38;5;75m',
+            string_bool: '\x1b[38;5;204m',
+            string_number: '\x1b[38;5;221m',
+            number: '\x1b[38;5;221m',
+            boolean: '\x1b[38;5;204m',
+            null: '\x1b[38;5;241m',
+            special: '\x1b[38;5;160m',
+            func: '\x1b[38;5;102m',
+        },
+    };
+    /**
+     * Constructs a new instance with an optional base preset or custom override.
+     * @param {ColorsList} [defaultColors] - Optional override for the default color scheme.
+     */
+    constructor(defaultColors = {}) {
+        this.#colors = { ...ColorSafeStringify.#PRESETS.default, ...defaultColors };
+    }
+    /**
+     * Internal method to apply ANSI color codes to different parts of a JSON string.
+     * @param {string} str - Raw JSON string to be colorized.
+     * @param {ColorsList} colors - ANSI color mapping to be applied to each JSON element type.
+     * @returns {string} Colorized JSON string.
+     */
+    #colorizeJSON(str, colors) {
+        /** @type {{ marker: string, key: string }[]} */
+        const keyMatches = [];
+        // Colorize numeric values
+        str = str.replace(/(?<!")\b(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b(?!")/g, `${colors.number}$1${colors.reset}`);
+        // Replace keys with temporary markers for later colorization
+        str = str.replace(/"([^"]+)":/g, (_, key) => {
+            const marker = `___KEY${keyMatches.length}___`;
+            keyMatches.push({ marker, key });
+            return `${marker}:`; // Keep the colon for valid syntax
+        });
+        // Replace strings and apply specific colors based on their content
+        str = str.replace(/"(?:\\.|[^"\\])*?"/g, (match) => {
+            const val = match.slice(1, -1); // Remove surrounding quotes
+            if (/^(https?|ftp):\/\/[^\s]+$/i.test(val)) {
+                return `${colors.string_url}${match}${colors.reset}`;
+            }
+            if (/^(true|false|null)$/.test(val)) {
+                return `${colors.string_bool}${match}${colors.reset}`;
+            }
+            if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(val)) {
+                return `${colors.string_number}${match}${colors.reset}`;
+            }
+            return `${colors.string}${match}${colors.reset}`;
+        });
+        // Replace markers with colorized keys
+        for (const { marker, key } of keyMatches) {
+            const regex = new RegExp(marker, 'g');
+            str = str.replace(regex, `${colors.key}"${key}"${colors.reset}`);
+        }
+        // Colorize boolean values
+        str = str.replace(/(?<!")\b(true|false)\b(?!")/g, `${colors.boolean}$1${colors.reset}`);
+        // Colorize null values
+        str = str.replace(/(?<!")\bnull\b(?!")/g, `${colors.null}null${colors.reset}`);
+        // Highlight special placeholder values
+        str = str.replace(/\[Circular\]/g, `${colors.special}[Circular]${colors.reset}`);
+        str = str.replace(/\[undefined\]/g, `${colors.special}[undefined]${colors.reset}`);
+        // Colorize function string representations
+        str = str.replace(/"function.*?[^\\]"/gs, `${colors.func}$&${colors.reset}`);
+        return str;
+    }
+    /**
+     * Colorizes a JSON string using the active or optionally overridden color set.
+     * @param {string} json - The JSON string to format.
+     * @param {ColorsList} [customColors] - Optional temporary color override.
+     * @returns {string}
+     */
+    colorize(json, customColors = {}) {
+        const colors = { ...this.#colors, ...customColors };
+        return this.#colorizeJSON(json, colors);
+    }
+    /**
+     * Returns the currently active color scheme.
+     * @returns {ColorsList}
+     */
+    getColors() {
+        return { ...this.#colors };
+    }
+    /**
+     * Updates the current color scheme with a partial override.
+     * @param {Partial<ColorsList>} newColors
+     */
+    updateColors(newColors) {
+        Object.assign(this.#colors, newColors);
+    }
+    /**
+     * Resets the current color scheme to the default preset.
+     */
+    resetColors() {
+        this.#colors = { ...ColorSafeStringify.#PRESETS.default };
+    }
+    /**
+     * Loads a color preset by name.
+     * @param {string} presetName - Name of the preset to load.
+     * @throws Will throw if the preset doesn't exist.
+     */
+    loadColorPreset(presetName) {
+        const preset = ColorSafeStringify.#PRESETS[presetName];
+        if (!preset)
+            throw new Error(`Preset "${presetName}" not found.`);
+        this.#colors = { ...preset };
+    }
+    /**
+     * Saves a new custom color preset.
+     * @param {string} name - Name of the new preset.
+     * @param {ColorsList} colors - ANSI color map to save.
+     */
+    saveColorPreset(name, colors) {
+        ColorSafeStringify.#PRESETS[name] = { ...colors };
+    }
+    /**
+     * Returns a list of all available color preset names.
+     * @returns {string[]}
+     */
+    getAvailablePresets() {
+        return Object.keys(ColorSafeStringify.#PRESETS);
+    }
+}
+export default ColorSafeStringify;

package/docs/README.md

@@ -12,16 +12,17 @@ Here, you can navigate through different sections of the project. Below are the
 
 This folder contains the core scripts we have worked on so far. Each file is a module focused on specific functionality.
 
-- 📦 **[array.md](./basics/array.md)** — A tiny utility for shuffling arrays using the Fisher–Yates algorithm.
-- ⏰ **[clock.md](./basics/clock.md)** — A versatile time utility module for calculating and formatting time durations.
-- 🧠 **[objFilter.md](./basics/objFilter.md)** — Type detection, extension, and analysis made easy with simple and extensible type validation.
-- 🔢 **[simpleMath.md](./basics/simpleMath.md)** — A collection of simple math utilities for calculations like the Rule of Three and percentages.
-- ✍️ **[text.md](./basics/text.md)** — A utility for transforming text into title case formats, with multiple options for capitalization.
-- 🔄 **[asyncReplace.md](./basics/asyncReplace.md)** — Asynchronously replaces matches in a string using a regex and an async function.
+- 📦 **[array](./basics/array.md)** — A tiny utility for shuffling arrays using the Fisher–Yates algorithm.
+- ⏰ **[clock](./basics/clock.md)** — A versatile time utility module for calculating and formatting time durations.
+- 🧠 **[objFilter](./basics/objFilter.md)** — Type detection, extension, and analysis made easy with simple and extensible type validation.
+- 🔢 **[simpleMath](./basics/simpleMath.md)** — A collection of simple math utilities for calculations like the Rule of Three and percentages.
+- ✍️ **[text](./basics/text.md)** — A utility for transforming text into title case formats, with multiple options for capitalization.
+- 🔄 **[asyncReplace](./basics/asyncReplace.md)** — Asynchronously replaces matches in a string using a regex and an async function.
 
 ### 2. **`libs/`**
-- 🗂️ **[TinyPromiseQueue.md](./libs/TinyPromiseQueue.md)** — A class that allows sequential execution of asynchronous tasks, supporting task delays, cancellation, and queue management.
-- 🏅 **[TinyLevelUp.md](./libs/TinyLevelUp.md)** — A class to manage user level-up logic based on experience points, providing methods for experience validation, addition, removal, and calculation.
+- 🗂️ **[TinyPromiseQueue](./libs/TinyPromiseQueue.md)** — A class that allows sequential execution of asynchronous tasks, supporting task delays, cancellation, and queue management.
+- 🏅 **[TinyLevelUp](./libs/TinyLevelUp.md)** — A class to manage user level-up logic based on experience points, providing methods for experience validation, addition, removal, and calculation.
+- 🎨 **[ColorSafeStringify](./libs/ColorSafeStringify.md)** — A utility for applying customizable ANSI colors to JSON strings in terminal outputs, supporting presets and fine-grained type-based highlighting.
 
 ---
 

package/docs/basics/objFilter.md

@@ -151,3 +151,9 @@ Here’s a full list of supported type names (in their default order):
 - `object`
 
 You can change this order or insert your own types with `extendObjType`.
+
+---
+
+### 🛠️ `getCheckObj()`
+
+This function creates a clone of the functions from the `typeValidator` object. It returns a new object where the keys are the same and the values are the cloned functions.

package/docs/libs/ColorSafeStringify.md

@@ -0,0 +1,145 @@
+# 🎨 Color Safe Stringify
+
+Color Safe Stringify is a lightweight JavaScript class for transforming boring JSON strings into colorful, readable terminal output using ANSI escape codes. Whether you're debugging, logging, or just want your JSONs to sparkle a bit more, this tool is here to help ✨
+
+---
+
+## 🚀 Features
+
+- 🎯 **Syntax-aware highlighting**: Keys, strings, numbers, booleans, nulls, functions, URLs, and special values each get their own color.
+- 🎨 **Customizable presets**: Built-in themes like `default`, `solarized`, and `monokai` — and you can even define your own!
+- 🔧 **Dynamic updates**: Change only the parts of the color scheme you want.
+- 🧠 **Smart detection**: Differentiates between strings that *look* like booleans/numbers/URLs and real primitives.
+- 🔁 **Safe formatting**: No circular structure errors — you can prepare your JSON ahead and color it afterward.
+
+---
+
+## 📦 Installation
+
+This library is designed to work in any Node.js environment:
+
+```bash
+npm install safe-stable-stringify
+```
+
+Then import both the stable stringifier and `ColorSafeStringify`:
+
+```js
+import stringify from 'safe-stable-stringify';
+import { ColorSafeStringify } from 'tiny-essentials';
+```
+
+---
+
+## 🧪 Usage Example
+
+```js
+const colorizer = new ColorSafeStringify();
+
+const jsonObject = {
+  name: "Yasmin",
+  age: 27,
+  website: "https://equestria.social/@jasmindreasond",
+  active: true,
+  notes: null,
+  big: BigInt(1234567890),
+  greet: () => "Hi!",
+  nested: {
+    color: "rainbow 🌈",
+  },
+};
+
+// Stringify safely first
+const jsonStr = stringify(jsonObject, null, 2);
+
+// Apply beautiful colors
+console.log(colorizer.colorize(jsonStr));
+```
+
+---
+
+## 🎨 Built-in Presets
+
+- `default` - a balanced palette with good terminal compatibility
+- `solarized` - warm, low-contrast colors inspired by Solarized theme
+- `monokai` - a bright and modern syntax-style theme
+
+Use them like so:
+
+```js
+colorizer.loadColorPreset("monokai");
+```
+
+---
+
+## 🧁 Create Your Own Preset
+
+You can save your own custom preset:
+
+```js
+colorizer.saveColorPreset('candy', {
+  reset: '\x1b[0m',
+  key: '\x1b[95m',
+  string: '\x1b[91m',
+  string_url: '\x1b[35m',
+  string_bool: '\x1b[95m',
+  string_number: '\x1b[91m',
+  number: '\x1b[91m',
+  boolean: '\x1b[95m',
+  null: '\x1b[90m',
+  special: '\x1b[31m',
+  func: '\x1b[35m',
+});
+
+colorizer.loadColorPreset('candy');
+```
+
+---
+
+## 🔧 API
+
+### `new ColorSafeStringify([defaultColors])`
+
+Creates a new colorizer with optional color overrides.
+
+### `.colorize(jsonString, [customColors])`
+
+Returns a colorized string using current or temporary color settings.
+
+### `.getColors()`
+
+Returns the current color scheme.
+
+### `.updateColors(partialColors)`
+
+Updates only specific color keys in the active scheme.
+
+### `.resetColors()`
+
+Resets to the default preset.
+
+### `.loadColorPreset(name)`
+
+Loads a preset by name. Throws an error if it doesn't exist.
+
+### `.saveColorPreset(name, colors)`
+
+Saves a new custom preset.
+
+### `.getAvailablePresets()`
+
+Returns an array of all available preset names.
+
+---
+
+## 🤖 Best Practices
+
+- Use `safe-stable-stringify` or equivalent to avoid issues with functions, circular references, and BigInt.
+- Always apply coloring *after* serialization.
+- For advanced highlighting, use proper typing for values (avoid turning everything into strings!).
+
+---
+
+## 🧚 Why?
+
+Plain JSON is fine… but colored JSON? That’s ✨ **magical** ✨ — and way easier on the eyes when you're reading logs, inspecting complex structures, or debugging live servers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiny-essentials",
-  "version": "1.7.1",
+  "version": "1.8.1",
   "description": "Collection of small, essential scripts designed to be used across various projects. These simple utilities are crafted for speed, ease of use, and versatility.",
   "scripts": {
     "test": "npm run test:mjs && npm run test:cjs && npm run test:js",
@@ -9,6 +9,7 @@
     "test:mjs": "node test/index.mjs",
     "test:mjs:promisequeue": "node test/index.mjs promiseQueue",
     "test:mjs:objtype": "node test/index.mjs objType",
+    "test:mjs:jsoncolor": "node test/index.mjs colorStringify",
     "fix:prettier": "npm run fix:prettier:src && npm run fix:prettier:test && npm run fix:prettier:rollup.config && npm run fix:prettier:webpack.config",
     "fix:prettier:src": "prettier --write ./src/*",
     "fix:prettier:test": "prettier --write ./test/*",
@@ -48,7 +49,12 @@
     "text",
     "lib",
     "time",
-    "shuffle-array"
+    "shuffle-array",
+    "json-color",
+    "terminal-color",
+    "cli-output",
+    "colorize-json",
+    "pretty-print-json"
   ],
   "author": "Yasmin Seidel (Jasmin Dreasond)",
   "license": "GPL-3.0-only",
@@ -82,6 +88,7 @@
     "prettier": "3.5.3",
     "rollup": "^4.40.0",
     "rollup-preserve-directives": "^1.1.3",
+    "safe-stable-stringify": "^2.5.0",
     "sass": "^1.87.0",
     "tinycolor2": "^1.6.0",
     "tslib": "^2.8.1",