@chainlink/external-adapter-framework 2.12.0 → 2.13.1

package/generator-adapter/node_modules/p-queue/dist/index.js

@@ -16,6 +16,10 @@ export default class PQueue extends EventEmitter {
     #lastExecutionTime = 0;
     #intervalId;
     #timeoutId;
+    #strict;
+    // Circular buffer implementation for better performance
+    #strictTicks = [];
+    #strictTicksStartIndex = 0;
     #queue;
     #queueClass;
     #pending = 0;
@@ -52,6 +56,7 @@ export default class PQueue extends EventEmitter {
             concurrency: Number.POSITIVE_INFINITY,
             autoStart: true,
             queueClass: PriorityQueue,
+            strict: false,
             ...options,
         };
         if (!(typeof options.intervalCap === 'number' && options.intervalCap >= 1)) {
@@ -60,12 +65,19 @@ export default class PQueue extends EventEmitter {
         if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {
             throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ''}\` (${typeof options.interval})`);
         }
+        if (options.strict && options.interval === 0) {
+            throw new TypeError('The `strict` option requires a non-zero `interval`');
+        }
+        if (options.strict && options.intervalCap === Number.POSITIVE_INFINITY) {
+            throw new TypeError('The `strict` option requires a finite `intervalCap`');
+        }
         // TODO: Remove this fallback in the next major version
         // eslint-disable-next-line @typescript-eslint/no-deprecated
         this.#carryoverIntervalCount = options.carryoverIntervalCount ?? options.carryoverConcurrencyCount ?? false;
         this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
         this.#intervalCap = options.intervalCap;
         this.#interval = options.interval;
+        this.#strict = options.strict;
         this.#queue = new options.queueClass();
         this.#queueClass = options.queueClass;
         this.concurrency = options.concurrency;
@@ -76,8 +88,58 @@ export default class PQueue extends EventEmitter {
         this.#isPaused = options.autoStart === false;
         this.#setupRateLimitTracking();
     }
+    #cleanupStrictTicks(now) {
+        // Remove ticks outside the current interval window using circular buffer approach
+        while (this.#strictTicksStartIndex < this.#strictTicks.length) {
+            const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+            if (oldestTick !== undefined && now - oldestTick >= this.#interval) {
+                this.#strictTicksStartIndex++;
+            }
+            else {
+                break;
+            }
+        }
+        // Compact the array when it becomes inefficient or fully consumed
+        // Compact when: (start index is large AND more than half wasted) OR all ticks expired
+        const shouldCompact = (this.#strictTicksStartIndex > 100 && this.#strictTicksStartIndex > this.#strictTicks.length / 2)
+            || this.#strictTicksStartIndex === this.#strictTicks.length;
+        if (shouldCompact) {
+            this.#strictTicks = this.#strictTicks.slice(this.#strictTicksStartIndex);
+            this.#strictTicksStartIndex = 0;
+        }
+    }
+    // Helper methods for interval consumption
+    #consumeIntervalSlot(now) {
+        if (this.#strict) {
+            this.#strictTicks.push(now);
+        }
+        else {
+            this.#intervalCount++;
+        }
+    }
+    #rollbackIntervalSlot() {
+        if (this.#strict) {
+            // Pop from the end of the actual data (not from start index)
+            if (this.#strictTicks.length > this.#strictTicksStartIndex) {
+                this.#strictTicks.pop();
+            }
+        }
+        else if (this.#intervalCount > 0) {
+            this.#intervalCount--;
+        }
+    }
+    #getActiveTicksCount() {
+        return this.#strictTicks.length - this.#strictTicksStartIndex;
+    }
     get #doesIntervalAllowAnother() {
-        return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
+        if (this.#isIntervalIgnored) {
+            return true;
+        }
+        if (this.#strict) {
+            // Cleanup already done by #isIntervalPausedAt before this is called
+            return this.#getActiveTicksCount() < this.#intervalCap;
+        }
+        return this.#intervalCount < this.#intervalCap;
     }
     get #doesConcurrentAllowAnother() {
         return this.#pending < this.#concurrency;
@@ -91,12 +153,28 @@ export default class PQueue extends EventEmitter {
         this.emit('next');
     }
     #onResumeInterval() {
-        this.#onInterval(); // Already schedules update
-        this.#initializeIntervalIfNeeded();
+        // Clear timeout ID before processing to prevent race condition
+        // Must clear before #onInterval to allow new timeouts to be scheduled
         this.#timeoutId = undefined;
+        this.#onInterval();
+        this.#initializeIntervalIfNeeded();
     }
-    get #isIntervalPaused() {
-        const now = Date.now();
+    #isIntervalPausedAt(now) {
+        // Strict mode: check if we need to wait for oldest tick to age out
+        if (this.#strict) {
+            this.#cleanupStrictTicks(now);
+            // If at capacity, need to wait for oldest tick to age out
+            const activeTicksCount = this.#getActiveTicksCount();
+            if (activeTicksCount >= this.#intervalCap) {
+                const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+                // After cleanup, remaining ticks are within interval, so delay is always > 0
+                const delay = this.#interval - (now - oldestTick);
+                this.#createIntervalTimeout(delay);
+                return true;
+            }
+            return false;
+        }
+        // Fixed window mode (original logic)
         if (this.#intervalId === undefined) {
             const delay = this.#intervalEnd - now;
             if (delay < 0) {
@@ -151,22 +229,26 @@ export default class PQueue extends EventEmitter {
             if (this.#pending === 0) {
                 // Clear timeout as well when completely idle
                 this.#clearTimeoutTimer();
+                // Compact strict ticks when idle to free memory
+                if (this.#strict && this.#strictTicksStartIndex > 0) {
+                    const now = Date.now();
+                    this.#cleanupStrictTicks(now);
+                }
                 this.emit('idle');
             }
             return false;
         }
         let taskStarted = false;
         if (!this.#isPaused) {
-            const canInitializeInterval = !this.#isIntervalPaused;
+            const now = Date.now();
+            const canInitializeInterval = !this.#isIntervalPausedAt(now);
             if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
                 const job = this.#queue.dequeue();
-                // Increment interval count immediately to prevent race conditions
                 if (!this.#isIntervalIgnored) {
-                    this.#intervalCount++;
+                    this.#consumeIntervalSlot(now);
                     this.#scheduleRateLimitUpdate();
                 }
                 this.emit('active');
-                this.#lastExecutionTime = Date.now();
                 job();
                 if (canInitializeInterval) {
                     this.#initializeIntervalIfNeeded();
@@ -180,16 +262,23 @@ export default class PQueue extends EventEmitter {
         if (this.#isIntervalIgnored || this.#intervalId !== undefined) {
             return;
         }
+        // Strict mode uses timeouts instead of interval timers
+        if (this.#strict) {
+            return;
+        }
         this.#intervalId = setInterval(() => {
             this.#onInterval();
         }, this.#interval);
         this.#intervalEnd = Date.now() + this.#interval;
     }
     #onInterval() {
-        if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
-            this.#clearIntervalTimer();
+        // Non-strict mode uses interval timers and intervalCount
+        if (!this.#strict) {
+            if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
+                this.#clearIntervalTimer();
+            }
+            this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
         }
-        this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
         this.#processQueue();
         this.#scheduleRateLimitUpdate();
     }
@@ -253,11 +342,12 @@ export default class PQueue extends EventEmitter {
         this.#queue.setPriority(id, priority);
     }
     async add(function_, options = {}) {
-        // In case `id` is not defined.
-        options.id ??= (this.#idAssigner++).toString();
+        // Create a copy to avoid mutating the original options object
         options = {
             timeout: this.timeout,
             ...options,
+            // Assign unique ID if not provided
+            id: options.id ?? (this.#idAssigner++).toString(),
         };
         return new Promise((resolve, reject) => {
             // Create a unique symbol for tracking this task
@@ -279,14 +369,12 @@ export default class PQueue extends EventEmitter {
                         options.signal?.throwIfAborted();
                     }
                     catch (error) {
-                        // Decrement the counter that was already incremented
-                        if (!this.#isIntervalIgnored) {
-                            this.#intervalCount--;
-                        }
+                        this.#rollbackIntervalConsumption();
                         // Clean up tracking before throwing
                         this.#runningTasks.delete(taskSymbol);
                         throw error;
                     }
+                    this.#lastExecutionTime = Date.now();
                     let operation = function_({ signal: options.signal });
                     if (options.timeout) {
                         operation = pTimeout(Promise.resolve(operation), {
@@ -353,10 +441,22 @@ export default class PQueue extends EventEmitter {
     */
     clear() {
         this.#queue = new this.#queueClass();
+        // Clear interval timer since queue is now empty (consistent with #tryToStartAnother)
+        this.#clearIntervalTimer();
+        // Note: We preserve strict mode rate-limiting state (ticks and timeout)
+        // because clear() only clears queued tasks, not rate limit history.
+        // This ensures that rate limits are still enforced after clearing the queue.
         // Note: We don't clear #runningTasks as those tasks are still running
         // They will be removed when they complete in the finally block
         // Force synchronous update since clear() should have immediate effect
         this.#updateRateLimitState();
+        // Emit events so waiters (onEmpty, onIdle, onSizeLessThan) can resolve
+        this.emit('empty');
+        if (this.#pending === 0) {
+            this.#clearTimeoutTimer();
+            this.emit('idle');
+        }
+        this.emit('next');
     }
     /**
     Can be called multiple times. Useful if you for example add additional items at a later time.
@@ -455,7 +555,7 @@ export default class PQueue extends EventEmitter {
     ```
     */
     // eslint-disable-next-line @typescript-eslint/promise-function-async
-    async onError() {
+    onError() {
         return new Promise((_resolve, reject) => {
             const handleError = (error) => {
                 this.off('error', handleError);
@@ -530,11 +630,34 @@ export default class PQueue extends EventEmitter {
             this.#updateRateLimitState();
         });
     }
+    #rollbackIntervalConsumption() {
+        if (this.#isIntervalIgnored) {
+            return;
+        }
+        this.#rollbackIntervalSlot();
+        this.#scheduleRateLimitUpdate();
+    }
     #updateRateLimitState() {
         const previous = this.#rateLimitedInInterval;
-        const shouldBeRateLimited = !this.#isIntervalIgnored
-            && this.#intervalCount >= this.#intervalCap
-            && this.#queue.size > 0;
+        // Early exit if rate limiting is disabled or queue is empty
+        if (this.#isIntervalIgnored || this.#queue.size === 0) {
+            if (previous) {
+                this.#rateLimitedInInterval = false;
+                this.emit('rateLimitCleared');
+            }
+            return;
+        }
+        // Get the current count based on mode
+        let count;
+        if (this.#strict) {
+            const now = Date.now();
+            this.#cleanupStrictTicks(now);
+            count = this.#getActiveTicksCount();
+        }
+        else {
+            count = this.#intervalCount;
+        }
+        const shouldBeRateLimited = count >= this.#intervalCap;
         if (shouldBeRateLimited !== previous) {
             this.#rateLimitedInInterval = shouldBeRateLimited;
             this.emit(shouldBeRateLimited ? 'rateLimit' : 'rateLimitCleared');

package/generator-adapter/node_modules/p-queue/dist/options.d.ts

@@ -67,6 +67,22 @@ export type Options<QueueType extends Queue<RunFunction, QueueOptions>, QueueOpt
     @deprecated Renamed to `carryoverIntervalCount`.
     */
     readonly carryoverConcurrencyCount?: boolean;
+    /**
+    Whether to use strict mode for rate limiting (sliding window algorithm).
+
+    When enabled, ensures that no more than `intervalCap` tasks execute in any rolling `interval` window, rather than resetting the count at fixed intervals. This provides more predictable and evenly distributed execution.
+
+    @default false
+
+    For example, with `intervalCap: 2` and `interval: 1000`:
+    - __Default mode (fixed window)__: Tasks can burst at window boundaries. You could execute 2 tasks at 999ms and 2 more at 1000ms, resulting in 4 tasks within 1ms.
+    - __Strict mode (sliding window)__: Enforces that no more than 2 tasks execute in any 1000ms rolling window, preventing bursts.
+
+    Strict mode is more resource-intensive as it tracks individual execution timestamps. Use it when you need guaranteed rate-limit compliance, such as when interacting with APIs that enforce strict rate limits.
+
+    The `carryoverIntervalCount` option has no effect when `strict` mode is enabled, as strict mode tracks actual execution timestamps rather than counting pending tasks.
+    */
+    readonly strict?: boolean;
 } & TimeoutOptions;
 export type QueueAddOptions = {
     /**
@@ -116,6 +132,6 @@ export type TaskOptions = {
     }
     ```
     */
-    readonly signal?: AbortSignal;
+    readonly signal?: AbortSignal | undefined;
 };
 export {};

package/generator-adapter/node_modules/p-queue/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "p-queue",
-	"version": "9.0.1",
+	"version": "9.1.0",
 	"description": "Promise queue with concurrency control",
 	"license": "MIT",
 	"repository": "sindresorhus/p-queue",

package/generator-adapter/node_modules/p-queue/readme.md

@@ -140,6 +140,25 @@ Default: `false`
 
 If `true`, specifies that any [pending](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) Promises, should be carried over into the next interval and counted against the `intervalCap`. If `false`, any of those pending Promises will not count towards the next `intervalCap`.
 
+##### strict
+
+Type: `boolean`\
+Default: `false`
+
+Whether to use strict mode for rate limiting (sliding window algorithm).
+
+When enabled, ensures that no more than `intervalCap` tasks execute in any rolling `interval` window, rather than resetting the count at fixed intervals. This provides more predictable and evenly distributed execution.
+
+For example, with `intervalCap: 2` and `interval: 1000`:
+- **Default mode (fixed window)**: Tasks can burst at window boundaries. You could execute 2 tasks at 999ms and 2 more at 1000ms, resulting in 4 tasks within 1ms.
+- **Strict mode (sliding window)**: Enforces that no more than 2 tasks execute in any 1000ms rolling window, preventing bursts.
+
+> [!NOTE]
+> Strict mode is more resource-intensive as it tracks individual execution timestamps. Use it when you need guaranteed rate-limit compliance, such as when interacting with APIs that enforce strict rate limits.
+
+> [!NOTE]
+> The `carryoverIntervalCount` option has no effect when `strict` mode is enabled, as strict mode tracks actual execution timestamps rather than counting pending tasks.
+
 ### queue
 
 `PQueue` instance.
@@ -555,7 +574,7 @@ Useful if you for example add additional items at a later time.
 
 #### idle
 
-Emitted every time the queue becomes empty and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+Emitted whenever the queue becomes idle: both empty and with zero running tasks (`size === 0 && pending === 0`). If no tasks are ever added, it never fires.
 
 The difference with `empty` is that `idle` guarantees that all work from the queue has finished. `empty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
 
@@ -828,6 +847,18 @@ const queue = new PQueue({queueClass: QueueClass});
 
 They are just different constraints. The `concurrency` option limits how many things run at the same time. The `intervalCap` option limits how many things run in total during the interval (over time).
 
+#### When should I use `strict` mode for rate limiting?
+
+Use `strict: true` when:
+- You're interacting with APIs that enforce strict rate limits and will throttle or block you if you exceed them, even briefly
+- You've experienced issues with the default fixed window mode (such as [#126](https://github.com/sindresorhus/p-queue/issues/126))
+- You need guaranteed compliance with rate limits for any rolling time window
+
+Use the default fixed window mode when:
+- You don't have strict rate limit requirements
+- Performance is more important than perfect rate limit distribution
+- You're rate limiting for backpressure management rather than external API constraints
+
 #### How do I implement backpressure?
 
 Use `.onSizeLessThan()` to prevent the queue from growing unbounded and causing memory issues when producers are faster than consumers:

package/generator-adapter/node_modules/stdin-discarder/index.js

@@ -1,59 +1,87 @@
 import process from 'node:process';
 
-const ASCII_ETX_CODE = 0x03; // Ctrl+C emits this code
+const ASCII_ETX_CODE = 0x03; // Ctrl+C
 
 class StdinDiscarder {
 	#activeCount = 0;
+	#stdin;
+	#stdinWasPaused = false;
+	#stdinWasRaw = false;
+	#handleInputBound = chunk => {
+		if (!chunk?.length) {
+			return;
+		}
+
+		const code = typeof chunk === 'string' ? chunk.codePointAt(0) : chunk[0];
+		if (code === ASCII_ETX_CODE) {
+			if (process.listenerCount('SIGINT') > 0) {
+				process.emit('SIGINT');
+			} else {
+				process.kill(process.pid, 'SIGINT');
+			}
+		}
+	};
 
 	start() {
 		this.#activeCount++;
-
 		if (this.#activeCount === 1) {
 			this.#realStart();
 		}
 	}
 
 	stop() {
-		if (this.#activeCount <= 0) {
-			throw new Error('`stop` called more times than `start`');
+		if (this.#activeCount === 0) {
+			return;
 		}
 
-		this.#activeCount--;
-
-		if (this.#activeCount === 0) {
+		if (--this.#activeCount === 0) {
 			this.#realStop();
 		}
 	}
 
 	#realStart() {
-		// No known way to make it work reliably on Windows.
-		if (process.platform === 'win32' || !process.stdin.isTTY) {
+		const {stdin} = process;
+
+		if (process.platform === 'win32' || !stdin?.isTTY || typeof stdin.setRawMode !== 'function') {
+			this.#stdin = undefined;
 			return;
 		}
 
-		process.stdin.setRawMode(true);
-		process.stdin.on('data', this.#handleInput);
-		process.stdin.resume();
+		this.#stdin = stdin;
+		this.#stdinWasPaused = stdin.isPaused();
+		this.#stdinWasRaw = Boolean(stdin.isRaw);
+
+		stdin.setRawMode(true);
+		stdin.prependListener('data', this.#handleInputBound);
+
+		if (this.#stdinWasPaused) {
+			stdin.resume();
+		}
 	}
 
 	#realStop() {
-		if (!process.stdin.isTTY) {
+		if (!this.#stdin) {
 			return;
 		}
 
-		process.stdin.off('data', this.#handleInput);
-		process.stdin.pause();
-		process.stdin.setRawMode(false);
-	}
+		const stdin = this.#stdin;
 
-	#handleInput(chunk) {
-		// Allow Ctrl+C to gracefully exit.
-		if (chunk[0] === ASCII_ETX_CODE) {
-			process.emit('SIGINT');
+		stdin.off('data', this.#handleInputBound);
+
+		if (stdin.isTTY) {
+			stdin.setRawMode?.(this.#stdinWasRaw);
+		}
+
+		if (this.#stdinWasPaused) {
+			stdin.pause();
 		}
+
+		this.#stdin = undefined;
+		this.#stdinWasPaused = false;
+		this.#stdinWasRaw = false;
 	}
 }
 
 const stdinDiscarder = new StdinDiscarder();
 
-export default stdinDiscarder;
+export default Object.freeze(stdinDiscarder);

package/generator-adapter/node_modules/stdin-discarder/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "stdin-discarder",
-	"version": "0.2.2",
+	"version": "0.3.1",
 	"description": "Discard stdin input except for Ctrl+C",
 	"license": "MIT",
 	"repository": "sindresorhus/stdin-discarder",

package/generator-adapter/node_modules/{ora → yeoman-generator}/node_modules/chalk/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "chalk",
-	"version": "5.6.2",
+	"version": "5.3.0",
 	"description": "Terminal string styling done right",
 	"license": "MIT",
 	"repository": "chalk/chalk",
@@ -16,7 +16,6 @@
 		}
 	},
 	"types": "./source/index.d.ts",
-	"sideEffects": false,
 	"engines": {
 		"node": "^12.17.0 || ^14.13 || >=16.0.0"
 	},
@@ -59,9 +58,10 @@
 		"log-update": "^5.0.0",
 		"matcha": "^0.7.0",
 		"tsd": "^0.19.0",
-		"xo": "^0.57.0",
+		"xo": "^0.53.0",
 		"yoctodelay": "^2.0.0"
 	},
+	"sideEffects": false,
 	"xo": {
 		"rules": {
 			"unicorn/prefer-string-slice": "off",

package/generator-adapter/node_modules/{ora → yeoman-generator}/node_modules/chalk/readme.md

@@ -12,13 +12,59 @@
 [![Coverage Status](https://codecov.io/gh/chalk/chalk/branch/main/graph/badge.svg)](https://codecov.io/gh/chalk/chalk)
 [![npm dependents](https://badgen.net/npm/dependents/chalk)](https://www.npmjs.com/package/chalk?activeTab=dependents)
 [![Downloads](https://badgen.net/npm/dt/chalk)](https://www.npmjs.com/package/chalk)
+[![run on repl.it](https://img.shields.io/badge/Run_on_Replit-f26207?logo=replit&logoColor=white)](https://repl.it/github/chalk/chalk)
 
 ![](media/screenshot.png)
 
-## Info
-
-- [Why not switch to a smaller coloring package?](https://github.com/chalk/chalk?tab=readme-ov-file#why-not-switch-to-a-smaller-coloring-package)
-- See [yoctocolors](https://github.com/sindresorhus/yoctocolors) for a smaller alternative
+<br>
+
+---
+
+<div align="center">
+	<p>
+		<p>
+			<sup>
+				Sindre Sorhus' open source work is supported by the community on <a href="https://github.com/sponsors/sindresorhus">GitHub Sponsors</a>
+			</sup>
+		</p>
+		<sup>Special thanks to:</sup>
+		<br>
+		<br>
+		<a href="https://standardresume.co/tech">
+			<img src="https://sindresorhus.com/assets/thanks/standard-resume-logo.svg" width="160">
+		</a>
+		<br>
+		<br>
+		<a href="https://retool.com/?utm_campaign=sindresorhus">
+			<img src="https://sindresorhus.com/assets/thanks/retool-logo.svg" width="230">
+		</a>
+		<br>
+		<br>
+		<a href="https://strapi.io/?ref=sindresorhus">
+			<div>
+				<img src="https://sindresorhus.com/assets/thanks/strapi-logo-white-bg.png" width="220" alt="Strapi">
+			</div>
+			<b>Strapi is the leading open-source headless CMS.</b>
+			<div>
+				<sup>It’s 100% JavaScript, fully customizable, and developer-first.</sup>
+			</div>
+		</a>
+		<br>
+		<br>
+		<a href="https://www.stackaid.us/?utm_campaign=sindre">
+			<div>
+				<img src="https://sindresorhus.com/assets/thanks/stackaid-logo.png" width="230" alt="StackAid">
+			</div>
+			<b>Fund your open source dependencies</b>
+		</a>
+		<br>
+		<br>
+	</p>
+</div>
+
+---
+
+<br>
 
 ## Highlights
 
@@ -31,7 +77,7 @@
 - Doesn't extend `String.prototype`
 - Clean and focused
 - Actively maintained
-- [Used by ~115,000 packages](https://www.npmjs.com/browse/depended/chalk) as of July 4, 2024
+- [Used by ~86,000 packages](https://www.npmjs.com/browse/depended/chalk) as of October 4, 2022
 
 ## Install
 
@@ -251,25 +297,9 @@ Since Chrome 69, ANSI escape codes are natively supported in the developer conso
 
 If you're on Windows, do yourself a favor and use [Windows Terminal](https://github.com/microsoft/terminal) instead of `cmd.exe`.
 
-## FAQ
-
-### Why not switch to a smaller coloring package?
-
-Chalk may be larger, but there is a reason for that. It offers a more user-friendly API, well-documented types, supports millions of colors, and covers edge cases that smaller alternatives miss. Chalk is mature, reliable, and built to last.
-
-But beyond the technical aspects, there's something more critical: trust and long-term maintenance. I have been active in open source for over a decade, and I'm committed to keeping Chalk maintained. Smaller packages might seem appealing now, but there's no guarantee they will be around for the long term, or that they won't become malicious over time.
-
-Chalk is also likely already in your dependency tree (since 100K+ packages depend on it), so switching won’t save space—in fact, it might increase it. npm deduplicates dependencies, so multiple Chalk instances turn into one, but adding another package alongside it will increase your overall size.
+## Origin story
 
-If the goal is to clean up the ecosystem, switching away from Chalk won’t even make a dent. The real problem lies with packages that have very deep dependency trees (for example, those including a lot of polyfills). Chalk has no dependencies. It's better to focus on impactful changes rather than minor optimizations.
-
-If absolute package size is important to you, I also maintain [yoctocolors](https://github.com/sindresorhus/yoctocolors), one of the smallest color packages out there.
-
-*\- [Sindre](https://github.com/sindresorhus)*
-
-### But the smaller coloring package has benchmarks showing it is faster
-
-[Micro-benchmarks are flawed](https://sindresorhus.com/blog/micro-benchmark-fallacy) because they measure performance in unrealistic, isolated scenarios, often giving a distorted view of real-world performance. Don't believe marketing fluff. All the coloring packages are more than fast enough.
+[colors.js](https://github.com/Marak/colors.js) used to be the most popular string styling module, but it has serious deficiencies like extending `String.prototype` which causes all kinds of [problems](https://github.com/yeoman/yo/issues/68) and the package is unmaintained. Although there are other packages, they either do too much or not enough. Chalk is a clean and focused alternative.
 
 ## Related
 
@@ -289,8 +319,6 @@ If absolute package size is important to you, I also maintain [yoctocolors](http
 - [chalk-pipe](https://github.com/LitoMore/chalk-pipe) - Create chalk style schemes with simpler style strings
 - [terminal-link](https://github.com/sindresorhus/terminal-link) - Create clickable links in the terminal
 
-*(Not accepting additional entries)*
-
 ## Maintainers
 
 - [Sindre Sorhus](https://github.com/sindresorhus)

package/generator-adapter/node_modules/{ora → yeoman-generator}/node_modules/chalk/source/index.d.ts

@@ -1,12 +1,7 @@
 // TODO: Make it this when TS suports that.
 // import {ModifierName, ForegroundColor, BackgroundColor, ColorName} from '#ansi-styles';
 // import {ColorInfo, ColorSupportLevel} from '#supports-color';
-import {
-	ModifierName,
-	ForegroundColorName,
-	BackgroundColorName,
-	ColorName,
-} from './vendor/ansi-styles/index.js';
+import {ModifierName, ForegroundColorName, BackgroundColorName, ColorName} from './vendor/ansi-styles/index.js';
 import {ColorInfo, ColorSupportLevel} from './vendor/supports-color/index.js';
 
 export interface Options {