first commit

node_modules/.bin/acorn

@@ -0,0 +1 @@
+../acorn/bin/acorn

node_modules/.bin/ejs

@@ -0,0 +1 @@
+../ejs/bin/cli.js

node_modules/.bin/escodegen

@@ -0,0 +1 @@
+../escodegen/bin/escodegen.js

node_modules/.bin/esgenerate

@@ -0,0 +1 @@
+../escodegen/bin/esgenerate.js

node_modules/.bin/eslint

@@ -0,0 +1 @@
+../eslint/bin/eslint.js

node_modules/.bin/esparse

@@ -0,0 +1 @@
+../esprima/bin/esparse.js

node_modules/.bin/esvalidate

@@ -0,0 +1 @@
+../esprima/bin/esvalidate.js

node_modules/.bin/giget

@@ -0,0 +1 @@
+../giget/dist/cli.mjs

node_modules/.bin/glob

@@ -0,0 +1 @@
+../glob/dist/esm/bin.mjs

node_modules/.bin/handlebars

@@ -0,0 +1 @@
+../handlebars/bin/handlebars

node_modules/.bin/is-docker

@@ -0,0 +1 @@
+../is-docker/cli.js

node_modules/.bin/is-inside-container

@@ -0,0 +1 @@
+../is-inside-container/cli.js

node_modules/.bin/jake

@@ -0,0 +1 @@
+../jake/bin/cli.js

node_modules/.bin/jiti

@@ -0,0 +1 @@
+../jiti/lib/jiti-cli.mjs

node_modules/.bin/js-yaml

@@ -0,0 +1 @@
+../js-yaml/bin/js-yaml.js

node_modules/.bin/n8n-node

@@ -0,0 +1 @@
+../@n8n/node-cli/bin/n8n-node.mjs

node_modules/.bin/napi-postinstall

@@ -0,0 +1 @@
+../napi-postinstall/lib/cli.js

node_modules/.bin/node-which

@@ -0,0 +1 @@
+../which/bin/node-which

node_modules/.bin/nypm

@@ -0,0 +1 @@
+../nypm/dist/cli.mjs

node_modules/.bin/prettier

@@ -0,0 +1 @@
+../prettier/bin/prettier.cjs

node_modules/.bin/release-it

@@ -0,0 +1 @@
+../release-it/bin/release-it.js

node_modules/.bin/rimraf

@@ -0,0 +1 @@
+../rimraf/dist/esm/bin.mjs

node_modules/.bin/semver

@@ -0,0 +1 @@
+../semver/bin/semver.js

node_modules/.bin/slugify

@@ -0,0 +1 @@
+../transliteration/dist/bin/slugify

node_modules/.bin/transliterate

@@ -0,0 +1 @@
+../transliteration/dist/bin/transliterate

node_modules/.bin/tsc

@@ -0,0 +1 @@
+../typescript/bin/tsc

node_modules/.bin/tsserver

@@ -0,0 +1 @@
+../typescript/bin/tsserver

node_modules/.bin/uglifyjs

@@ -0,0 +1 @@
+../uglify-js/bin/uglifyjs

node_modules/@clack/core/CHANGELOG.md

@@ -0,0 +1,263 @@
+# @clack/core
+
+## 0.5.0
+
+### Minor Changes
+
+- 07ca32d: Reverted a change where placeholders were being set as values on return.
+
+## 0.4.2
+
+### Patch Changes
+
+- 30aa7ed: Adds a new `selectableGroups` boolean to the group multi-select prompt. Using `selectableGroups: false` will disable the ability to select a top-level group, but still allow every child to be selected individually.
+- 5dfce8a: Fixes an edge case for placeholder values. Previously, when pressing `enter` on an empty prompt, placeholder values would be ignored. Now, placeholder values are treated as the prompt value.
+- f574297: Fix "TTY initialization failed: uv_tty_init returned EBADF (bad file descriptor)" error happening on Windows for non-tty terminals.
+
+## 0.4.1
+
+### Patch Changes
+
+- 8093f3c: Adds `Error` support to the `validate` function
+- e5ba09a: Fixes a cursor display bug in terminals that do not support the "hidden" escape sequence. See [Issue #127](https://github.com/bombshell-dev/clack/issues/127).
+- 8cba8e3: Fixes a rendering bug with cursor positions for `TextPrompt`
+
+## 0.4.0
+
+### Minor Changes
+
+- a83d2f8: Adds a new `updateSettings()` function to support new global keybindings.
+
+  `updateSettings()` accepts an `aliases` object that maps custom keys to an action (`up | down | left | right | space | enter | cancel`).
+
+  ```ts
+  import { updateSettings } from "@clack/core";
+
+  // Support custom keybindings
+  updateSettings({
+    aliases: {
+      w: "up",
+      a: "left",
+      s: "down",
+      d: "right",
+    },
+  });
+  ```
+
+> [!WARNING]
+> In order to enforce consistent, user-friendly defaults across the ecosystem, `updateSettings` does not support disabling Clack's default keybindings.
+
+- 801246b: Adds a new `signal` option to support programmatic prompt cancellation with an [abort controller](https://kettanaito.com/blog/dont-sleep-on-abort-controller).
+
+- a83d2f8: Updates default keybindings to support Vim motion shortcuts and map the `escape` key to cancel (`ctrl+c`).
+
+  | alias | action |
+  | ----- | ------ |
+  | `k`   | up     |
+  | `l`   | right  |
+  | `j`   | down   |
+  | `h`   | left   |
+  | `esc` | cancel |
+
+### Patch Changes
+
+- 51e12bc: Improves types for events and interaction states.
+
+## 0.3.5
+
+### Patch Changes
+
+- 4845f4f: Fixes a bug which kept the terminal cursor hidden after a prompt is cancelled
+- d7b2fb9: Adds missing `LICENSE` file. Since the `package.json` file has always included `"license": "MIT"`, please consider this a licensing clarification rather than a licensing change.
+
+## 0.3.4
+
+### Patch Changes
+
+- a04e418: fix(@clack/core): keyboard input not working after await in spinner
+- 4f6fcf5: feat(@clack/core): allow tab completion for placeholders
+
+## 0.3.3
+
+### Patch Changes
+
+- cd79076: fix: restore raw mode on unblock
+
+## 0.3.2
+
+### Patch Changes
+
+- c96eda5: Enable hard line-wrapping behavior for long words without spaces
+
+## 0.3.1
+
+### Patch Changes
+
+- 58a1df1: Fix line duplication bug by automatically wrapping prompts to `process.stdout.columns`
+
+## 0.3.0
+
+### Minor Changes
+
+- 8a4a12f: Add `GroupMultiSelect` prompt
+
+### Patch Changes
+
+- 8a4a12f: add `groupMultiselect` prompt
+
+## 0.2.1
+
+### Patch Changes
+
+- ec812b6: fix `readline` hang on Windows
+
+## 0.2.0
+
+### Minor Changes
+
+- d74dd05: Adds a `selectKey` prompt type
+- 54c1bc3: **Breaking Change** `multiselect` has renamed `initialValue` to `initialValues`
+
+## 0.1.9
+
+### Patch Changes
+
+- 1251132: Multiselect: return `Value[]` instead of `Option[]`.
+- 8994382: Add a password prompt to `@clack/prompts`
+
+## 0.1.8
+
+### Patch Changes
+
+- d96071c: Don't mutate `initialValue` in `multiselect`, fix parameter type for `validate()`.
+
+  Credits to @banjo for the bug report and initial PR!
+
+## 0.1.7
+
+### Patch Changes
+
+- 6d9e675: Add support for neovim cursor motion (`hjkl`)
+
+  Thanks [@esau-morais](https://github.com/esau-morais) for the assist!
+
+## 0.1.6
+
+### Patch Changes
+
+- 7fb5375: Adds a new `defaultValue` option to the text prompt, removes automatic usage of the placeholder value.
+
+## 0.1.5
+
+### Patch Changes
+
+- de1314e: Support `required` option for multi-select
+
+## 0.1.4
+
+### Patch Changes
+
+- ca77da1: Fix multiselect initial value logic
+- 8aed606: Fix `MaxListenersExceededWarning` by detaching `stdin` listeners on close
+
+## 0.1.3
+
+### Patch Changes
+
+- a99c458: Support `initialValue` option for text prompt
+
+## 0.1.2
+
+### Patch Changes
+
+- Allow isCancel to type guard any unknown value
+- 7dcad8f: Allow placeholder to be passed to TextPrompt
+- 2242f13: Fix multiselect returning undefined
+- b1341d6: Improved placeholder handling
+
+## 0.1.1
+
+### Patch Changes
+
+- 4be7dbf: Ensure raw mode is unset on submit
+- b480679: Preserve value if validation fails
+
+## 0.1.0
+
+### Minor Changes
+
+- 7015ec9: Create new prompt: multi-select
+
+## 0.0.12
+
+### Patch Changes
+
+- 9d371c3: Fix rendering bug when using y/n to confirm
+
+## 0.0.11
+
+### Patch Changes
+
+- 441d5b7: fix select return undefined
+- d20ef2a: Update keywords, URLs
+- fe13c2f: fix cursor missing after submit
+
+## 0.0.10
+
+### Patch Changes
+
+- a0cb382: Add `main` entrypoint
+
+## 0.0.9
+
+### Patch Changes
+
+- Fix node@16 issue (cannot read "createInterface" of undefined)
+
+## 0.0.8
+
+### Patch Changes
+
+- a4b5e13: Bug fixes, exposes `block` utility
+
+## 0.0.7
+
+### Patch Changes
+
+- Fix cursor bug
+
+## 0.0.6
+
+### Patch Changes
+
+- Fix error with character check
+
+## 0.0.5
+
+### Patch Changes
+
+- 491f9e0: update readme
+
+## 0.0.4
+
+### Patch Changes
+
+- 7372d5c: Fix bug with line deletion
+
+## 0.0.3
+
+### Patch Changes
+
+- 5605d28: Do not bundle dependencies (take II)
+
+## 0.0.2
+
+### Patch Changes
+
+- 2ee67cb: don't bundle deps
+
+## 0.0.1
+
+### Patch Changes
+
+- 306598e: Initial publish, still WIP

node_modules/@clack/core/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Nate Moore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@clack/core/README.md

@@ -0,0 +1,22 @@
+# `@clack/core`
+
+Clack contains low-level primitives for implementing your own command-line applications.
+
+Currently, `TextPrompt`, `SelectPrompt`, and `ConfirmPrompt` are exposed as well as the base `Prompt` class.
+
+Each `Prompt` accepts a `render` function.
+
+```js
+import { TextPrompt, isCancel } from '@clack/core';
+
+const p = new TextPrompt({
+  render() {
+    return `What's your name?\n${this.valueWithCursor}`;
+  },
+});
+
+const name = await p.prompt();
+if (isCancel(name)) {
+  process.exit(0);
+}
+```

node_modules/@clack/core/dist/index.d.cts

@@ -0,0 +1,211 @@
+import { Readable, Writable } from 'node:stream';
+
+declare const actions: readonly ["up", "down", "left", "right", "space", "enter", "cancel"];
+type Action = (typeof actions)[number];
+interface ClackSettings {
+    /**
+     * Set custom global aliases for the default actions.
+     * This will not overwrite existing aliases, it will only add new ones!
+     *
+     * @param aliases - An object that maps aliases to actions
+     * @default { k: 'up', j: 'down', h: 'left', l: 'right', '\x03': 'cancel', 'escape': 'cancel' }
+     */
+    aliases: Record<string, Action>;
+}
+declare function updateSettings(updates: ClackSettings): void;
+
+/**
+ * The state of the prompt
+ */
+type ClackState = 'initial' | 'active' | 'cancel' | 'submit' | 'error';
+/**
+ * Typed event emitter for clack
+ */
+interface ClackEvents {
+    initial: (value?: any) => void;
+    active: (value?: any) => void;
+    cancel: (value?: any) => void;
+    submit: (value?: any) => void;
+    error: (value?: any) => void;
+    cursor: (key?: Action) => void;
+    key: (key?: string) => void;
+    value: (value?: string) => void;
+    confirm: (value?: boolean) => void;
+    finalize: () => void;
+}
+
+interface PromptOptions<Self extends Prompt> {
+    render(this: Omit<Self, 'prompt'>): string | undefined;
+    placeholder?: string;
+    initialValue?: any;
+    validate?: ((value: any) => string | Error | undefined) | undefined;
+    input?: Readable;
+    output?: Writable;
+    debug?: boolean;
+    signal?: AbortSignal;
+}
+declare class Prompt {
+    protected input: Readable;
+    protected output: Writable;
+    private _abortSignal?;
+    private rl;
+    private opts;
+    private _render;
+    private _track;
+    private _prevFrame;
+    private _subscribers;
+    protected _cursor: number;
+    state: ClackState;
+    error: string;
+    value: any;
+    constructor(options: PromptOptions<Prompt>, trackValue?: boolean);
+    /**
+     * Unsubscribe all listeners
+     */
+    protected unsubscribe(): void;
+    /**
+     * Set a subscriber with opts
+     * @param event - The event name
+     */
+    private setSubscriber;
+    /**
+     * Subscribe to an event
+     * @param event - The event name
+     * @param cb - The callback
+     */
+    on<T extends keyof ClackEvents>(event: T, cb: ClackEvents[T]): void;
+    /**
+     * Subscribe to an event once
+     * @param event - The event name
+     * @param cb - The callback
+     */
+    once<T extends keyof ClackEvents>(event: T, cb: ClackEvents[T]): void;
+    /**
+     * Emit an event with data
+     * @param event - The event name
+     * @param data - The data to pass to the callback
+     */
+    emit<T extends keyof ClackEvents>(event: T, ...data: Parameters<ClackEvents[T]>): void;
+    prompt(): Promise<string | symbol>;
+    private onKeypress;
+    protected close(): void;
+    private restoreCursor;
+    private render;
+}
+
+interface ConfirmOptions extends PromptOptions<ConfirmPrompt> {
+    active: string;
+    inactive: string;
+    initialValue?: boolean;
+}
+declare class ConfirmPrompt extends Prompt {
+    get cursor(): 0 | 1;
+    private get _value();
+    constructor(opts: ConfirmOptions);
+}
+
+interface GroupMultiSelectOptions<T extends {
+    value: any;
+}> extends PromptOptions<GroupMultiSelectPrompt<T>> {
+    options: Record<string, T[]>;
+    initialValues?: T['value'][];
+    required?: boolean;
+    cursorAt?: T['value'];
+    selectableGroups?: boolean;
+}
+declare class GroupMultiSelectPrompt<T extends {
+    value: any;
+}> extends Prompt {
+    #private;
+    options: (T & {
+        group: string | boolean;
+    })[];
+    cursor: number;
+    getGroupItems(group: string): T[];
+    isGroupSelected(group: string): boolean;
+    private toggleValue;
+    constructor(opts: GroupMultiSelectOptions<T>);
+}
+
+interface MultiSelectOptions<T extends {
+    value: any;
+}> extends PromptOptions<MultiSelectPrompt<T>> {
+    options: T[];
+    initialValues?: T['value'][];
+    required?: boolean;
+    cursorAt?: T['value'];
+}
+declare class MultiSelectPrompt<T extends {
+    value: any;
+}> extends Prompt {
+    options: T[];
+    cursor: number;
+    private get _value();
+    private toggleAll;
+    private toggleValue;
+    constructor(opts: MultiSelectOptions<T>);
+}
+
+interface PasswordOptions extends PromptOptions<PasswordPrompt> {
+    mask?: string;
+}
+declare class PasswordPrompt extends Prompt {
+    valueWithCursor: string;
+    private _mask;
+    get cursor(): number;
+    get masked(): any;
+    constructor({ mask, ...opts }: PasswordOptions);
+}
+
+interface SelectOptions<T extends {
+    value: any;
+}> extends PromptOptions<SelectPrompt<T>> {
+    options: T[];
+    initialValue?: T['value'];
+}
+declare class SelectPrompt<T extends {
+    value: any;
+}> extends Prompt {
+    options: T[];
+    cursor: number;
+    private get _value();
+    private changeValue;
+    constructor(opts: SelectOptions<T>);
+}
+
+interface SelectKeyOptions<T extends {
+    value: any;
+}> extends PromptOptions<SelectKeyPrompt<T>> {
+    options: T[];
+}
+declare class SelectKeyPrompt<T extends {
+    value: any;
+}> extends Prompt {
+    options: T[];
+    cursor: number;
+    constructor(opts: SelectKeyOptions<T>);
+}
+
+interface TextOptions extends PromptOptions<TextPrompt> {
+    placeholder?: string;
+    defaultValue?: string;
+}
+declare class TextPrompt extends Prompt {
+    get valueWithCursor(): any;
+    get cursor(): number;
+    constructor(opts: TextOptions);
+}
+
+declare function isCancel(value: unknown): value is symbol;
+declare function block({ input, output, overwrite, hideCursor, }?: {
+    input?: (NodeJS.ReadStream & {
+        fd: 0;
+    }) | undefined;
+    output?: (NodeJS.WriteStream & {
+        fd: 1;
+    }) | undefined;
+    overwrite?: boolean | undefined;
+    hideCursor?: boolean | undefined;
+}): () => void;
+
+export { type ClackSettings, ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, PasswordPrompt, Prompt, SelectKeyPrompt, SelectPrompt, type ClackState as State, TextPrompt, block, isCancel, updateSettings };

node_modules/@clack/core/dist/index.d.mts

@@ -0,0 +1,211 @@
+import { Readable, Writable } from 'node:stream';
+
+declare const actions: readonly ["up", "down", "left", "right", "space", "enter", "cancel"];
+type Action = (typeof actions)[number];
+interface ClackSettings {
+    /**
+     * Set custom global aliases for the default actions.
+     * This will not overwrite existing aliases, it will only add new ones!
+     *
+     * @param aliases - An object that maps aliases to actions
+     * @default { k: 'up', j: 'down', h: 'left', l: 'right', '\x03': 'cancel', 'escape': 'cancel' }
+     */
+    aliases: Record<string, Action>;
+}
+declare function updateSettings(updates: ClackSettings): void;
+
+/**
+ * The state of the prompt
+ */
+type ClackState = 'initial' | 'active' | 'cancel' | 'submit' | 'error';
+/**
+ * Typed event emitter for clack
+ */
+interface ClackEvents {
+    initial: (value?: any) => void;
+    active: (value?: any) => void;
+    cancel: (value?: any) => void;
+    submit: (value?: any) => void;
+    error: (value?: any) => void;
+    cursor: (key?: Action) => void;
+    key: (key?: string) => void;
+    value: (value?: string) => void;
+    confirm: (value?: boolean) => void;
+    finalize: () => void;
+}
+
+interface PromptOptions<Self extends Prompt> {
+    render(this: Omit<Self, 'prompt'>): string | undefined;
+    placeholder?: string;
+    initialValue?: any;
+    validate?: ((value: any) => string | Error | undefined) | undefined;
+    input?: Readable;
+    output?: Writable;
+    debug?: boolean;
+    signal?: AbortSignal;
+}
+declare class Prompt {
+    protected input: Readable;
+    protected output: Writable;
+    private _abortSignal?;
+    private rl;
+    private opts;
+    private _render;
+    private _track;
+    private _prevFrame;
+    private _subscribers;
+    protected _cursor: number;
+    state: ClackState;
+    error: string;
+    value: any;
+    constructor(options: PromptOptions<Prompt>, trackValue?: boolean);
+    /**
+     * Unsubscribe all listeners
+     */
+    protected unsubscribe(): void;
+    /**
+     * Set a subscriber with opts
+     * @param event - The event name
+     */
+    private setSubscriber;
+    /**
+     * Subscribe to an event
+     * @param event - The event name
+     * @param cb - The callback
+     */
+    on<T extends keyof ClackEvents>(event: T, cb: ClackEvents[T]): void;
+    /**
+     * Subscribe to an event once
+     * @param event - The event name
+     * @param cb - The callback
+     */
+    once<T extends keyof ClackEvents>(event: T, cb: ClackEvents[T]): void;
+    /**
+     * Emit an event with data
+     * @param event - The event name
+     * @param data - The data to pass to the callback
+     */
+    emit<T extends keyof ClackEvents>(event: T, ...data: Parameters<ClackEvents[T]>): void;
+    prompt(): Promise<string | symbol>;
+    private onKeypress;
+    protected close(): void;
+    private restoreCursor;
+    private render;
+}
+
+interface ConfirmOptions extends PromptOptions<ConfirmPrompt> {
+    active: string;
+    inactive: string;
+    initialValue?: boolean;
+}
+declare class ConfirmPrompt extends Prompt {
+    get cursor(): 0 | 1;
+    private get _value();
+    constructor(opts: ConfirmOptions);
+}
+
+interface GroupMultiSelectOptions<T extends {
+    value: any;
+}> extends PromptOptions<GroupMultiSelectPrompt<T>> {
+    options: Record<string, T[]>;
+    initialValues?: T['value'][];
+    required?: boolean;
+    cursorAt?: T['value'];
+    selectableGroups?: boolean;
+}
+declare class GroupMultiSelectPrompt<T extends {
+    value: any;
+}> extends Prompt {
+    #private;
+    options: (T & {
+        group: string | boolean;
+    })[];
+    cursor: number;
+    getGroupItems(group: string): T[];
+    isGroupSelected(group: string): boolean;
+    private toggleValue;
+    constructor(opts: GroupMultiSelectOptions<T>);
+}
+
+interface MultiSelectOptions<T extends {
+    value: any;
+}> extends PromptOptions<MultiSelectPrompt<T>> {
+    options: T[];
+    initialValues?: T['value'][];
+    required?: boolean;
+    cursorAt?: T['value'];
+}
+declare class MultiSelectPrompt<T extends {
+    value: any;
+}> extends Prompt {
+    options: T[];
+    cursor: number;
+    private get _value();
+    private toggleAll;
+    private toggleValue;
+    constructor(opts: MultiSelectOptions<T>);
+}
+
+interface PasswordOptions extends PromptOptions<PasswordPrompt> {
+    mask?: string;
+}
+declare class PasswordPrompt extends Prompt {
+    valueWithCursor: string;
+    private _mask;
+    get cursor(): number;
+    get masked(): any;
+    constructor({ mask, ...opts }: PasswordOptions);
+}
+
+interface SelectOptions<T extends {
+    value: any;
+}> extends PromptOptions<SelectPrompt<T>> {
+    options: T[];
+    initialValue?: T['value'];
+}
+declare class SelectPrompt<T extends {
+    value: any;
+}> extends Prompt {
+    options: T[];
+    cursor: number;
+    private get _value();
+    private changeValue;
+    constructor(opts: SelectOptions<T>);
+}
+
+interface SelectKeyOptions<T extends {
+    value: any;
+}> extends PromptOptions<SelectKeyPrompt<T>> {
+    options: T[];
+}
+declare class SelectKeyPrompt<T extends {
+    value: any;
+}> extends Prompt {
+    options: T[];
+    cursor: number;
+    constructor(opts: SelectKeyOptions<T>);
+}
+
+interface TextOptions extends PromptOptions<TextPrompt> {
+    placeholder?: string;
+    defaultValue?: string;
+}
+declare class TextPrompt extends Prompt {
+    get valueWithCursor(): any;
+    get cursor(): number;
+    constructor(opts: TextOptions);
+}
+
+declare function isCancel(value: unknown): value is symbol;
+declare function block({ input, output, overwrite, hideCursor, }?: {
+    input?: (NodeJS.ReadStream & {
+        fd: 0;
+    }) | undefined;
+    output?: (NodeJS.WriteStream & {
+        fd: 1;
+    }) | undefined;
+    overwrite?: boolean | undefined;
+    hideCursor?: boolean | undefined;
+}): () => void;
+
+export { type ClackSettings, ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, PasswordPrompt, Prompt, SelectKeyPrompt, SelectPrompt, type ClackState as State, TextPrompt, block, isCancel, updateSettings };

node_modules/@clack/core/dist/index.d.ts

@@ -0,0 +1,211 @@
+import { Readable, Writable } from 'node:stream';
+
+declare const actions: readonly ["up", "down", "left", "right", "space", "enter", "cancel"];
+type Action = (typeof actions)[number];
+interface ClackSettings {
+    /**
+     * Set custom global aliases for the default actions.
+     * This will not overwrite existing aliases, it will only add new ones!
+     *
+     * @param aliases - An object that maps aliases to actions
+     * @default { k: 'up', j: 'down', h: 'left', l: 'right', '\x03': 'cancel', 'escape': 'cancel' }
+     */
+    aliases: Record<string, Action>;
+}
+declare function updateSettings(updates: ClackSettings): void;
+
+/**
+ * The state of the prompt
+ */
+type ClackState = 'initial' | 'active' | 'cancel' | 'submit' | 'error';
+/**
+ * Typed event emitter for clack
+ */
+interface ClackEvents {
+    initial: (value?: any) => void;
+    active: (value?: any) => void;
+    cancel: (value?: any) => void;
+    submit: (value?: any) => void;
+    error: (value?: any) => void;
+    cursor: (key?: Action) => void;
+    key: (key?: string) => void;
+    value: (value?: string) => void;
+    confirm: (value?: boolean) => void;
+    finalize: () => void;
+}
+
+interface PromptOptions<Self extends Prompt> {
+    render(this: Omit<Self, 'prompt'>): string | undefined;
+    placeholder?: string;
+    initialValue?: any;
+    validate?: ((value: any) => string | Error | undefined) | undefined;
+    input?: Readable;
+    output?: Writable;
+    debug?: boolean;
+    signal?: AbortSignal;
+}
+declare class Prompt {
+    protected input: Readable;
+    protected output: Writable;
+    private _abortSignal?;
+    private rl;
+    private opts;
+    private _render;
+    private _track;
+    private _prevFrame;
+    private _subscribers;
+    protected _cursor: number;
+    state: ClackState;
+    error: string;
+    value: any;
+    constructor(options: PromptOptions<Prompt>, trackValue?: boolean);
+    /**
+     * Unsubscribe all listeners
+     */
+    protected unsubscribe(): void;
+    /**
+     * Set a subscriber with opts
+     * @param event - The event name
+     */
+    private setSubscriber;
+    /**
+     * Subscribe to an event
+     * @param event - The event name
+     * @param cb - The callback
+     */
+    on<T extends keyof ClackEvents>(event: T, cb: ClackEvents[T]): void;
+    /**
+     * Subscribe to an event once
+     * @param event - The event name
+     * @param cb - The callback
+     */
+    once<T extends keyof ClackEvents>(event: T, cb: ClackEvents[T]): void;
+    /**
+     * Emit an event with data
+     * @param event - The event name
+     * @param data - The data to pass to the callback
+     */
+    emit<T extends keyof ClackEvents>(event: T, ...data: Parameters<ClackEvents[T]>): void;
+    prompt(): Promise<string | symbol>;
+    private onKeypress;
+    protected close(): void;
+    private restoreCursor;
+    private render;
+}
+
+interface ConfirmOptions extends PromptOptions<ConfirmPrompt> {
+    active: string;
+    inactive: string;
+    initialValue?: boolean;
+}
+declare class ConfirmPrompt extends Prompt {
+    get cursor(): 0 | 1;
+    private get _value();
+    constructor(opts: ConfirmOptions);
+}
+
+interface GroupMultiSelectOptions<T extends {
+    value: any;
+}> extends PromptOptions<GroupMultiSelectPrompt<T>> {
+    options: Record<string, T[]>;
+    initialValues?: T['value'][];
+    required?: boolean;
+    cursorAt?: T['value'];
+    selectableGroups?: boolean;
+}
+declare class GroupMultiSelectPrompt<T extends {
+    value: any;
+}> extends Prompt {
+    #private;
+    options: (T & {
+        group: string | boolean;
+    })[];
+    cursor: number;
+    getGroupItems(group: string): T[];
+    isGroupSelected(group: string): boolean;
+    private toggleValue;
+    constructor(opts: GroupMultiSelectOptions<T>);
+}
+
+interface MultiSelectOptions<T extends {
+    value: any;
+}> extends PromptOptions<MultiSelectPrompt<T>> {
+    options: T[];
+    initialValues?: T['value'][];
+    required?: boolean;
+    cursorAt?: T['value'];
+}
+declare class MultiSelectPrompt<T extends {
+    value: any;
+}> extends Prompt {
+    options: T[];
+    cursor: number;
+    private get _value();
+    private toggleAll;
+    private toggleValue;
+    constructor(opts: MultiSelectOptions<T>);
+}
+
+interface PasswordOptions extends PromptOptions<PasswordPrompt> {
+    mask?: string;
+}
+declare class PasswordPrompt extends Prompt {
+    valueWithCursor: string;
+    private _mask;
+    get cursor(): number;
+    get masked(): any;
+    constructor({ mask, ...opts }: PasswordOptions);
+}
+
+interface SelectOptions<T extends {
+    value: any;
+}> extends PromptOptions<SelectPrompt<T>> {
+    options: T[];
+    initialValue?: T['value'];
+}
+declare class SelectPrompt<T extends {
+    value: any;
+}> extends Prompt {
+    options: T[];
+    cursor: number;
+    private get _value();
+    private changeValue;
+    constructor(opts: SelectOptions<T>);
+}
+
+interface SelectKeyOptions<T extends {
+    value: any;
+}> extends PromptOptions<SelectKeyPrompt<T>> {
+    options: T[];
+}
+declare class SelectKeyPrompt<T extends {
+    value: any;
+}> extends Prompt {
+    options: T[];
+    cursor: number;
+    constructor(opts: SelectKeyOptions<T>);
+}
+
+interface TextOptions extends PromptOptions<TextPrompt> {
+    placeholder?: string;
+    defaultValue?: string;
+}
+declare class TextPrompt extends Prompt {
+    get valueWithCursor(): any;
+    get cursor(): number;
+    constructor(opts: TextOptions);
+}
+
+declare function isCancel(value: unknown): value is symbol;
+declare function block({ input, output, overwrite, hideCursor, }?: {
+    input?: (NodeJS.ReadStream & {
+        fd: 0;
+    }) | undefined;
+    output?: (NodeJS.WriteStream & {
+        fd: 1;
+    }) | undefined;
+    overwrite?: boolean | undefined;
+    hideCursor?: boolean | undefined;
+}): () => void;
+
+export { type ClackSettings, ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, PasswordPrompt, Prompt, SelectKeyPrompt, SelectPrompt, type ClackState as State, TextPrompt, block, isCancel, updateSettings };

node_modules/@clack/core/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@clack/core",
+  "version": "0.5.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bombshell-dev/clack.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/bombshell-dev/clack/issues"
+  },
+  "homepage": "https://github.com/bombshell-dev/clack/tree/main/packages/core#readme",
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "ask",
+    "clack",
+    "cli",
+    "command-line",
+    "command",
+    "input",
+    "interact",
+    "interface",
+    "menu",
+    "prompt",
+    "prompts",
+    "stdin",
+    "ui"
+  ],
+  "author": {
+    "name": "Nate Moore",
+    "email": "nate@natemoo.re",
+    "url": "https://twitter.com/n_moore"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "picocolors": "^1.0.0",
+    "sisteransi": "^1.0.5"
+  },
+  "devDependencies": {
+    "vitest": "^1.6.0",
+    "wrap-ansi": "^8.1.0"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "test": "vitest run"
+  }
+}

node_modules/@clack/prompts/CHANGELOG.md

@@ -0,0 +1,423 @@
+# @clack/prompts
+
+## 0.11.0
+
+### Minor Changes
+
+- 07ca32d: Reverted a change where placeholders were being set as values on return.
+
+### Patch Changes
+
+- Updated dependencies [07ca32d]
+  - @clack/core@0.5.0
+
+## 0.10.1
+
+### Patch Changes
+
+- 11a5dc1: Fixes multiselect only shows hints on the first item in the options list. Now correctly shows hints for all selected options with hint property.
+- 30aa7ed: Adds a new `selectableGroups` boolean to the group multi-select prompt. Using `selectableGroups: false` will disable the ability to select a top-level group, but still allow every child to be selected individually.
+- Updated dependencies [30aa7ed]
+- Updated dependencies [5dfce8a]
+- Updated dependencies [f574297]
+  - @clack/core@0.4.2
+
+## 0.10.0
+
+### Minor Changes
+
+- 613179d: Adds a new `indicator` option to `spinner`, which supports the original `"dots"` loading animation or a new `"timer"` loading animation.
+
+  ```ts
+  import * as p from "@clack/prompts";
+
+  const spin = p.spinner({ indicator: "timer" });
+  spin.start("Loading");
+  await sleep(3000);
+  spin.stop("Loaded");
+  ```
+
+- a38b2bc: Adds `stream` API which provides the same methods as `log`, but for iterable (even async) message streams. This is particularly useful for AI responses which are dynamically generated by LLMs.
+
+  ```ts
+  import * as p from "@clack/prompts";
+
+  await p.stream.step(
+    (async function* () {
+      yield* generateLLMResponse(question);
+    })()
+  );
+  ```
+
+## 0.9.1
+
+### Patch Changes
+
+- 8093f3c: Adds `Error` support to the `validate` function
+- 98925e3: Exports the `Option` type and improves JSDocannotations
+- 1904e57: Replace custom utility for stripping ANSI control sequences with Node's built-in [`stripVTControlCharacters`](https://nodejs.org/docs/latest/api/util.html#utilstripvtcontrolcharactersstr) utility.
+- Updated dependencies [8093f3c]
+- Updated dependencies [e5ba09a]
+- Updated dependencies [8cba8e3]
+  - @clack/core@0.4.1
+
+## 0.9.0
+
+### Minor Changes
+
+- a83d2f8: Adds a new `updateSettings()` function to support new global keybindings.
+
+  `updateSettings()` accepts an `aliases` object that maps custom keys to an action (`up | down | left | right | space | enter | cancel`).
+
+  ```ts
+  import { updateSettings } from "@clack/prompts";
+
+  // Support custom keybindings
+  updateSettings({
+    aliases: {
+      w: "up",
+      a: "left",
+      s: "down",
+      d: "right",
+    },
+  });
+  ```
+
+> [!WARNING]
+> In order to enforce consistent, user-friendly defaults across the ecosystem, `updateSettings` does not support disabling Clack's default keybindings.
+
+- 801246b: Adds a new `signal` option to support programmatic prompt cancellation with an [abort controller](https://kettanaito.com/blog/dont-sleep-on-abort-controller).
+
+  One example use case is automatically cancelling a prompt after a timeout.
+
+  ```ts
+  const shouldContinue = await confirm({
+    message: "This message will self destruct in 5 seconds",
+    signal: AbortSignal.timeout(5000),
+  });
+  ```
+
+  Another use case is racing a long running task with a manual prompt.
+
+  ```ts
+  const abortController = new AbortController();
+
+  const projectType = await Promise.race([
+    detectProjectType({
+      signal: abortController.signal,
+    }),
+    select({
+      message: "Pick a project type.",
+      options: [
+        { value: "ts", label: "TypeScript" },
+        { value: "js", label: "JavaScript" },
+        { value: "coffee", label: "CoffeeScript", hint: "oh no" },
+      ],
+      signal: abortController.signal,
+    }),
+  ]);
+
+  abortController.abort();
+  ```
+
+- a83d2f8: Updates default keybindings to support Vim motion shortcuts and map the `escape` key to cancel (`ctrl+c`).
+
+  | alias | action |
+  | ----- | ------ |
+  | `k`   | up     |
+  | `l`   | right  |
+  | `j`   | down   |
+  | `h`   | left   |
+  | `esc` | cancel |
+
+### Patch Changes
+
+- f9f139d: Adapts `spinner` output for static CI environments
+- Updated dependencies [a83d2f8]
+- Updated dependencies [801246b]
+- Updated dependencies [a83d2f8]
+- Updated dependencies [51e12bc]
+  - @clack/core@0.4.0
+
+## 0.8.2
+
+### Patch Changes
+
+- Updated dependencies [4845f4f]
+- Updated dependencies [d7b2fb9]
+  - @clack/core@0.3.5
+
+## 0.8.1
+
+### Patch Changes
+
+- 360afeb: feat: adaptative max items
+
+## 0.8.0
+
+### Minor Changes
+
+- 9acccde: Add tasks function for executing tasks in spinners
+
+### Patch Changes
+
+- b5c6b9b: Feat multiselect maxItems option
+- 50ed94a: fix: clear `spinner` hooks on `spinner.stop`
+- Updated dependencies [a04e418]
+- Updated dependencies [4f6fcf5]
+  - @clack/core@0.3.4
+
+## 0.7.0
+
+### Minor Changes
+
+- b27a701: add maxItems option to select prompt
+- 89371be: added a new method called `spinner.message(msg: string)`
+
+### Patch Changes
+
+- 52183c4: Fix `spinner` conflict with terminal on error between `spinner.start()` and `spinner.stop()`
+- ab51d29: Fixes cases where the note title length was miscalculated due to ansi characters
+- Updated dependencies [cd79076]
+  - @clack/core@0.3.3
+
+## 0.6.3
+
+### Patch Changes
+
+- c96eda5: Enable hard line-wrapping behavior for long words without spaces
+- Updated dependencies [c96eda5]
+  - @clack/core@0.3.2
+
+## 0.6.2
+
+### Patch Changes
+
+- 58a1df1: Fix line duplication bug by automatically wrapping prompts to `process.stdout.columns`
+- Updated dependencies [58a1df1]
+  - @clack/core@0.3.1
+
+## 0.6.1
+
+### Patch Changes
+
+- ca08fb6: Support complex value types for `select`, `multiselect` and `groupMultiselect`.
+
+## 0.6.0
+
+### Minor Changes
+
+- 8a4a12f: add `groupMultiselect` prompt
+- 165a1b3: Add `log` APIs. Supports `log.info`, `log.success`, `log.warn`, and `log.error`. For low-level control, `log.message` is also exposed.
+
+### Patch Changes
+
+- Updated dependencies [8a4a12f]
+- Updated dependencies [8a4a12f]
+  - @clack/core@0.3.0
+
+## 0.5.1
+
+### Patch Changes
+
+- cc11917: Update default `password` mask
+- Updated dependencies [ec812b6]
+  - @clack/core@0.2.1
+
+## 0.5.0
+
+### Minor Changes
+
+- d74dd05: Adds a `selectKey` prompt type
+- 54c1bc3: **Breaking Change** `multiselect` has renamed `initialValue` to `initialValues`
+
+### Patch Changes
+
+- Updated dependencies [d74dd05]
+- Updated dependencies [54c1bc3]
+  - @clack/core@0.2.0
+
+## 0.4.5
+
+### Patch Changes
+
+- 1251132: Multiselect: return `Value[]` instead of `Option[]`.
+- 8994382: Add a password prompt to `@clack/prompts`
+- Updated dependencies [1251132]
+- Updated dependencies [8994382]
+  - @clack/core@0.1.9
+
+## 0.4.4
+
+### Patch Changes
+
+- d96071c: Don't mutate `initialValue` in `multiselect`, fix parameter type for `validate()`.
+
+  Credits to @banjo for the bug report and initial PR!
+
+- Updated dependencies [d96071c]
+  - @clack/core@0.1.8
+
+## 0.4.3
+
+### Patch Changes
+
+- 83d890e: Fix text cancel display bug
+
+## 0.4.2
+
+### Patch Changes
+
+- Update README
+
+## 0.4.1
+
+### Patch Changes
+
+- 7fb5375: Adds a new `defaultValue` option to the text prompt, removes automatic usage of the placeholder value.
+- Updated dependencies [7fb5375]
+  - @clack/core@0.1.6
+
+## 0.4.0
+
+### Minor Changes
+
+- 61b88b6: Add `group` construct to group many prompts together
+
+### Patch Changes
+
+- de1314e: Support `required` option for multi-select
+- Updated dependencies [de1314e]
+  - @clack/core@0.1.5
+
+## 0.3.0
+
+### Minor Changes
+
+- 493c592: Improve types for select/multiselect prompts. Numbers and booleans are now supported as the `value` option.
+- 15558e3: Improved Windows/non-unicode support
+
+### Patch Changes
+
+- ca77da1: Fix multiselect initial value logic
+- Updated dependencies [ca77da1]
+- Updated dependencies [8aed606]
+  - @clack/core@0.1.4
+
+## 0.2.2
+
+### Patch Changes
+
+- 94b24d9: Fix CJS `ansi-regex` interop
+
+## 0.2.1
+
+### Patch Changes
+
+- a99c458: Support `initialValue` option for text prompt
+- Updated dependencies [a99c458]
+  - @clack/core@0.1.3
+
+## 0.2.0
+
+### Minor Changes
+
+- Improved type safety
+- b1341d6: Updated styles, new note component
+
+### Patch Changes
+
+- Updated dependencies [7dcad8f]
+- Updated dependencies [2242f13]
+- Updated dependencies [b1341d6]
+  - @clack/core@0.1.2
+
+## 0.1.1
+
+### Patch Changes
+
+- fa09bf5: Use circle for radio, square for checkbox
+- Updated dependencies [4be7dbf]
+- Updated dependencies [b480679]
+  - @clack/core@0.1.1
+
+## 0.1.0
+
+### Minor Changes
+
+- 7015ec9: Create new prompt: multi-select
+
+### Patch Changes
+
+- Updated dependencies [7015ec9]
+  - @clack/core@0.1.0
+
+## 0.0.10
+
+### Patch Changes
+
+- e0b49e5: Update spinner so it actually spins
+
+## 0.0.9
+
+### Patch Changes
+
+- Update README
+
+## 0.0.8
+
+### Patch Changes
+
+- Updated dependencies [9d371c3]
+  - @clack/core@0.0.12
+
+## 0.0.7
+
+### Patch Changes
+
+- Update README
+
+## 0.0.6
+
+### Patch Changes
+
+- d20ef2a: Update keywords, URLs
+- Updated dependencies [441d5b7]
+- Updated dependencies [d20ef2a]
+- Updated dependencies [fe13c2f]
+  - @clack/core@0.0.11
+
+## 0.0.5
+
+### Patch Changes
+
+- Update README
+
+## 0.0.4
+
+### Patch Changes
+
+- 80404ab: Update README
+
+## 0.0.3
+
+### Patch Changes
+
+- a0cb382: Add `main` entrypoint
+- Updated dependencies [a0cb382]
+  - @clack/core@0.0.10
+
+## 0.0.2
+
+### Patch Changes
+
+- Updated dependencies
+  - @clack/core@0.0.9
+
+## 0.0.1
+
+### Patch Changes
+
+- a4b5e13: Initial release
+- Updated dependencies [a4b5e13]
+  - @clack/core@0.0.8

node_modules/@clack/prompts/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Nate Moore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@clack/prompts/README.md

@@ -0,0 +1,207 @@
+# `@clack/prompts`
+
+Effortlessly build beautiful command-line apps 🪄 [Try the demo](https://stackblitz.com/edit/clack-prompts?file=index.js)
+
+![clack-prompt](https://github.com/bombshell-dev/clack/blob/main/.github/assets/clack-demo.gif)
+
+---
+
+`@clack/prompts` is an opinionated, pre-styled wrapper around [`@clack/core`](https://www.npmjs.com/package/@clack/core).
+
+- 🤏 80% smaller than other options
+- 💎 Beautiful, minimal UI
+- ✅ Simple API
+- 🧱 Comes with `text`, `confirm`, `select`, `multiselect`, and `spinner` components
+
+## Basics
+
+### Setup
+
+The `intro` and `outro` functions will print a message to begin or end a prompt session, respectively.
+
+```js
+import { intro, outro } from '@clack/prompts';
+
+intro(`create-my-app`);
+// Do stuff
+outro(`You're all set!`);
+```
+
+### Cancellation
+
+The `isCancel` function is a guard that detects when a user cancels a question with `CTRL + C`. You should handle this situation for each prompt, optionally providing a nice cancellation message with the `cancel` utility.
+
+```js
+import { isCancel, cancel, text } from '@clack/prompts';
+
+const value = await text({
+  message: 'What is the meaning of life?',
+});
+
+if (isCancel(value)) {
+  cancel('Operation cancelled.');
+  process.exit(0);
+}
+```
+
+## Components
+
+### Text
+
+The text component accepts a single line of text.
+
+```js
+import { text } from '@clack/prompts';
+
+const meaning = await text({
+  message: 'What is the meaning of life?',
+  placeholder: 'Not sure',
+  initialValue: '42',
+  validate(value) {
+    if (value.length === 0) return `Value is required!`;
+  },
+});
+```
+
+### Confirm
+
+The confirm component accepts a yes or no answer. The result is a boolean value of `true` or `false`.
+
+```js
+import { confirm } from '@clack/prompts';
+
+const shouldContinue = await confirm({
+  message: 'Do you want to continue?',
+});
+```
+
+### Select
+
+The select component allows a user to choose one value from a list of options. The result is the `value` prop of a given option.
+
+```js
+import { select } from '@clack/prompts';
+
+const projectType = await select({
+  message: 'Pick a project type.',
+  options: [
+    { value: 'ts', label: 'TypeScript' },
+    { value: 'js', label: 'JavaScript' },
+    { value: 'coffee', label: 'CoffeeScript', hint: 'oh no' },
+  ],
+});
+```
+
+### Multi-Select
+
+The `multiselect` component allows a user to choose many values from a list of options. The result is an array with all selected `value` props.
+
+```js
+import { multiselect } from '@clack/prompts';
+
+const additionalTools = await multiselect({
+  message: 'Select additional tools.',
+  options: [
+    { value: 'eslint', label: 'ESLint', hint: 'recommended' },
+    { value: 'prettier', label: 'Prettier' },
+    { value: 'gh-action', label: 'GitHub Action' },
+  ],
+  required: false,
+});
+```
+
+### Spinner
+
+The spinner component surfaces a pending action, such as a long-running download or dependency installation.
+
+```js
+import { spinner } from '@clack/prompts';
+
+const s = spinner();
+s.start('Installing via npm');
+// Do installation here
+s.stop('Installed via npm');
+```
+
+## Utilities
+
+### Grouping
+
+Grouping prompts together is a great way to keep your code organized. This accepts a JSON object with a name that can be used to reference the group later. The second argument is an optional but has a `onCancel` callback that will be called if the user cancels one of the prompts in the group.
+
+```js
+import * as p from '@clack/prompts';
+
+const group = await p.group(
+  {
+    name: () => p.text({ message: 'What is your name?' }),
+    age: () => p.text({ message: 'What is your age?' }),
+    color: ({ results }) =>
+      p.multiselect({
+        message: `What is your favorite color ${results.name}?`,
+        options: [
+          { value: 'red', label: 'Red' },
+          { value: 'green', label: 'Green' },
+          { value: 'blue', label: 'Blue' },
+        ],
+      }),
+  },
+  {
+    // On Cancel callback that wraps the group
+    // So if the user cancels one of the prompts in the group this function will be called
+    onCancel: ({ results }) => {
+      p.cancel('Operation cancelled.');
+      process.exit(0);
+    },
+  }
+);
+
+console.log(group.name, group.age, group.color);
+```
+
+### Tasks
+
+Execute multiple tasks in spinners.
+
+```js
+await p.tasks([
+  {
+    title: 'Installing via npm',
+    task: async (message) => {
+      // Do installation here
+      return 'Installed via npm';
+    },
+  },
+]);
+```
+
+### Logs
+
+```js
+import { log } from '@clack/prompts';
+
+log.info('Info!');
+log.success('Success!');
+log.step('Step!');
+log.warn('Warn!');
+log.error('Error!');
+log.message('Hello, World', { symbol: color.cyan('~') });
+```
+
+
+### Stream
+
+When interacting with dynamic LLMs or other streaming message providers, use the `stream` APIs to log messages from an iterable, even an async one.
+
+```js
+import { stream } from '@clack/prompts';
+
+stream.info((function *() { yield 'Info!'; })());
+stream.success((function *() { yield 'Success!'; })());
+stream.step((function *() { yield 'Step!'; })());
+stream.warn((function *() { yield 'Warn!'; })());
+stream.error((function *() { yield 'Error!'; })());
+stream.message((function *() { yield 'Hello'; yield ", World" })(), { symbol: color.cyan('~') });
+```
+
+![clack-log-prompts](https://github.com/bombshell-dev/clack/blob/main/.github/assets/clack-logs.png)

node_modules/@clack/prompts/dist/index.cjs

@@ -0,0 +1,87 @@
+"use strict";const node_util=require("node:util"),core=require("@clack/core"),process$1=require("node:process"),e=require("picocolors"),sisteransi=require("sisteransi");function _interopDefaultCompat(t){return t&&typeof t=="object"&&"default"in t?t.default:t}const process__default=_interopDefaultCompat(process$1),e__default=_interopDefaultCompat(e);function isUnicodeSupported(){return process__default.platform!=="win32"?process__default.env.TERM!=="linux":!!process__default.env.CI||!!process__default.env.WT_SESSION||!!process__default.env.TERMINUS_SUBLIME||process__default.env.ConEmuTask==="{cmd::Cmder}"||process__default.env.TERM_PROGRAM==="Terminus-Sublime"||process__default.env.TERM_PROGRAM==="vscode"||process__default.env.TERM==="xterm-256color"||process__default.env.TERM==="alacritty"||process__default.env.TERMINAL_EMULATOR==="JetBrains-JediTerm"}const P=isUnicodeSupported(),u=(t,o)=>P?t:o,ie=u("\u25C6","*"),G=u("\u25A0","x"),L=u("\u25B2","x"),S=u("\u25C7","o"),ae=u("\u250C","T"),a=u("\u2502","|"),g=u("\u2514","\u2014"),_=u("\u25CF",">"),A=u("\u25CB"," "),C=u("\u25FB","[\u2022]"),V=u("\u25FC","[+]"),N=u("\u25FB","[ ]"),oe=u("\u25AA","\u2022"),j=u("\u2500","-"),le=u("\u256E","+"),ce=u("\u251C","+"),ue=u("\u256F","+"),B=u("\u25CF","\u2022"),W=u("\u25C6","*"),H=u("\u25B2","!"),q=u("\u25A0","x"),b=t=>{switch(t){case"initial":case"active":return e__default.cyan(ie);case"cancel":return e__default.red(G);case"error":return e__default.yellow(L);case"submit":return e__default.green(S)}},E=t=>{const{cursor:o,options:s,style:i}=t,r=t.maxItems??Number.POSITIVE_INFINITY,c=Math.max(process.stdout.rows-4,0),n=Math.min(c,Math.max(r,5));let l=0;o>=l+n-3?l=Math.max(Math.min(o-n+3,s.length-n),0):o<l+2&&(l=Math.max(o-2,0));const $=n<s.length&&l>0,h=n<s.length&&l+n<s.length;return s.slice(l,l+n).map((m,y,w)=>{const x=y===0&&$,M=y===w.length-1&&h;return x||M?e__default.dim("..."):i(m,y+l===o)})},text=t=>new core.TextPrompt({validate:t.validate,placeholder:t.placeholder,defaultValue:t.defaultValue,initialValue:t.initialValue,render(){const o=`${e__default.gray(a)}
+${b(this.state)}  ${t.message}
+`,s=t.placeholder?e__default.inverse(t.placeholder[0])+e__default.dim(t.placeholder.slice(1)):e__default.inverse(e__default.hidden("_")),i=this.value?this.valueWithCursor:s;switch(this.state){case"error":return`${o.trim()}
+${e__default.yellow(a)}  ${i}
+${e__default.yellow(g)}  ${e__default.yellow(this.error)}
+`;case"submit":return`${o}${e__default.gray(a)}  ${e__default.dim(this.value||t.placeholder)}`;case"cancel":return`${o}${e__default.gray(a)}  ${e__default.strikethrough(e__default.dim(this.value??""))}${this.value?.trim()?`
+${e__default.gray(a)}`:""}`;default:return`${o}${e__default.cyan(a)}  ${i}
+${e__default.cyan(g)}
+`}}}).prompt(),password=t=>new core.PasswordPrompt({validate:t.validate,mask:t.mask??oe,render(){const o=`${e__default.gray(a)}
+${b(this.state)}  ${t.message}
+`,s=this.valueWithCursor,i=this.masked;switch(this.state){case"error":return`${o.trim()}
+${e__default.yellow(a)}  ${i}
+${e__default.yellow(g)}  ${e__default.yellow(this.error)}
+`;case"submit":return`${o}${e__default.gray(a)}  ${e__default.dim(i)}`;case"cancel":return`${o}${e__default.gray(a)}  ${e__default.strikethrough(e__default.dim(i??""))}${i?`
+${e__default.gray(a)}`:""}`;default:return`${o}${e__default.cyan(a)}  ${s}
+${e__default.cyan(g)}
+`}}}).prompt(),confirm=t=>{const o=t.active??"Yes",s=t.inactive??"No";return new core.ConfirmPrompt({active:o,inactive:s,initialValue:t.initialValue??!0,render(){const i=`${e__default.gray(a)}
+${b(this.state)}  ${t.message}
+`,r=this.value?o:s;switch(this.state){case"submit":return`${i}${e__default.gray(a)}  ${e__default.dim(r)}`;case"cancel":return`${i}${e__default.gray(a)}  ${e__default.strikethrough(e__default.dim(r))}
+${e__default.gray(a)}`;default:return`${i}${e__default.cyan(a)}  ${this.value?`${e__default.green(_)} ${o}`:`${e__default.dim(A)} ${e__default.dim(o)}`} ${e__default.dim("/")} ${this.value?`${e__default.dim(A)} ${e__default.dim(s)}`:`${e__default.green(_)} ${s}`}
+${e__default.cyan(g)}
+`}}}).prompt()},select=t=>{const o=(s,i)=>{const r=s.label??String(s.value);switch(i){case"selected":return`${e__default.dim(r)}`;case"active":return`${e__default.green(_)} ${r} ${s.hint?e__default.dim(`(${s.hint})`):""}`;case"cancelled":return`${e__default.strikethrough(e__default.dim(r))}`;default:return`${e__default.dim(A)} ${e__default.dim(r)}`}};return new core.SelectPrompt({options:t.options,initialValue:t.initialValue,render(){const s=`${e__default.gray(a)}
+${b(this.state)}  ${t.message}
+`;switch(this.state){case"submit":return`${s}${e__default.gray(a)}  ${o(this.options[this.cursor],"selected")}`;case"cancel":return`${s}${e__default.gray(a)}  ${o(this.options[this.cursor],"cancelled")}
+${e__default.gray(a)}`;default:return`${s}${e__default.cyan(a)}  ${E({cursor:this.cursor,options:this.options,maxItems:t.maxItems,style:(i,r)=>o(i,r?"active":"inactive")}).join(`
+${e__default.cyan(a)}  `)}
+${e__default.cyan(g)}
+`}}}).prompt()},selectKey=t=>{const o=(s,i="inactive")=>{const r=s.label??String(s.value);return i==="selected"?`${e__default.dim(r)}`:i==="cancelled"?`${e__default.strikethrough(e__default.dim(r))}`:i==="active"?`${e__default.bgCyan(e__default.gray(` ${s.value} `))} ${r} ${s.hint?e__default.dim(`(${s.hint})`):""}`:`${e__default.gray(e__default.bgWhite(e__default.inverse(` ${s.value} `)))} ${r} ${s.hint?e__default.dim(`(${s.hint})`):""}`};return new core.SelectKeyPrompt({options:t.options,initialValue:t.initialValue,render(){const s=`${e__default.gray(a)}
+${b(this.state)}  ${t.message}
+`;switch(this.state){case"submit":return`${s}${e__default.gray(a)}  ${o(this.options.find(i=>i.value===this.value)??t.options[0],"selected")}`;case"cancel":return`${s}${e__default.gray(a)}  ${o(this.options[0],"cancelled")}
+${e__default.gray(a)}`;default:return`${s}${e__default.cyan(a)}  ${this.options.map((i,r)=>o(i,r===this.cursor?"active":"inactive")).join(`
+${e__default.cyan(a)}  `)}
+${e__default.cyan(g)}
+`}}}).prompt()},multiselect=t=>{const o=(s,i)=>{const r=s.label??String(s.value);return i==="active"?`${e__default.cyan(C)} ${r} ${s.hint?e__default.dim(`(${s.hint})`):""}`:i==="selected"?`${e__default.green(V)} ${e__default.dim(r)} ${s.hint?e__default.dim(`(${s.hint})`):""}`:i==="cancelled"?`${e__default.strikethrough(e__default.dim(r))}`:i==="active-selected"?`${e__default.green(V)} ${r} ${s.hint?e__default.dim(`(${s.hint})`):""}`:i==="submitted"?`${e__default.dim(r)}`:`${e__default.dim(N)} ${e__default.dim(r)}`};return new core.MultiSelectPrompt({options:t.options,initialValues:t.initialValues,required:t.required??!0,cursorAt:t.cursorAt,validate(s){if(this.required&&s.length===0)return`Please select at least one option.
+${e__default.reset(e__default.dim(`Press ${e__default.gray(e__default.bgWhite(e__default.inverse(" space ")))} to select, ${e__default.gray(e__default.bgWhite(e__default.inverse(" enter ")))} to submit`))}`},render(){const s=`${e__default.gray(a)}
+${b(this.state)}  ${t.message}
+`,i=(r,c)=>{const n=this.value.includes(r.value);return c&&n?o(r,"active-selected"):n?o(r,"selected"):o(r,c?"active":"inactive")};switch(this.state){case"submit":return`${s}${e__default.gray(a)}  ${this.options.filter(({value:r})=>this.value.includes(r)).map(r=>o(r,"submitted")).join(e__default.dim(", "))||e__default.dim("none")}`;case"cancel":{const r=this.options.filter(({value:c})=>this.value.includes(c)).map(c=>o(c,"cancelled")).join(e__default.dim(", "));return`${s}${e__default.gray(a)}  ${r.trim()?`${r}
+${e__default.gray(a)}`:""}`}case"error":{const r=this.error.split(`
+`).map((c,n)=>n===0?`${e__default.yellow(g)}  ${e__default.yellow(c)}`:`   ${c}`).join(`
+`);return`${s+e__default.yellow(a)}  ${E({options:this.options,cursor:this.cursor,maxItems:t.maxItems,style:i}).join(`
+${e__default.yellow(a)}  `)}
+${r}
+`}default:return`${s}${e__default.cyan(a)}  ${E({options:this.options,cursor:this.cursor,maxItems:t.maxItems,style:i}).join(`
+${e__default.cyan(a)}  `)}
+${e__default.cyan(g)}
+`}}}).prompt()},groupMultiselect=t=>{const{selectableGroups:o=!0}=t,s=(i,r,c=[])=>{const n=i.label??String(i.value),l=typeof i.group=="string",$=l&&(c[c.indexOf(i)+1]??{group:!0}),h=l&&$.group===!0,m=l?o?`${h?g:a} `:"  ":"";if(r==="active")return`${e__default.dim(m)}${e__default.cyan(C)} ${n} ${i.hint?e__default.dim(`(${i.hint})`):""}`;if(r==="group-active")return`${m}${e__default.cyan(C)} ${e__default.dim(n)}`;if(r==="group-active-selected")return`${m}${e__default.green(V)} ${e__default.dim(n)}`;if(r==="selected"){const w=l||o?e__default.green(V):"";return`${e__default.dim(m)}${w} ${e__default.dim(n)} ${i.hint?e__default.dim(`(${i.hint})`):""}`}if(r==="cancelled")return`${e__default.strikethrough(e__default.dim(n))}`;if(r==="active-selected")return`${e__default.dim(m)}${e__default.green(V)} ${n} ${i.hint?e__default.dim(`(${i.hint})`):""}`;if(r==="submitted")return`${e__default.dim(n)}`;const y=l||o?e__default.dim(N):"";return`${e__default.dim(m)}${y} ${e__default.dim(n)}`};return new core.GroupMultiSelectPrompt({options:t.options,initialValues:t.initialValues,required:t.required??!0,cursorAt:t.cursorAt,selectableGroups:o,validate(i){if(this.required&&i.length===0)return`Please select at least one option.
+${e__default.reset(e__default.dim(`Press ${e__default.gray(e__default.bgWhite(e__default.inverse(" space ")))} to select, ${e__default.gray(e__default.bgWhite(e__default.inverse(" enter ")))} to submit`))}`},render(){const i=`${e__default.gray(a)}
+${b(this.state)}  ${t.message}
+`;switch(this.state){case"submit":return`${i}${e__default.gray(a)}  ${this.options.filter(({value:r})=>this.value.includes(r)).map(r=>s(r,"submitted")).join(e__default.dim(", "))}`;case"cancel":{const r=this.options.filter(({value:c})=>this.value.includes(c)).map(c=>s(c,"cancelled")).join(e__default.dim(", "));return`${i}${e__default.gray(a)}  ${r.trim()?`${r}
+${e__default.gray(a)}`:""}`}case"error":{const r=this.error.split(`
+`).map((c,n)=>n===0?`${e__default.yellow(g)}  ${e__default.yellow(c)}`:`   ${c}`).join(`
+`);return`${i}${e__default.yellow(a)}  ${this.options.map((c,n,l)=>{const $=this.value.includes(c.value)||c.group===!0&&this.isGroupSelected(`${c.value}`),h=n===this.cursor;return!h&&typeof c.group=="string"&&this.options[this.cursor].value===c.group?s(c,$?"group-active-selected":"group-active",l):h&&$?s(c,"active-selected",l):$?s(c,"selected",l):s(c,h?"active":"inactive",l)}).join(`
+${e__default.yellow(a)}  `)}
+${r}
+`}default:return`${i}${e__default.cyan(a)}  ${this.options.map((r,c,n)=>{const l=this.value.includes(r.value)||r.group===!0&&this.isGroupSelected(`${r.value}`),$=c===this.cursor;return!$&&typeof r.group=="string"&&this.options[this.cursor].value===r.group?s(r,l?"group-active-selected":"group-active",n):$&&l?s(r,"active-selected",n):l?s(r,"selected",n):s(r,$?"active":"inactive",n)}).join(`
+${e__default.cyan(a)}  `)}
+${e__default.cyan(g)}
+`}}}).prompt()},note=(t="",o="")=>{const s=`
+${t}
+`.split(`
+`),i=node_util.stripVTControlCharacters(o).length,r=Math.max(s.reduce((n,l)=>{const $=node_util.stripVTControlCharacters(l);return $.length>n?$.length:n},0),i)+2,c=s.map(n=>`${e__default.gray(a)}  ${e__default.dim(n)}${" ".repeat(r-node_util.stripVTControlCharacters(n).length)}${e__default.gray(a)}`).join(`
+`);process.stdout.write(`${e__default.gray(a)}
+${e__default.green(S)}  ${e__default.reset(o)} ${e__default.gray(j.repeat(Math.max(r-i-1,1))+le)}
+${c}
+${e__default.gray(ce+j.repeat(r+2)+ue)}
+`)},cancel=(t="")=>{process.stdout.write(`${e__default.gray(g)}  ${e__default.red(t)}
+
+`)},intro=(t="")=>{process.stdout.write(`${e__default.gray(ae)}  ${t}
+`)},outro=(t="")=>{process.stdout.write(`${e__default.gray(a)}
+${e__default.gray(g)}  ${t}
+
+`)},log={message:(t="",{symbol:o=e__default.gray(a)}={})=>{const s=[`${e__default.gray(a)}`];if(t){const[i,...r]=t.split(`
+`);s.push(`${o}  ${i}`,...r.map(c=>`${e__default.gray(a)}  ${c}`))}process.stdout.write(`${s.join(`
+`)}
+`)},info:t=>{log.message(t,{symbol:e__default.blue(B)})},success:t=>{log.message(t,{symbol:e__default.green(W)})},step:t=>{log.message(t,{symbol:e__default.green(S)})},warn:t=>{log.message(t,{symbol:e__default.yellow(H)})},warning:t=>{log.warn(t)},error:t=>{log.message(t,{symbol:e__default.red(q)})}},D=`${e__default.gray(a)}  `,stream={message:async(t,{symbol:o=e__default.gray(a)}={})=>{process.stdout.write(`${e__default.gray(a)}
+${o}  `);let s=3;for await(let i of t){i=i.replace(/\n/g,`
+${D}`),i.includes(`
+`)&&(s=3+node_util.stripVTControlCharacters(i.slice(i.lastIndexOf(`
+`))).length);const r=node_util.stripVTControlCharacters(i).length;s+r<process.stdout.columns?(s+=r,process.stdout.write(i)):(process.stdout.write(`
+${D}${i.trimStart()}`),s=3+node_util.stripVTControlCharacters(i.trimStart()).length)}process.stdout.write(`
+`)},info:t=>stream.message(t,{symbol:e__default.blue(B)}),success:t=>stream.message(t,{symbol:e__default.green(W)}),step:t=>stream.message(t,{symbol:e__default.green(S)}),warn:t=>stream.message(t,{symbol:e__default.yellow(H)}),warning:t=>stream.warn(t),error:t=>stream.message(t,{symbol:e__default.red(q)})},spinner=({indicator:t="dots"}={})=>{const o=P?["\u25D2","\u25D0","\u25D3","\u25D1"]:["\u2022","o","O","0"],s=P?80:120,i=process.env.CI==="true";let r,c,n=!1,l="",$,h=performance.now();const m=p=>{const d=p>1?"Something went wrong":"Canceled";n&&R(d,p)},y=()=>m(2),w=()=>m(1),x=()=>{process.on("uncaughtExceptionMonitor",y),process.on("unhandledRejection",y),process.on("SIGINT",w),process.on("SIGTERM",w),process.on("exit",m)},M=()=>{process.removeListener("uncaughtExceptionMonitor",y),process.removeListener("unhandledRejection",y),process.removeListener("SIGINT",w),process.removeListener("SIGTERM",w),process.removeListener("exit",m)},T=()=>{if($===void 0)return;i&&process.stdout.write(`
+`);const p=$.split(`
+`);process.stdout.write(sisteransi.cursor.move(-999,p.length-1)),process.stdout.write(sisteransi.erase.down(p.length))},I=p=>p.replace(/\.+$/,""),k=p=>{const d=(performance.now()-p)/1e3,v=Math.floor(d/60),f=Math.floor(d%60);return v>0?`[${v}m ${f}s]`:`[${f}s]`},O=(p="")=>{n=!0,r=core.block(),l=I(p),h=performance.now(),process.stdout.write(`${e__default.gray(a)}
+`);let d=0,v=0;x(),c=setInterval(()=>{if(i&&l===$)return;T(),$=l;const f=e__default.magenta(o[d]);if(i)process.stdout.write(`${f}  ${l}...`);else if(t==="timer")process.stdout.write(`${f}  ${l} ${k(h)}`);else{const F=".".repeat(Math.floor(v)).slice(0,3);process.stdout.write(`${f}  ${l}${F}`)}d=d+1<o.length?d+1:0,v=v<o.length?v+.125:0},s)},R=(p="",d=0)=>{n=!1,clearInterval(c),T();const v=d===0?e__default.green(S):d===1?e__default.red(G):e__default.red(L);l=I(p??l),t==="timer"?process.stdout.write(`${v}  ${l} ${k(h)}
+`):process.stdout.write(`${v}  ${l}
+`),M(),r()};return{start:O,stop:R,message:(p="")=>{l=I(p??l)}}},group=async(t,o)=>{const s={},i=Object.keys(t);for(const r of i){const c=t[r],n=await c({results:s})?.catch(l=>{throw l});if(typeof o?.onCancel=="function"&&core.isCancel(n)){s[r]="canceled",o.onCancel({results:s});continue}s[r]=n}return s},tasks=async t=>{for(const o of t){if(o.enabled===!1)continue;const s=spinner();s.start(o.title);const i=await o.task(s.message);s.stop(i||o.title)}};exports.isCancel=core.isCancel,exports.updateSettings=core.updateSettings,exports.cancel=cancel,exports.confirm=confirm,exports.group=group,exports.groupMultiselect=groupMultiselect,exports.intro=intro,exports.log=log,exports.multiselect=multiselect,exports.note=note,exports.outro=outro,exports.password=password,exports.select=select,exports.selectKey=selectKey,exports.spinner=spinner,exports.stream=stream,exports.tasks=tasks,exports.text=text;
+//# sourceMappingURL=index.cjs.map

node_modules/@clack/prompts/dist/index.d.cts

@@ -0,0 +1,165 @@
+export { ClackSettings, isCancel, updateSettings } from '@clack/core';
+
+interface TextOptions {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    validate?: (value: string) => string | Error | undefined;
+}
+declare const text: (opts: TextOptions) => Promise<string | symbol>;
+interface PasswordOptions {
+    message: string;
+    mask?: string;
+    validate?: (value: string) => string | Error | undefined;
+}
+declare const password: (opts: PasswordOptions) => Promise<string | symbol>;
+interface ConfirmOptions {
+    message: string;
+    active?: string;
+    inactive?: string;
+    initialValue?: boolean;
+}
+declare const confirm: (opts: ConfirmOptions) => Promise<boolean | symbol>;
+type Primitive = Readonly<string | boolean | number>;
+type Option<Value> = Value extends Primitive ? {
+    /**
+     * Internal data for this option.
+     */
+    value: Value;
+    /**
+     * The optional, user-facing text for this option.
+     *
+     * By default, the `value` is converted to a string.
+     */
+    label?: string;
+    /**
+     * An optional hint to display to the user when
+     * this option might be selected.
+     *
+     * By default, no `hint` is displayed.
+     */
+    hint?: string;
+} : {
+    /**
+     * Internal data for this option.
+     */
+    value: Value;
+    /**
+     * Required. The user-facing text for this option.
+     */
+    label: string;
+    /**
+     * An optional hint to display to the user when
+     * this option might be selected.
+     *
+     * By default, no `hint` is displayed.
+     */
+    hint?: string;
+};
+interface SelectOptions<Value> {
+    message: string;
+    options: Option<Value>[];
+    initialValue?: Value;
+    maxItems?: number;
+}
+declare const select: <Value>(opts: SelectOptions<Value>) => Promise<symbol | Value>;
+declare const selectKey: <Value extends string>(opts: SelectOptions<Value>) => Promise<symbol | Value>;
+interface MultiSelectOptions<Value> {
+    message: string;
+    options: Option<Value>[];
+    initialValues?: Value[];
+    maxItems?: number;
+    required?: boolean;
+    cursorAt?: Value;
+}
+declare const multiselect: <Value>(opts: MultiSelectOptions<Value>) => Promise<symbol | Value[]>;
+interface GroupMultiSelectOptions<Value> {
+    message: string;
+    options: Record<string, Option<Value>[]>;
+    initialValues?: Value[];
+    required?: boolean;
+    cursorAt?: Value;
+    selectableGroups?: boolean;
+}
+declare const groupMultiselect: <Value>(opts: GroupMultiSelectOptions<Value>) => Promise<symbol | Value[]>;
+declare const note: (message?: string, title?: string) => void;
+declare const cancel: (message?: string) => void;
+declare const intro: (title?: string) => void;
+declare const outro: (message?: string) => void;
+type LogMessageOptions = {
+    symbol?: string;
+};
+declare const log: {
+    message: (message?: string, { symbol }?: LogMessageOptions) => void;
+    info: (message: string) => void;
+    success: (message: string) => void;
+    step: (message: string) => void;
+    warn: (message: string) => void;
+    /** alias for `log.warn()`. */
+    warning: (message: string) => void;
+    error: (message: string) => void;
+};
+declare const stream: {
+    message: (iterable: Iterable<string> | AsyncIterable<string>, { symbol }?: LogMessageOptions) => Promise<void>;
+    info: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    success: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    step: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    warn: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    /** alias for `log.warn()`. */
+    warning: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    error: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+};
+interface SpinnerOptions {
+    indicator?: 'dots' | 'timer';
+}
+declare const spinner: ({ indicator }?: SpinnerOptions) => {
+    start: (msg?: string) => void;
+    stop: (msg?: string, code?: number) => void;
+    message: (msg?: string) => void;
+};
+type PromptGroupAwaitedReturn<T> = {
+    [P in keyof T]: Exclude<Awaited<T[P]>, symbol>;
+};
+interface PromptGroupOptions<T> {
+    /**
+     * Control how the group can be canceled
+     * if one of the prompts is canceled.
+     */
+    onCancel?: (opts: {
+        results: Prettify<Partial<PromptGroupAwaitedReturn<T>>>;
+    }) => void;
+}
+type Prettify<T> = {
+    [P in keyof T]: T[P];
+} & {};
+type PromptGroup<T> = {
+    [P in keyof T]: (opts: {
+        results: Prettify<Partial<PromptGroupAwaitedReturn<Omit<T, P>>>>;
+    }) => undefined | Promise<T[P] | undefined>;
+};
+/**
+ * Define a group of prompts to be displayed
+ * and return a results of objects within the group
+ */
+declare const group: <T>(prompts: PromptGroup<T>, opts?: PromptGroupOptions<T> | undefined) => Promise<{ [P in keyof PromptGroupAwaitedReturn<T>]: PromptGroupAwaitedReturn<T>[P]; }>;
+type Task = {
+    /**
+     * Task title
+     */
+    title: string;
+    /**
+     * Task function
+     */
+    task: (message: (string: string) => void) => string | Promise<string> | void | Promise<void>;
+    /**
+     * If enabled === false the task will be skipped
+     */
+    enabled?: boolean;
+};
+/**
+ * Define a group of tasks to be executed
+ */
+declare const tasks: (tasks: Task[]) => Promise<void>;
+
+export { type ConfirmOptions, type GroupMultiSelectOptions, type LogMessageOptions, type MultiSelectOptions, type Option, type PasswordOptions, type PromptGroup, type PromptGroupAwaitedReturn, type PromptGroupOptions, type SelectOptions, type SpinnerOptions, type Task, type TextOptions, cancel, confirm, group, groupMultiselect, intro, log, multiselect, note, outro, password, select, selectKey, spinner, stream, tasks, text };

node_modules/@clack/prompts/dist/index.d.mts

@@ -0,0 +1,165 @@
+export { ClackSettings, isCancel, updateSettings } from '@clack/core';
+
+interface TextOptions {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    validate?: (value: string) => string | Error | undefined;
+}
+declare const text: (opts: TextOptions) => Promise<string | symbol>;
+interface PasswordOptions {
+    message: string;
+    mask?: string;
+    validate?: (value: string) => string | Error | undefined;
+}
+declare const password: (opts: PasswordOptions) => Promise<string | symbol>;
+interface ConfirmOptions {
+    message: string;
+    active?: string;
+    inactive?: string;
+    initialValue?: boolean;
+}
+declare const confirm: (opts: ConfirmOptions) => Promise<boolean | symbol>;
+type Primitive = Readonly<string | boolean | number>;
+type Option<Value> = Value extends Primitive ? {
+    /**
+     * Internal data for this option.
+     */
+    value: Value;
+    /**
+     * The optional, user-facing text for this option.
+     *
+     * By default, the `value` is converted to a string.
+     */
+    label?: string;
+    /**
+     * An optional hint to display to the user when
+     * this option might be selected.
+     *
+     * By default, no `hint` is displayed.
+     */
+    hint?: string;
+} : {
+    /**
+     * Internal data for this option.
+     */
+    value: Value;
+    /**
+     * Required. The user-facing text for this option.
+     */
+    label: string;
+    /**
+     * An optional hint to display to the user when
+     * this option might be selected.
+     *
+     * By default, no `hint` is displayed.
+     */
+    hint?: string;
+};
+interface SelectOptions<Value> {
+    message: string;
+    options: Option<Value>[];
+    initialValue?: Value;
+    maxItems?: number;
+}
+declare const select: <Value>(opts: SelectOptions<Value>) => Promise<symbol | Value>;
+declare const selectKey: <Value extends string>(opts: SelectOptions<Value>) => Promise<symbol | Value>;
+interface MultiSelectOptions<Value> {
+    message: string;
+    options: Option<Value>[];
+    initialValues?: Value[];
+    maxItems?: number;
+    required?: boolean;
+    cursorAt?: Value;
+}
+declare const multiselect: <Value>(opts: MultiSelectOptions<Value>) => Promise<symbol | Value[]>;
+interface GroupMultiSelectOptions<Value> {
+    message: string;
+    options: Record<string, Option<Value>[]>;
+    initialValues?: Value[];
+    required?: boolean;
+    cursorAt?: Value;
+    selectableGroups?: boolean;
+}
+declare const groupMultiselect: <Value>(opts: GroupMultiSelectOptions<Value>) => Promise<symbol | Value[]>;
+declare const note: (message?: string, title?: string) => void;
+declare const cancel: (message?: string) => void;
+declare const intro: (title?: string) => void;
+declare const outro: (message?: string) => void;
+type LogMessageOptions = {
+    symbol?: string;
+};
+declare const log: {
+    message: (message?: string, { symbol }?: LogMessageOptions) => void;
+    info: (message: string) => void;
+    success: (message: string) => void;
+    step: (message: string) => void;
+    warn: (message: string) => void;
+    /** alias for `log.warn()`. */
+    warning: (message: string) => void;
+    error: (message: string) => void;
+};
+declare const stream: {
+    message: (iterable: Iterable<string> | AsyncIterable<string>, { symbol }?: LogMessageOptions) => Promise<void>;
+    info: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    success: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    step: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    warn: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    /** alias for `log.warn()`. */
+    warning: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    error: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+};
+interface SpinnerOptions {
+    indicator?: 'dots' | 'timer';
+}
+declare const spinner: ({ indicator }?: SpinnerOptions) => {
+    start: (msg?: string) => void;
+    stop: (msg?: string, code?: number) => void;
+    message: (msg?: string) => void;
+};
+type PromptGroupAwaitedReturn<T> = {
+    [P in keyof T]: Exclude<Awaited<T[P]>, symbol>;
+};
+interface PromptGroupOptions<T> {
+    /**
+     * Control how the group can be canceled
+     * if one of the prompts is canceled.
+     */
+    onCancel?: (opts: {
+        results: Prettify<Partial<PromptGroupAwaitedReturn<T>>>;
+    }) => void;
+}
+type Prettify<T> = {
+    [P in keyof T]: T[P];
+} & {};
+type PromptGroup<T> = {
+    [P in keyof T]: (opts: {
+        results: Prettify<Partial<PromptGroupAwaitedReturn<Omit<T, P>>>>;
+    }) => undefined | Promise<T[P] | undefined>;
+};
+/**
+ * Define a group of prompts to be displayed
+ * and return a results of objects within the group
+ */
+declare const group: <T>(prompts: PromptGroup<T>, opts?: PromptGroupOptions<T> | undefined) => Promise<{ [P in keyof PromptGroupAwaitedReturn<T>]: PromptGroupAwaitedReturn<T>[P]; }>;
+type Task = {
+    /**
+     * Task title
+     */
+    title: string;
+    /**
+     * Task function
+     */
+    task: (message: (string: string) => void) => string | Promise<string> | void | Promise<void>;
+    /**
+     * If enabled === false the task will be skipped
+     */
+    enabled?: boolean;
+};
+/**
+ * Define a group of tasks to be executed
+ */
+declare const tasks: (tasks: Task[]) => Promise<void>;
+
+export { type ConfirmOptions, type GroupMultiSelectOptions, type LogMessageOptions, type MultiSelectOptions, type Option, type PasswordOptions, type PromptGroup, type PromptGroupAwaitedReturn, type PromptGroupOptions, type SelectOptions, type SpinnerOptions, type Task, type TextOptions, cancel, confirm, group, groupMultiselect, intro, log, multiselect, note, outro, password, select, selectKey, spinner, stream, tasks, text };

node_modules/@clack/prompts/dist/index.d.ts

@@ -0,0 +1,165 @@
+export { ClackSettings, isCancel, updateSettings } from '@clack/core';
+
+interface TextOptions {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    validate?: (value: string) => string | Error | undefined;
+}
+declare const text: (opts: TextOptions) => Promise<string | symbol>;
+interface PasswordOptions {
+    message: string;
+    mask?: string;
+    validate?: (value: string) => string | Error | undefined;
+}
+declare const password: (opts: PasswordOptions) => Promise<string | symbol>;
+interface ConfirmOptions {
+    message: string;
+    active?: string;
+    inactive?: string;
+    initialValue?: boolean;
+}
+declare const confirm: (opts: ConfirmOptions) => Promise<boolean | symbol>;
+type Primitive = Readonly<string | boolean | number>;
+type Option<Value> = Value extends Primitive ? {
+    /**
+     * Internal data for this option.
+     */
+    value: Value;
+    /**
+     * The optional, user-facing text for this option.
+     *
+     * By default, the `value` is converted to a string.
+     */
+    label?: string;
+    /**
+     * An optional hint to display to the user when
+     * this option might be selected.
+     *
+     * By default, no `hint` is displayed.
+     */
+    hint?: string;
+} : {
+    /**
+     * Internal data for this option.
+     */
+    value: Value;
+    /**
+     * Required. The user-facing text for this option.
+     */
+    label: string;
+    /**
+     * An optional hint to display to the user when
+     * this option might be selected.
+     *
+     * By default, no `hint` is displayed.
+     */
+    hint?: string;
+};
+interface SelectOptions<Value> {
+    message: string;
+    options: Option<Value>[];
+    initialValue?: Value;
+    maxItems?: number;
+}
+declare const select: <Value>(opts: SelectOptions<Value>) => Promise<symbol | Value>;
+declare const selectKey: <Value extends string>(opts: SelectOptions<Value>) => Promise<symbol | Value>;
+interface MultiSelectOptions<Value> {
+    message: string;
+    options: Option<Value>[];
+    initialValues?: Value[];
+    maxItems?: number;
+    required?: boolean;
+    cursorAt?: Value;
+}
+declare const multiselect: <Value>(opts: MultiSelectOptions<Value>) => Promise<symbol | Value[]>;
+interface GroupMultiSelectOptions<Value> {
+    message: string;
+    options: Record<string, Option<Value>[]>;
+    initialValues?: Value[];
+    required?: boolean;
+    cursorAt?: Value;
+    selectableGroups?: boolean;
+}
+declare const groupMultiselect: <Value>(opts: GroupMultiSelectOptions<Value>) => Promise<symbol | Value[]>;
+declare const note: (message?: string, title?: string) => void;
+declare const cancel: (message?: string) => void;
+declare const intro: (title?: string) => void;
+declare const outro: (message?: string) => void;
+type LogMessageOptions = {
+    symbol?: string;
+};
+declare const log: {
+    message: (message?: string, { symbol }?: LogMessageOptions) => void;
+    info: (message: string) => void;
+    success: (message: string) => void;
+    step: (message: string) => void;
+    warn: (message: string) => void;
+    /** alias for `log.warn()`. */
+    warning: (message: string) => void;
+    error: (message: string) => void;
+};
+declare const stream: {
+    message: (iterable: Iterable<string> | AsyncIterable<string>, { symbol }?: LogMessageOptions) => Promise<void>;
+    info: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    success: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    step: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    warn: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    /** alias for `log.warn()`. */
+    warning: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    error: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+};
+interface SpinnerOptions {
+    indicator?: 'dots' | 'timer';
+}
+declare const spinner: ({ indicator }?: SpinnerOptions) => {
+    start: (msg?: string) => void;
+    stop: (msg?: string, code?: number) => void;
+    message: (msg?: string) => void;
+};
+type PromptGroupAwaitedReturn<T> = {
+    [P in keyof T]: Exclude<Awaited<T[P]>, symbol>;
+};
+interface PromptGroupOptions<T> {
+    /**
+     * Control how the group can be canceled
+     * if one of the prompts is canceled.
+     */
+    onCancel?: (opts: {
+        results: Prettify<Partial<PromptGroupAwaitedReturn<T>>>;
+    }) => void;
+}
+type Prettify<T> = {
+    [P in keyof T]: T[P];
+} & {};
+type PromptGroup<T> = {
+    [P in keyof T]: (opts: {
+        results: Prettify<Partial<PromptGroupAwaitedReturn<Omit<T, P>>>>;
+    }) => undefined | Promise<T[P] | undefined>;
+};
+/**
+ * Define a group of prompts to be displayed
+ * and return a results of objects within the group
+ */
+declare const group: <T>(prompts: PromptGroup<T>, opts?: PromptGroupOptions<T> | undefined) => Promise<{ [P in keyof PromptGroupAwaitedReturn<T>]: PromptGroupAwaitedReturn<T>[P]; }>;
+type Task = {
+    /**
+     * Task title
+     */
+    title: string;
+    /**
+     * Task function
+     */
+    task: (message: (string: string) => void) => string | Promise<string> | void | Promise<void>;
+    /**
+     * If enabled === false the task will be skipped
+     */
+    enabled?: boolean;
+};
+/**
+ * Define a group of tasks to be executed
+ */
+declare const tasks: (tasks: Task[]) => Promise<void>;
+
+export { type ConfirmOptions, type GroupMultiSelectOptions, type LogMessageOptions, type MultiSelectOptions, type Option, type PasswordOptions, type PromptGroup, type PromptGroupAwaitedReturn, type PromptGroupOptions, type SelectOptions, type SpinnerOptions, type Task, type TextOptions, cancel, confirm, group, groupMultiselect, intro, log, multiselect, note, outro, password, select, selectKey, spinner, stream, tasks, text };

node_modules/@clack/prompts/dist/index.mjs

@@ -0,0 +1,87 @@
+import{stripVTControlCharacters as S}from"node:util";import{TextPrompt as Q,PasswordPrompt as X,ConfirmPrompt as Z,SelectPrompt as ee,SelectKeyPrompt as te,MultiSelectPrompt as re,GroupMultiSelectPrompt as se,isCancel as ie,block as ne}from"@clack/core";export{isCancel,updateSettings}from"@clack/core";import y from"node:process";import e from"picocolors";import{cursor as oe,erase as ae}from"sisteransi";function ce(){return y.platform!=="win32"?y.env.TERM!=="linux":!!y.env.CI||!!y.env.WT_SESSION||!!y.env.TERMINUS_SUBLIME||y.env.ConEmuTask==="{cmd::Cmder}"||y.env.TERM_PROGRAM==="Terminus-Sublime"||y.env.TERM_PROGRAM==="vscode"||y.env.TERM==="xterm-256color"||y.env.TERM==="alacritty"||y.env.TERMINAL_EMULATOR==="JetBrains-JediTerm"}const V=ce(),u=(t,n)=>V?t:n,le=u("\u25C6","*"),L=u("\u25A0","x"),W=u("\u25B2","x"),C=u("\u25C7","o"),ue=u("\u250C","T"),o=u("\u2502","|"),d=u("\u2514","\u2014"),k=u("\u25CF",">"),P=u("\u25CB"," "),A=u("\u25FB","[\u2022]"),T=u("\u25FC","[+]"),F=u("\u25FB","[ ]"),$e=u("\u25AA","\u2022"),_=u("\u2500","-"),me=u("\u256E","+"),de=u("\u251C","+"),pe=u("\u256F","+"),q=u("\u25CF","\u2022"),D=u("\u25C6","*"),U=u("\u25B2","!"),K=u("\u25A0","x"),b=t=>{switch(t){case"initial":case"active":return e.cyan(le);case"cancel":return e.red(L);case"error":return e.yellow(W);case"submit":return e.green(C)}},G=t=>{const{cursor:n,options:r,style:i}=t,s=t.maxItems??Number.POSITIVE_INFINITY,c=Math.max(process.stdout.rows-4,0),a=Math.min(c,Math.max(s,5));let l=0;n>=l+a-3?l=Math.max(Math.min(n-a+3,r.length-a),0):n<l+2&&(l=Math.max(n-2,0));const $=a<r.length&&l>0,g=a<r.length&&l+a<r.length;return r.slice(l,l+a).map((p,v,f)=>{const j=v===0&&$,E=v===f.length-1&&g;return j||E?e.dim("..."):i(p,v+l===n)})},he=t=>new Q({validate:t.validate,placeholder:t.placeholder,defaultValue:t.defaultValue,initialValue:t.initialValue,render(){const n=`${e.gray(o)}
+${b(this.state)}  ${t.message}
+`,r=t.placeholder?e.inverse(t.placeholder[0])+e.dim(t.placeholder.slice(1)):e.inverse(e.hidden("_")),i=this.value?this.valueWithCursor:r;switch(this.state){case"error":return`${n.trim()}
+${e.yellow(o)}  ${i}
+${e.yellow(d)}  ${e.yellow(this.error)}
+`;case"submit":return`${n}${e.gray(o)}  ${e.dim(this.value||t.placeholder)}`;case"cancel":return`${n}${e.gray(o)}  ${e.strikethrough(e.dim(this.value??""))}${this.value?.trim()?`
+${e.gray(o)}`:""}`;default:return`${n}${e.cyan(o)}  ${i}
+${e.cyan(d)}
+`}}}).prompt(),ge=t=>new X({validate:t.validate,mask:t.mask??$e,render(){const n=`${e.gray(o)}
+${b(this.state)}  ${t.message}
+`,r=this.valueWithCursor,i=this.masked;switch(this.state){case"error":return`${n.trim()}
+${e.yellow(o)}  ${i}
+${e.yellow(d)}  ${e.yellow(this.error)}
+`;case"submit":return`${n}${e.gray(o)}  ${e.dim(i)}`;case"cancel":return`${n}${e.gray(o)}  ${e.strikethrough(e.dim(i??""))}${i?`
+${e.gray(o)}`:""}`;default:return`${n}${e.cyan(o)}  ${r}
+${e.cyan(d)}
+`}}}).prompt(),ye=t=>{const n=t.active??"Yes",r=t.inactive??"No";return new Z({active:n,inactive:r,initialValue:t.initialValue??!0,render(){const i=`${e.gray(o)}
+${b(this.state)}  ${t.message}
+`,s=this.value?n:r;switch(this.state){case"submit":return`${i}${e.gray(o)}  ${e.dim(s)}`;case"cancel":return`${i}${e.gray(o)}  ${e.strikethrough(e.dim(s))}
+${e.gray(o)}`;default:return`${i}${e.cyan(o)}  ${this.value?`${e.green(k)} ${n}`:`${e.dim(P)} ${e.dim(n)}`} ${e.dim("/")} ${this.value?`${e.dim(P)} ${e.dim(r)}`:`${e.green(k)} ${r}`}
+${e.cyan(d)}
+`}}}).prompt()},ve=t=>{const n=(r,i)=>{const s=r.label??String(r.value);switch(i){case"selected":return`${e.dim(s)}`;case"active":return`${e.green(k)} ${s} ${r.hint?e.dim(`(${r.hint})`):""}`;case"cancelled":return`${e.strikethrough(e.dim(s))}`;default:return`${e.dim(P)} ${e.dim(s)}`}};return new ee({options:t.options,initialValue:t.initialValue,render(){const r=`${e.gray(o)}
+${b(this.state)}  ${t.message}
+`;switch(this.state){case"submit":return`${r}${e.gray(o)}  ${n(this.options[this.cursor],"selected")}`;case"cancel":return`${r}${e.gray(o)}  ${n(this.options[this.cursor],"cancelled")}
+${e.gray(o)}`;default:return`${r}${e.cyan(o)}  ${G({cursor:this.cursor,options:this.options,maxItems:t.maxItems,style:(i,s)=>n(i,s?"active":"inactive")}).join(`
+${e.cyan(o)}  `)}
+${e.cyan(d)}
+`}}}).prompt()},we=t=>{const n=(r,i="inactive")=>{const s=r.label??String(r.value);return i==="selected"?`${e.dim(s)}`:i==="cancelled"?`${e.strikethrough(e.dim(s))}`:i==="active"?`${e.bgCyan(e.gray(` ${r.value} `))} ${s} ${r.hint?e.dim(`(${r.hint})`):""}`:`${e.gray(e.bgWhite(e.inverse(` ${r.value} `)))} ${s} ${r.hint?e.dim(`(${r.hint})`):""}`};return new te({options:t.options,initialValue:t.initialValue,render(){const r=`${e.gray(o)}
+${b(this.state)}  ${t.message}
+`;switch(this.state){case"submit":return`${r}${e.gray(o)}  ${n(this.options.find(i=>i.value===this.value)??t.options[0],"selected")}`;case"cancel":return`${r}${e.gray(o)}  ${n(this.options[0],"cancelled")}
+${e.gray(o)}`;default:return`${r}${e.cyan(o)}  ${this.options.map((i,s)=>n(i,s===this.cursor?"active":"inactive")).join(`
+${e.cyan(o)}  `)}
+${e.cyan(d)}
+`}}}).prompt()},fe=t=>{const n=(r,i)=>{const s=r.label??String(r.value);return i==="active"?`${e.cyan(A)} ${s} ${r.hint?e.dim(`(${r.hint})`):""}`:i==="selected"?`${e.green(T)} ${e.dim(s)} ${r.hint?e.dim(`(${r.hint})`):""}`:i==="cancelled"?`${e.strikethrough(e.dim(s))}`:i==="active-selected"?`${e.green(T)} ${s} ${r.hint?e.dim(`(${r.hint})`):""}`:i==="submitted"?`${e.dim(s)}`:`${e.dim(F)} ${e.dim(s)}`};return new re({options:t.options,initialValues:t.initialValues,required:t.required??!0,cursorAt:t.cursorAt,validate(r){if(this.required&&r.length===0)return`Please select at least one option.
+${e.reset(e.dim(`Press ${e.gray(e.bgWhite(e.inverse(" space ")))} to select, ${e.gray(e.bgWhite(e.inverse(" enter ")))} to submit`))}`},render(){const r=`${e.gray(o)}
+${b(this.state)}  ${t.message}
+`,i=(s,c)=>{const a=this.value.includes(s.value);return c&&a?n(s,"active-selected"):a?n(s,"selected"):n(s,c?"active":"inactive")};switch(this.state){case"submit":return`${r}${e.gray(o)}  ${this.options.filter(({value:s})=>this.value.includes(s)).map(s=>n(s,"submitted")).join(e.dim(", "))||e.dim("none")}`;case"cancel":{const s=this.options.filter(({value:c})=>this.value.includes(c)).map(c=>n(c,"cancelled")).join(e.dim(", "));return`${r}${e.gray(o)}  ${s.trim()?`${s}
+${e.gray(o)}`:""}`}case"error":{const s=this.error.split(`
+`).map((c,a)=>a===0?`${e.yellow(d)}  ${e.yellow(c)}`:`   ${c}`).join(`
+`);return`${r+e.yellow(o)}  ${G({options:this.options,cursor:this.cursor,maxItems:t.maxItems,style:i}).join(`
+${e.yellow(o)}  `)}
+${s}
+`}default:return`${r}${e.cyan(o)}  ${G({options:this.options,cursor:this.cursor,maxItems:t.maxItems,style:i}).join(`
+${e.cyan(o)}  `)}
+${e.cyan(d)}
+`}}}).prompt()},be=t=>{const{selectableGroups:n=!0}=t,r=(i,s,c=[])=>{const a=i.label??String(i.value),l=typeof i.group=="string",$=l&&(c[c.indexOf(i)+1]??{group:!0}),g=l&&$.group===!0,p=l?n?`${g?d:o} `:"  ":"";if(s==="active")return`${e.dim(p)}${e.cyan(A)} ${a} ${i.hint?e.dim(`(${i.hint})`):""}`;if(s==="group-active")return`${p}${e.cyan(A)} ${e.dim(a)}`;if(s==="group-active-selected")return`${p}${e.green(T)} ${e.dim(a)}`;if(s==="selected"){const f=l||n?e.green(T):"";return`${e.dim(p)}${f} ${e.dim(a)} ${i.hint?e.dim(`(${i.hint})`):""}`}if(s==="cancelled")return`${e.strikethrough(e.dim(a))}`;if(s==="active-selected")return`${e.dim(p)}${e.green(T)} ${a} ${i.hint?e.dim(`(${i.hint})`):""}`;if(s==="submitted")return`${e.dim(a)}`;const v=l||n?e.dim(F):"";return`${e.dim(p)}${v} ${e.dim(a)}`};return new se({options:t.options,initialValues:t.initialValues,required:t.required??!0,cursorAt:t.cursorAt,selectableGroups:n,validate(i){if(this.required&&i.length===0)return`Please select at least one option.
+${e.reset(e.dim(`Press ${e.gray(e.bgWhite(e.inverse(" space ")))} to select, ${e.gray(e.bgWhite(e.inverse(" enter ")))} to submit`))}`},render(){const i=`${e.gray(o)}
+${b(this.state)}  ${t.message}
+`;switch(this.state){case"submit":return`${i}${e.gray(o)}  ${this.options.filter(({value:s})=>this.value.includes(s)).map(s=>r(s,"submitted")).join(e.dim(", "))}`;case"cancel":{const s=this.options.filter(({value:c})=>this.value.includes(c)).map(c=>r(c,"cancelled")).join(e.dim(", "));return`${i}${e.gray(o)}  ${s.trim()?`${s}
+${e.gray(o)}`:""}`}case"error":{const s=this.error.split(`
+`).map((c,a)=>a===0?`${e.yellow(d)}  ${e.yellow(c)}`:`   ${c}`).join(`
+`);return`${i}${e.yellow(o)}  ${this.options.map((c,a,l)=>{const $=this.value.includes(c.value)||c.group===!0&&this.isGroupSelected(`${c.value}`),g=a===this.cursor;return!g&&typeof c.group=="string"&&this.options[this.cursor].value===c.group?r(c,$?"group-active-selected":"group-active",l):g&&$?r(c,"active-selected",l):$?r(c,"selected",l):r(c,g?"active":"inactive",l)}).join(`
+${e.yellow(o)}  `)}
+${s}
+`}default:return`${i}${e.cyan(o)}  ${this.options.map((s,c,a)=>{const l=this.value.includes(s.value)||s.group===!0&&this.isGroupSelected(`${s.value}`),$=c===this.cursor;return!$&&typeof s.group=="string"&&this.options[this.cursor].value===s.group?r(s,l?"group-active-selected":"group-active",a):$&&l?r(s,"active-selected",a):l?r(s,"selected",a):r(s,$?"active":"inactive",a)}).join(`
+${e.cyan(o)}  `)}
+${e.cyan(d)}
+`}}}).prompt()},Me=(t="",n="")=>{const r=`
+${t}
+`.split(`
+`),i=S(n).length,s=Math.max(r.reduce((a,l)=>{const $=S(l);return $.length>a?$.length:a},0),i)+2,c=r.map(a=>`${e.gray(o)}  ${e.dim(a)}${" ".repeat(s-S(a).length)}${e.gray(o)}`).join(`
+`);process.stdout.write(`${e.gray(o)}
+${e.green(C)}  ${e.reset(n)} ${e.gray(_.repeat(Math.max(s-i-1,1))+me)}
+${c}
+${e.gray(de+_.repeat(s+2)+pe)}
+`)},xe=(t="")=>{process.stdout.write(`${e.gray(d)}  ${e.red(t)}
+
+`)},Ie=(t="")=>{process.stdout.write(`${e.gray(ue)}  ${t}
+`)},Se=(t="")=>{process.stdout.write(`${e.gray(o)}
+${e.gray(d)}  ${t}
+
+`)},M={message:(t="",{symbol:n=e.gray(o)}={})=>{const r=[`${e.gray(o)}`];if(t){const[i,...s]=t.split(`
+`);r.push(`${n}  ${i}`,...s.map(c=>`${e.gray(o)}  ${c}`))}process.stdout.write(`${r.join(`
+`)}
+`)},info:t=>{M.message(t,{symbol:e.blue(q)})},success:t=>{M.message(t,{symbol:e.green(D)})},step:t=>{M.message(t,{symbol:e.green(C)})},warn:t=>{M.message(t,{symbol:e.yellow(U)})},warning:t=>{M.warn(t)},error:t=>{M.message(t,{symbol:e.red(K)})}},J=`${e.gray(o)}  `,x={message:async(t,{symbol:n=e.gray(o)}={})=>{process.stdout.write(`${e.gray(o)}
+${n}  `);let r=3;for await(let i of t){i=i.replace(/\n/g,`
+${J}`),i.includes(`
+`)&&(r=3+S(i.slice(i.lastIndexOf(`
+`))).length);const s=S(i).length;r+s<process.stdout.columns?(r+=s,process.stdout.write(i)):(process.stdout.write(`
+${J}${i.trimStart()}`),r=3+S(i.trimStart()).length)}process.stdout.write(`
+`)},info:t=>x.message(t,{symbol:e.blue(q)}),success:t=>x.message(t,{symbol:e.green(D)}),step:t=>x.message(t,{symbol:e.green(C)}),warn:t=>x.message(t,{symbol:e.yellow(U)}),warning:t=>x.warn(t),error:t=>x.message(t,{symbol:e.red(K)})},Y=({indicator:t="dots"}={})=>{const n=V?["\u25D2","\u25D0","\u25D3","\u25D1"]:["\u2022","o","O","0"],r=V?80:120,i=process.env.CI==="true";let s,c,a=!1,l="",$,g=performance.now();const p=m=>{const h=m>1?"Something went wrong":"Canceled";a&&N(h,m)},v=()=>p(2),f=()=>p(1),j=()=>{process.on("uncaughtExceptionMonitor",v),process.on("unhandledRejection",v),process.on("SIGINT",f),process.on("SIGTERM",f),process.on("exit",p)},E=()=>{process.removeListener("uncaughtExceptionMonitor",v),process.removeListener("unhandledRejection",v),process.removeListener("SIGINT",f),process.removeListener("SIGTERM",f),process.removeListener("exit",p)},B=()=>{if($===void 0)return;i&&process.stdout.write(`
+`);const m=$.split(`
+`);process.stdout.write(oe.move(-999,m.length-1)),process.stdout.write(ae.down(m.length))},R=m=>m.replace(/\.+$/,""),O=m=>{const h=(performance.now()-m)/1e3,w=Math.floor(h/60),I=Math.floor(h%60);return w>0?`[${w}m ${I}s]`:`[${I}s]`},H=(m="")=>{a=!0,s=ne(),l=R(m),g=performance.now(),process.stdout.write(`${e.gray(o)}
+`);let h=0,w=0;j(),c=setInterval(()=>{if(i&&l===$)return;B(),$=l;const I=e.magenta(n[h]);if(i)process.stdout.write(`${I}  ${l}...`);else if(t==="timer")process.stdout.write(`${I}  ${l} ${O(g)}`);else{const z=".".repeat(Math.floor(w)).slice(0,3);process.stdout.write(`${I}  ${l}${z}`)}h=h+1<n.length?h+1:0,w=w<n.length?w+.125:0},r)},N=(m="",h=0)=>{a=!1,clearInterval(c),B();const w=h===0?e.green(C):h===1?e.red(L):e.red(W);l=R(m??l),t==="timer"?process.stdout.write(`${w}  ${l} ${O(g)}
+`):process.stdout.write(`${w}  ${l}
+`),E(),s()};return{start:H,stop:N,message:(m="")=>{l=R(m??l)}}},Ce=async(t,n)=>{const r={},i=Object.keys(t);for(const s of i){const c=t[s],a=await c({results:r})?.catch(l=>{throw l});if(typeof n?.onCancel=="function"&&ie(a)){r[s]="canceled",n.onCancel({results:r});continue}r[s]=a}return r},Te=async t=>{for(const n of t){if(n.enabled===!1)continue;const r=Y();r.start(n.title);const i=await n.task(r.message);r.stop(i||n.title)}};export{xe as cancel,ye as confirm,Ce as group,be as groupMultiselect,Ie as intro,M as log,fe as multiselect,Me as note,Se as outro,ge as password,ve as select,we as selectKey,Y as spinner,x as stream,Te as tasks,he as text};
+//# sourceMappingURL=index.mjs.map

node_modules/@clack/prompts/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@clack/prompts",
+  "version": "0.11.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bombshell-dev/clack.git",
+    "directory": "packages/prompts"
+  },
+  "bugs": {
+    "url": "https://github.com/bombshell-dev/clack/issues"
+  },
+  "homepage": "https://github.com/bombshell-dev/clack/tree/main/packages/prompts#readme",
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "author": {
+    "name": "Nate Moore",
+    "email": "nate@natemoo.re",
+    "url": "https://twitter.com/n_moore"
+  },
+  "license": "MIT",
+  "keywords": [
+    "ask",
+    "clack",
+    "cli",
+    "command-line",
+    "command",
+    "input",
+    "interact",
+    "interface",
+    "menu",
+    "prompt",
+    "prompts",
+    "stdin",
+    "ui"
+  ],
+  "dependencies": {
+    "picocolors": "^1.0.0",
+    "sisteransi": "^1.0.5",
+    "@clack/core": "0.5.0"
+  },
+  "devDependencies": {
+    "is-unicode-supported": "^1.3.0"
+  },
+  "scripts": {
+    "build": "unbuild"
+  }
+}

node_modules/@eslint-community/eslint-utils/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Toru Nagashima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@eslint-community/eslint-utils/README.md

@@ -0,0 +1,37 @@
+# @eslint-community/eslint-utils
+
+[![npm version](https://img.shields.io/npm/v/@eslint-community/eslint-utils.svg)](https://www.npmjs.com/package/@eslint-community/eslint-utils)
+[![Downloads/month](https://img.shields.io/npm/dm/@eslint-community/eslint-utils.svg)](http://www.npmtrends.com/@eslint-community/eslint-utils)
+[![Build Status](https://github.com/eslint-community/eslint-utils/workflows/CI/badge.svg)](https://github.com/eslint-community/eslint-utils/actions)
+[![Coverage Status](https://codecov.io/gh/eslint-community/eslint-utils/branch/main/graph/badge.svg)](https://codecov.io/gh/eslint-community/eslint-utils)
+
+## 🏁 Goal
+
+This package provides utility functions and classes for make ESLint custom rules.
+
+For examples:
+
+-   [`getStaticValue`](https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstaticvalue) evaluates static value on AST.
+-   [`ReferenceTracker`](https://eslint-community.github.io/eslint-utils/api/scope-utils.html#referencetracker-class) checks the members of modules/globals as handling assignments and destructuring.
+
+## 📖 Usage
+
+See [documentation](https://eslint-community.github.io/eslint-utils).
+
+## 📰 Changelog
+
+See [releases](https://github.com/eslint-community/eslint-utils/releases).
+
+## ❤️ Contributing
+
+Welcome contributing!
+
+Please use GitHub's Issues/PRs.
+
+### Development Tools
+
+-   `npm run test-coverage` runs tests and measures coverage.
+-   `npm run clean` removes the coverage result of `npm run test-coverage` command.
+-   `npm run coverage` shows the coverage result of the last `npm run test-coverage` command.
+-   `npm run lint` runs ESLint.
+-   `npm run watch` runs tests on each file change.

node_modules/@eslint-community/eslint-utils/index.d.mts

@@ -0,0 +1,217 @@
+import * as eslint from 'eslint';
+import { Rule, AST } from 'eslint';
+import * as estree from 'estree';
+
+declare const READ: unique symbol;
+declare const CALL: unique symbol;
+declare const CONSTRUCT: unique symbol;
+declare const ESM: unique symbol;
+declare class ReferenceTracker {
+    constructor(globalScope: Scope$2, options?: {
+        mode?: "legacy" | "strict" | undefined;
+        globalObjectNames?: string[] | undefined;
+    } | undefined);
+    private variableStack;
+    private globalScope;
+    private mode;
+    private globalObjectNames;
+    iterateGlobalReferences<T>(traceMap: TraceMap$2<T>): IterableIterator<TrackedReferences$2<T>>;
+    iterateCjsReferences<T_1>(traceMap: TraceMap$2<T_1>): IterableIterator<TrackedReferences$2<T_1>>;
+    iterateEsmReferences<T_2>(traceMap: TraceMap$2<T_2>): IterableIterator<TrackedReferences$2<T_2>>;
+    iteratePropertyReferences<T_3>(node: Expression, traceMap: TraceMap$2<T_3>): IterableIterator<TrackedReferences$2<T_3>>;
+    private _iterateVariableReferences;
+    private _iteratePropertyReferences;
+    private _iterateLhsReferences;
+    private _iterateImportReferences;
+}
+declare namespace ReferenceTracker {
+    export { READ };
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+}
+type Scope$2 = eslint.Scope.Scope;
+type Expression = estree.Expression;
+type TraceMap$2<T> = TraceMap$1<T>;
+type TrackedReferences$2<T> = TrackedReferences$1<T>;
+
+type StaticValue$2 = StaticValueProvided$1 | StaticValueOptional$1;
+type StaticValueProvided$1 = {
+    optional?: undefined;
+    value: unknown;
+};
+type StaticValueOptional$1 = {
+    optional?: true;
+    value: undefined;
+};
+type ReferenceTrackerOptions$1 = {
+    globalObjectNames?: string[];
+    mode?: "legacy" | "strict";
+};
+type TraceMap$1<T = unknown> = {
+    [i: string]: TraceMapObject<T>;
+};
+type TraceMapObject<T> = {
+    [i: string]: TraceMapObject<T>;
+    [CALL]?: T;
+    [CONSTRUCT]?: T;
+    [READ]?: T;
+    [ESM]?: boolean;
+};
+type TrackedReferences$1<T> = {
+    info: T;
+    node: Rule.Node;
+    path: string[];
+    type: typeof CALL | typeof CONSTRUCT | typeof READ;
+};
+type HasSideEffectOptions$1 = {
+    considerGetters?: boolean;
+    considerImplicitTypeConversion?: boolean;
+};
+type PunctuatorToken<Value extends string> = AST.Token & {
+    type: "Punctuator";
+    value: Value;
+};
+type ArrowToken$1 = PunctuatorToken<"=>">;
+type CommaToken$1 = PunctuatorToken<",">;
+type SemicolonToken$1 = PunctuatorToken<";">;
+type ColonToken$1 = PunctuatorToken<":">;
+type OpeningParenToken$1 = PunctuatorToken<"(">;
+type ClosingParenToken$1 = PunctuatorToken<")">;
+type OpeningBracketToken$1 = PunctuatorToken<"[">;
+type ClosingBracketToken$1 = PunctuatorToken<"]">;
+type OpeningBraceToken$1 = PunctuatorToken<"{">;
+type ClosingBraceToken$1 = PunctuatorToken<"}">;
+
+declare function findVariable(initialScope: Scope$1, nameOrNode: string | Identifier): Variable | null;
+type Scope$1 = eslint.Scope.Scope;
+type Variable = eslint.Scope.Variable;
+type Identifier = estree.Identifier;
+
+declare function getFunctionHeadLocation(node: FunctionNode$1, sourceCode: SourceCode$2): SourceLocation | null;
+type SourceCode$2 = eslint.SourceCode;
+type FunctionNode$1 = estree.Function;
+type SourceLocation = estree.SourceLocation;
+
+declare function getFunctionNameWithKind(node: FunctionNode, sourceCode?: eslint.SourceCode | undefined): string;
+type FunctionNode = estree.Function;
+
+declare function getInnermostScope(initialScope: Scope, node: Node$4): Scope;
+type Scope = eslint.Scope.Scope;
+type Node$4 = estree.Node;
+
+declare function getPropertyName(node: MemberExpression | MethodDefinition | Property | PropertyDefinition, initialScope?: eslint.Scope.Scope | undefined): string | null | undefined;
+type MemberExpression = estree.MemberExpression;
+type MethodDefinition = estree.MethodDefinition;
+type Property = estree.Property;
+type PropertyDefinition = estree.PropertyDefinition;
+
+declare function getStaticValue(node: Node$3, initialScope?: eslint.Scope.Scope | null | undefined): StaticValue$1 | null;
+type StaticValue$1 = StaticValue$2;
+type Node$3 = estree.Node;
+
+declare function getStringIfConstant(node: Node$2, initialScope?: eslint.Scope.Scope | null | undefined): string | null;
+type Node$2 = estree.Node;
+
+declare function hasSideEffect(node: Node$1, sourceCode: SourceCode$1, options?: HasSideEffectOptions$1 | undefined): boolean;
+type Node$1 = estree.Node;
+type SourceCode$1 = eslint.SourceCode;
+
+declare function isArrowToken(token: CommentOrToken): token is ArrowToken$1;
+declare function isCommaToken(token: CommentOrToken): token is CommaToken$1;
+declare function isSemicolonToken(token: CommentOrToken): token is SemicolonToken$1;
+declare function isColonToken(token: CommentOrToken): token is ColonToken$1;
+declare function isOpeningParenToken(token: CommentOrToken): token is OpeningParenToken$1;
+declare function isClosingParenToken(token: CommentOrToken): token is ClosingParenToken$1;
+declare function isOpeningBracketToken(token: CommentOrToken): token is OpeningBracketToken$1;
+declare function isClosingBracketToken(token: CommentOrToken): token is ClosingBracketToken$1;
+declare function isOpeningBraceToken(token: CommentOrToken): token is OpeningBraceToken$1;
+declare function isClosingBraceToken(token: CommentOrToken): token is ClosingBraceToken$1;
+declare function isCommentToken(token: CommentOrToken): token is estree.Comment;
+declare function isNotArrowToken(arg0: CommentOrToken): boolean;
+declare function isNotCommaToken(arg0: CommentOrToken): boolean;
+declare function isNotSemicolonToken(arg0: CommentOrToken): boolean;
+declare function isNotColonToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningParenToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingParenToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotCommentToken(arg0: CommentOrToken): boolean;
+type Token = eslint.AST.Token;
+type Comment = estree.Comment;
+type CommentOrToken = Comment | Token;
+
+declare function isParenthesized(timesOrNode: Node | number, nodeOrSourceCode: Node | SourceCode, optionalSourceCode?: eslint.SourceCode | undefined): boolean;
+type Node = estree.Node;
+type SourceCode = eslint.SourceCode;
+
+declare class PatternMatcher {
+    constructor(pattern: RegExp, options?: {
+        escaped?: boolean | undefined;
+    } | undefined);
+    execAll(str: string): IterableIterator<RegExpExecArray>;
+    test(str: string): boolean;
+    [Symbol.replace](str: string, replacer: string | ((...strs: string[]) => string)): string;
+}
+
+declare namespace _default {
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+    export { findVariable };
+    export { getFunctionHeadLocation };
+    export { getFunctionNameWithKind };
+    export { getInnermostScope };
+    export { getPropertyName };
+    export { getStaticValue };
+    export { getStringIfConstant };
+    export { hasSideEffect };
+    export { isArrowToken };
+    export { isClosingBraceToken };
+    export { isClosingBracketToken };
+    export { isClosingParenToken };
+    export { isColonToken };
+    export { isCommaToken };
+    export { isCommentToken };
+    export { isNotArrowToken };
+    export { isNotClosingBraceToken };
+    export { isNotClosingBracketToken };
+    export { isNotClosingParenToken };
+    export { isNotColonToken };
+    export { isNotCommaToken };
+    export { isNotCommentToken };
+    export { isNotOpeningBraceToken };
+    export { isNotOpeningBracketToken };
+    export { isNotOpeningParenToken };
+    export { isNotSemicolonToken };
+    export { isOpeningBraceToken };
+    export { isOpeningBracketToken };
+    export { isOpeningParenToken };
+    export { isParenthesized };
+    export { isSemicolonToken };
+    export { PatternMatcher };
+    export { READ };
+    export { ReferenceTracker };
+}
+
+type StaticValue = StaticValue$2;
+type StaticValueOptional = StaticValueOptional$1;
+type StaticValueProvided = StaticValueProvided$1;
+type ReferenceTrackerOptions = ReferenceTrackerOptions$1;
+type TraceMap<T> = TraceMap$1<T>;
+type TrackedReferences<T> = TrackedReferences$1<T>;
+type HasSideEffectOptions = HasSideEffectOptions$1;
+type ArrowToken = ArrowToken$1;
+type CommaToken = CommaToken$1;
+type SemicolonToken = SemicolonToken$1;
+type ColonToken = ColonToken$1;
+type OpeningParenToken = OpeningParenToken$1;
+type ClosingParenToken = ClosingParenToken$1;
+type OpeningBracketToken = OpeningBracketToken$1;
+type ClosingBracketToken = ClosingBracketToken$1;
+type OpeningBraceToken = OpeningBraceToken$1;
+type ClosingBraceToken = ClosingBraceToken$1;
+
+export { ArrowToken, CALL, CONSTRUCT, ClosingBraceToken, ClosingBracketToken, ClosingParenToken, ColonToken, CommaToken, ESM, HasSideEffectOptions, OpeningBraceToken, OpeningBracketToken, OpeningParenToken, PatternMatcher, READ, ReferenceTracker, ReferenceTrackerOptions, SemicolonToken, StaticValue, StaticValueOptional, StaticValueProvided, TraceMap, TrackedReferences, _default as default, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isParenthesized, isSemicolonToken };

node_modules/@eslint-community/eslint-utils/index.d.ts

@@ -0,0 +1,217 @@
+import * as eslint from 'eslint';
+import { Rule, AST } from 'eslint';
+import * as estree from 'estree';
+
+declare const READ: unique symbol;
+declare const CALL: unique symbol;
+declare const CONSTRUCT: unique symbol;
+declare const ESM: unique symbol;
+declare class ReferenceTracker {
+    constructor(globalScope: Scope$2, options?: {
+        mode?: "legacy" | "strict" | undefined;
+        globalObjectNames?: string[] | undefined;
+    } | undefined);
+    private variableStack;
+    private globalScope;
+    private mode;
+    private globalObjectNames;
+    iterateGlobalReferences<T>(traceMap: TraceMap$2<T>): IterableIterator<TrackedReferences$2<T>>;
+    iterateCjsReferences<T_1>(traceMap: TraceMap$2<T_1>): IterableIterator<TrackedReferences$2<T_1>>;
+    iterateEsmReferences<T_2>(traceMap: TraceMap$2<T_2>): IterableIterator<TrackedReferences$2<T_2>>;
+    iteratePropertyReferences<T_3>(node: Expression, traceMap: TraceMap$2<T_3>): IterableIterator<TrackedReferences$2<T_3>>;
+    private _iterateVariableReferences;
+    private _iteratePropertyReferences;
+    private _iterateLhsReferences;
+    private _iterateImportReferences;
+}
+declare namespace ReferenceTracker {
+    export { READ };
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+}
+type Scope$2 = eslint.Scope.Scope;
+type Expression = estree.Expression;
+type TraceMap$2<T> = TraceMap$1<T>;
+type TrackedReferences$2<T> = TrackedReferences$1<T>;
+
+type StaticValue$2 = StaticValueProvided$1 | StaticValueOptional$1;
+type StaticValueProvided$1 = {
+    optional?: undefined;
+    value: unknown;
+};
+type StaticValueOptional$1 = {
+    optional?: true;
+    value: undefined;
+};
+type ReferenceTrackerOptions$1 = {
+    globalObjectNames?: string[];
+    mode?: "legacy" | "strict";
+};
+type TraceMap$1<T = unknown> = {
+    [i: string]: TraceMapObject<T>;
+};
+type TraceMapObject<T> = {
+    [i: string]: TraceMapObject<T>;
+    [CALL]?: T;
+    [CONSTRUCT]?: T;
+    [READ]?: T;
+    [ESM]?: boolean;
+};
+type TrackedReferences$1<T> = {
+    info: T;
+    node: Rule.Node;
+    path: string[];
+    type: typeof CALL | typeof CONSTRUCT | typeof READ;
+};
+type HasSideEffectOptions$1 = {
+    considerGetters?: boolean;
+    considerImplicitTypeConversion?: boolean;
+};
+type PunctuatorToken<Value extends string> = AST.Token & {
+    type: "Punctuator";
+    value: Value;
+};
+type ArrowToken$1 = PunctuatorToken<"=>">;
+type CommaToken$1 = PunctuatorToken<",">;
+type SemicolonToken$1 = PunctuatorToken<";">;
+type ColonToken$1 = PunctuatorToken<":">;
+type OpeningParenToken$1 = PunctuatorToken<"(">;
+type ClosingParenToken$1 = PunctuatorToken<")">;
+type OpeningBracketToken$1 = PunctuatorToken<"[">;
+type ClosingBracketToken$1 = PunctuatorToken<"]">;
+type OpeningBraceToken$1 = PunctuatorToken<"{">;
+type ClosingBraceToken$1 = PunctuatorToken<"}">;
+
+declare function findVariable(initialScope: Scope$1, nameOrNode: string | Identifier): Variable | null;
+type Scope$1 = eslint.Scope.Scope;
+type Variable = eslint.Scope.Variable;
+type Identifier = estree.Identifier;
+
+declare function getFunctionHeadLocation(node: FunctionNode$1, sourceCode: SourceCode$2): SourceLocation | null;
+type SourceCode$2 = eslint.SourceCode;
+type FunctionNode$1 = estree.Function;
+type SourceLocation = estree.SourceLocation;
+
+declare function getFunctionNameWithKind(node: FunctionNode, sourceCode?: eslint.SourceCode | undefined): string;
+type FunctionNode = estree.Function;
+
+declare function getInnermostScope(initialScope: Scope, node: Node$4): Scope;
+type Scope = eslint.Scope.Scope;
+type Node$4 = estree.Node;
+
+declare function getPropertyName(node: MemberExpression | MethodDefinition | Property | PropertyDefinition, initialScope?: eslint.Scope.Scope | undefined): string | null | undefined;
+type MemberExpression = estree.MemberExpression;
+type MethodDefinition = estree.MethodDefinition;
+type Property = estree.Property;
+type PropertyDefinition = estree.PropertyDefinition;
+
+declare function getStaticValue(node: Node$3, initialScope?: eslint.Scope.Scope | null | undefined): StaticValue$1 | null;
+type StaticValue$1 = StaticValue$2;
+type Node$3 = estree.Node;
+
+declare function getStringIfConstant(node: Node$2, initialScope?: eslint.Scope.Scope | null | undefined): string | null;
+type Node$2 = estree.Node;
+
+declare function hasSideEffect(node: Node$1, sourceCode: SourceCode$1, options?: HasSideEffectOptions$1 | undefined): boolean;
+type Node$1 = estree.Node;
+type SourceCode$1 = eslint.SourceCode;
+
+declare function isArrowToken(token: CommentOrToken): token is ArrowToken$1;
+declare function isCommaToken(token: CommentOrToken): token is CommaToken$1;
+declare function isSemicolonToken(token: CommentOrToken): token is SemicolonToken$1;
+declare function isColonToken(token: CommentOrToken): token is ColonToken$1;
+declare function isOpeningParenToken(token: CommentOrToken): token is OpeningParenToken$1;
+declare function isClosingParenToken(token: CommentOrToken): token is ClosingParenToken$1;
+declare function isOpeningBracketToken(token: CommentOrToken): token is OpeningBracketToken$1;
+declare function isClosingBracketToken(token: CommentOrToken): token is ClosingBracketToken$1;
+declare function isOpeningBraceToken(token: CommentOrToken): token is OpeningBraceToken$1;
+declare function isClosingBraceToken(token: CommentOrToken): token is ClosingBraceToken$1;
+declare function isCommentToken(token: CommentOrToken): token is estree.Comment;
+declare function isNotArrowToken(arg0: CommentOrToken): boolean;
+declare function isNotCommaToken(arg0: CommentOrToken): boolean;
+declare function isNotSemicolonToken(arg0: CommentOrToken): boolean;
+declare function isNotColonToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningParenToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingParenToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotCommentToken(arg0: CommentOrToken): boolean;
+type Token = eslint.AST.Token;
+type Comment = estree.Comment;
+type CommentOrToken = Comment | Token;
+
+declare function isParenthesized(timesOrNode: Node | number, nodeOrSourceCode: Node | SourceCode, optionalSourceCode?: eslint.SourceCode | undefined): boolean;
+type Node = estree.Node;
+type SourceCode = eslint.SourceCode;
+
+declare class PatternMatcher {
+    constructor(pattern: RegExp, options?: {
+        escaped?: boolean | undefined;
+    } | undefined);
+    execAll(str: string): IterableIterator<RegExpExecArray>;
+    test(str: string): boolean;
+    [Symbol.replace](str: string, replacer: string | ((...strs: string[]) => string)): string;
+}
+
+declare namespace _default {
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+    export { findVariable };
+    export { getFunctionHeadLocation };
+    export { getFunctionNameWithKind };
+    export { getInnermostScope };
+    export { getPropertyName };
+    export { getStaticValue };
+    export { getStringIfConstant };
+    export { hasSideEffect };
+    export { isArrowToken };
+    export { isClosingBraceToken };
+    export { isClosingBracketToken };
+    export { isClosingParenToken };
+    export { isColonToken };
+    export { isCommaToken };
+    export { isCommentToken };
+    export { isNotArrowToken };
+    export { isNotClosingBraceToken };
+    export { isNotClosingBracketToken };
+    export { isNotClosingParenToken };
+    export { isNotColonToken };
+    export { isNotCommaToken };
+    export { isNotCommentToken };
+    export { isNotOpeningBraceToken };
+    export { isNotOpeningBracketToken };
+    export { isNotOpeningParenToken };
+    export { isNotSemicolonToken };
+    export { isOpeningBraceToken };
+    export { isOpeningBracketToken };
+    export { isOpeningParenToken };
+    export { isParenthesized };
+    export { isSemicolonToken };
+    export { PatternMatcher };
+    export { READ };
+    export { ReferenceTracker };
+}
+
+type StaticValue = StaticValue$2;
+type StaticValueOptional = StaticValueOptional$1;
+type StaticValueProvided = StaticValueProvided$1;
+type ReferenceTrackerOptions = ReferenceTrackerOptions$1;
+type TraceMap<T> = TraceMap$1<T>;
+type TrackedReferences<T> = TrackedReferences$1<T>;
+type HasSideEffectOptions = HasSideEffectOptions$1;
+type ArrowToken = ArrowToken$1;
+type CommaToken = CommaToken$1;
+type SemicolonToken = SemicolonToken$1;
+type ColonToken = ColonToken$1;
+type OpeningParenToken = OpeningParenToken$1;
+type ClosingParenToken = ClosingParenToken$1;
+type OpeningBracketToken = OpeningBracketToken$1;
+type ClosingBracketToken = ClosingBracketToken$1;
+type OpeningBraceToken = OpeningBraceToken$1;
+type ClosingBraceToken = ClosingBraceToken$1;
+
+export { ArrowToken, CALL, CONSTRUCT, ClosingBraceToken, ClosingBracketToken, ClosingParenToken, ColonToken, CommaToken, ESM, HasSideEffectOptions, OpeningBraceToken, OpeningBracketToken, OpeningParenToken, PatternMatcher, READ, ReferenceTracker, ReferenceTrackerOptions, SemicolonToken, StaticValue, StaticValueOptional, StaticValueProvided, TraceMap, TrackedReferences, _default as default, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isParenthesized, isSemicolonToken };

node_modules/@eslint-community/eslint-utils/package.json

@@ -0,0 +1,89 @@
+{
+    "name": "@eslint-community/eslint-utils",
+    "version": "4.9.0",
+    "description": "Utilities for ESLint plugins.",
+    "keywords": [
+        "eslint"
+    ],
+    "homepage": "https://github.com/eslint-community/eslint-utils#readme",
+    "bugs": {
+        "url": "https://github.com/eslint-community/eslint-utils/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/eslint-community/eslint-utils"
+    },
+    "license": "MIT",
+    "author": "Toru Nagashima",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "import": "./index.mjs",
+            "require": "./index.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "main": "index",
+    "module": "index.mjs",
+    "files": [
+        "index.*"
+    ],
+    "scripts": {
+        "prebuild": "npm run -s clean",
+        "build": "npm run build:dts && npm run build:rollup",
+        "build:dts": "tsc -p tsconfig.build.json",
+        "build:rollup": "rollup -c",
+        "clean": "rimraf .nyc_output coverage index.* dist",
+        "coverage": "opener ./coverage/lcov-report/index.html",
+        "docs:build": "vitepress build docs",
+        "docs:watch": "vitepress dev docs",
+        "format": "npm run -s format:prettier -- --write",
+        "format:prettier": "prettier .",
+        "format:check": "npm run -s format:prettier -- --check",
+        "lint:eslint": "eslint .",
+        "lint:format": "npm run -s format:check",
+        "lint:installed-check": "installed-check -v -i installed-check -i npm-run-all2 -i knip -i rollup-plugin-dts",
+        "lint:knip": "knip",
+        "lint": "run-p lint:*",
+        "test-coverage": "c8 mocha --reporter dot \"test/*.mjs\"",
+        "test": "mocha --reporter dot \"test/*.mjs\"",
+        "preversion": "npm run test-coverage && npm run -s build",
+        "postversion": "git push && git push --tags",
+        "prewatch": "npm run -s clean",
+        "watch": "warun \"{src,test}/**/*.mjs\" -- npm run -s test:mocha"
+    },
+    "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+    },
+    "devDependencies": {
+        "@eslint-community/eslint-plugin-mysticatea": "^15.6.1",
+        "@types/eslint": "^9.6.1",
+        "@types/estree": "^1.0.7",
+        "@typescript-eslint/parser": "^5.62.0",
+        "@typescript-eslint/types": "^5.62.0",
+        "c8": "^8.0.1",
+        "dot-prop": "^7.2.0",
+        "eslint": "^8.57.1",
+        "installed-check": "^8.0.1",
+        "knip": "^5.33.3",
+        "mocha": "^9.2.2",
+        "npm-run-all2": "^6.2.3",
+        "opener": "^1.5.2",
+        "prettier": "2.8.8",
+        "rimraf": "^3.0.2",
+        "rollup": "^2.79.2",
+        "rollup-plugin-dts": "^4.2.3",
+        "rollup-plugin-sourcemaps": "^0.6.3",
+        "semver": "^7.6.3",
+        "typescript": "^4.9.5",
+        "vitepress": "^1.4.1",
+        "warun": "^1.0.0"
+    },
+    "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+    },
+    "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+    },
+    "funding": "https://opencollective.com/eslint"
+}

node_modules/@eslint-community/regexpp/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Toru Nagashima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@eslint-community/regexpp/README.md

@@ -0,0 +1,177 @@
+# @eslint-community/regexpp
+
+[![npm version](https://img.shields.io/npm/v/@eslint-community/regexpp.svg)](https://www.npmjs.com/package/@eslint-community/regexpp)
+[![Downloads/month](https://img.shields.io/npm/dm/@eslint-community/regexpp.svg)](http://www.npmtrends.com/@eslint-community/regexpp)
+[![Build Status](https://github.com/eslint-community/regexpp/workflows/CI/badge.svg)](https://github.com/eslint-community/regexpp/actions)
+[![codecov](https://codecov.io/gh/eslint-community/regexpp/branch/main/graph/badge.svg)](https://codecov.io/gh/eslint-community/regexpp)
+
+A regular expression parser for ECMAScript.
+
+## 💿 Installation
+
+```bash
+$ npm install @eslint-community/regexpp
+```
+
+- require Node@^12.0.0 || ^14.0.0 || >=16.0.0.
+
+## 📖 Usage
+
+```ts
+import {
+    AST,
+    RegExpParser,
+    RegExpValidator,
+    RegExpVisitor,
+    parseRegExpLiteral,
+    validateRegExpLiteral,
+    visitRegExpAST
+} from "@eslint-community/regexpp"
+```
+
+### parseRegExpLiteral(source, options?)
+
+Parse a given regular expression literal then make AST object.
+
+This is equivalent to `new RegExpParser(options).parseLiteral(source)`.
+
+- **Parameters:**
+    - `source` (`string | RegExp`) The source code to parse.
+    - `options?` ([`RegExpParser.Options`]) The options to parse.
+- **Return:**
+    - The AST of the regular expression.
+
+### validateRegExpLiteral(source, options?)
+
+Validate a given regular expression literal.
+
+This is equivalent to `new RegExpValidator(options).validateLiteral(source)`.
+
+- **Parameters:**
+    - `source` (`string`) The source code to validate.
+    - `options?` ([`RegExpValidator.Options`]) The options to validate.
+
+### visitRegExpAST(ast, handlers)
+
+Visit each node of a given AST.
+
+This is equivalent to `new RegExpVisitor(handlers).visit(ast)`.
+
+- **Parameters:**
+    - `ast` ([`AST.Node`]) The AST to visit.
+    - `handlers` ([`RegExpVisitor.Handlers`]) The callbacks.
+
+### RegExpParser
+
+#### new RegExpParser(options?)
+
+- **Parameters:**
+    - `options?` ([`RegExpParser.Options`]) The options to parse.
+
+#### parser.parseLiteral(source, start?, end?)
+
+Parse a regular expression literal.
+
+- **Parameters:**
+    - `source` (`string`) The source code to parse. E.g. `"/abc/g"`.
+    - `start?` (`number`) The start index in the source code. Default is `0`.
+    - `end?` (`number`) The end index in the source code. Default is `source.length`.
+- **Return:**
+    - The AST of the regular expression.
+
+#### parser.parsePattern(source, start?, end?, flags?)
+
+Parse a regular expression pattern.
+
+- **Parameters:**
+    - `source` (`string`) The source code to parse. E.g. `"abc"`.
+    - `start?` (`number`) The start index in the source code. Default is `0`.
+    - `end?` (`number`) The end index in the source code. Default is `source.length`.
+    - `flags?` (`{ unicode?: boolean, unicodeSets?: boolean }`) The flags to enable Unicode mode, and Unicode Set mode.
+- **Return:**
+    - The AST of the regular expression pattern.
+
+#### parser.parseFlags(source, start?, end?)
+
+Parse a regular expression flags.
+
+- **Parameters:**
+    - `source` (`string`) The source code to parse. E.g. `"gim"`.
+    - `start?` (`number`) The start index in the source code. Default is `0`.
+    - `end?` (`number`) The end index in the source code. Default is `source.length`.
+- **Return:**
+    - The AST of the regular expression flags.
+
+### RegExpValidator
+
+#### new RegExpValidator(options)
+
+- **Parameters:**
+    - `options` ([`RegExpValidator.Options`]) The options to validate.
+
+#### validator.validateLiteral(source, start, end)
+
+Validate a regular expression literal.
+
+- **Parameters:**
+    - `source` (`string`) The source code to validate.
+    - `start?` (`number`) The start index in the source code. Default is `0`.
+    - `end?` (`number`) The end index in the source code. Default is `source.length`.
+
+#### validator.validatePattern(source, start, end, flags)
+
+Validate a regular expression pattern.
+
+- **Parameters:**
+    - `source` (`string`) The source code to validate.
+    - `start?` (`number`) The start index in the source code. Default is `0`.
+    - `end?` (`number`) The end index in the source code. Default is `source.length`.
+    - `flags?` (`{ unicode?: boolean, unicodeSets?: boolean }`) The flags to enable Unicode mode, and Unicode Set mode.
+
+#### validator.validateFlags(source, start, end)
+
+Validate a regular expression flags.
+
+- **Parameters:**
+    - `source` (`string`) The source code to validate.
+    - `start?` (`number`) The start index in the source code. Default is `0`.
+    - `end?` (`number`) The end index in the source code. Default is `source.length`.
+
+### RegExpVisitor
+
+#### new RegExpVisitor(handlers)
+
+- **Parameters:**
+    - `handlers` ([`RegExpVisitor.Handlers`]) The callbacks.
+
+#### visitor.visit(ast)
+
+Validate a regular expression literal.
+
+- **Parameters:**
+    - `ast` ([`AST.Node`]) The AST to visit.
+
+## 📰 Changelog
+
+- [GitHub Releases](https://github.com/eslint-community/regexpp/releases)
+
+## 🍻 Contributing
+
+Welcome contributing!
+
+Please use GitHub's Issues/PRs.
+
+### Development Tools
+
+- `npm test` runs tests and measures coverage.
+- `npm run build` compiles TypeScript source code to `index.js`, `index.js.map`, and `index.d.ts`.
+- `npm run clean` removes the temporary files which are created by `npm test` and `npm run build`.
+- `npm run lint` runs ESLint.
+- `npm run update:test` updates test fixtures.
+- `npm run update:ids` updates `src/unicode/ids.ts`.
+- `npm run watch` runs tests with `--watch` option.
+
+[`AST.Node`]: src/ast.ts#L4
+[`RegExpParser.Options`]: src/parser.ts#L743
+[`RegExpValidator.Options`]: src/validator.ts#L220
+[`RegExpVisitor.Handlers`]: src/visitor.ts#L291

node_modules/@eslint-community/regexpp/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@eslint-community/regexpp",
+  "version": "4.12.2",
+  "description": "Regular expression parser for ECMAScript.",
+  "keywords": [
+    "regexp",
+    "regular",
+    "expression",
+    "parser",
+    "validator",
+    "ast",
+    "abstract",
+    "syntax",
+    "tree",
+    "ecmascript",
+    "es2015",
+    "es2016",
+    "es2017",
+    "es2018",
+    "es2019",
+    "es2020",
+    "es2021",
+    "annexB"
+  ],
+  "homepage": "https://github.com/eslint-community/regexpp#readme",
+  "bugs": {
+    "url": "https://github.com/eslint-community/regexpp/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eslint-community/regexpp"
+  },
+  "license": "MIT",
+  "author": "Toru Nagashima",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "index",
+  "files": [
+    "index.*"
+  ],
+  "scripts": {
+    "prebuild": "npm run -s clean",
+    "build": "run-s build:*",
+    "build:tsc": "tsc --module es2015",
+    "build:rollup": "rollup -c",
+    "build:dts": "npm run -s build:tsc -- --removeComments false && dts-bundle --name @eslint-community/regexpp --main .temp/index.d.ts --out ../index.d.ts && prettier --write index.d.ts",
+    "clean": "rimraf .temp index.*",
+    "lint": "eslint . --ext .ts",
+    "test": "nyc _mocha \"test/*.ts\" --reporter dot --timeout 10000",
+    "debug": "mocha --require ts-node/register/transpile-only \"test/*.ts\" --reporter dot --timeout 10000",
+    "update:test": "ts-node scripts/update-fixtures.ts",
+    "update:unicode": "run-s update:unicode:*",
+    "update:unicode:ids": "ts-node scripts/update-unicode-ids.ts",
+    "update:unicode:props": "ts-node scripts/update-unicode-properties.ts",
+    "update:test262:extract": "ts-node -T scripts/extract-test262.ts",
+    "preversion": "npm test && npm run -s build",
+    "postversion": "git push && git push --tags",
+    "prewatch": "npm run -s clean",
+    "watch": "_mocha \"test/*.ts\" --require ts-node/register --reporter dot --timeout 10000 --watch-extensions ts --watch --growl"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@eslint-community/eslint-plugin-mysticatea": "^15.5.1",
+    "@rollup/plugin-node-resolve": "^14.1.0",
+    "@types/eslint": "^8.44.3",
+    "@types/jsdom": "^16.2.15",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^12.20.55",
+    "dts-bundle": "^0.7.3",
+    "eslint": "^8.50.0",
+    "js-tokens": "^8.0.2",
+    "jsdom": "^19.0.0",
+    "mocha": "^9.2.2",
+    "npm-run-all2": "^6.2.2",
+    "nyc": "^14.1.1",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.79.1",
+    "rollup-plugin-sourcemaps": "^0.6.3",
+    "ts-node": "^10.9.1",
+    "typescript": "~5.0.2"
+  },
+  "engines": {
+    "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+  }
+}

node_modules/@eslint/config-array/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

node_modules/@eslint/config-array/README.md

@@ -0,0 +1,368 @@
+# Config Array
+
+## Description
+
+A config array is a way of managing configurations that are based on glob pattern matching of filenames. Each config array contains the information needed to determine the correct configuration for any file based on the filename.
+
+**Note:** This is a generic package that can be used outside of ESLint. It contains no ESLint-specific functionality.
+
+## Installation
+
+For Node.js and compatible runtimes:
+
+```shell
+npm install @eslint/config-array
+# or
+yarn add @eslint/config-array
+# or
+pnpm install @eslint/config-array
+# or
+bun add @eslint/config-array
+```
+
+For Deno:
+
+```shell
+deno add @eslint/config-array
+```
+
+## Background
+
+The basic idea is that all configuration, including overrides, can be represented by a single array where each item in the array is a config object. Config objects appearing later in the array override config objects appearing earlier in the array. You can calculate a config for a given file by traversing all config objects in the array to find the ones that match the filename. Matching is done by specifying glob patterns in `files` and `ignores` properties on each config object. Here's an example:
+
+```js
+export default [
+	// match all JSON files
+	{
+		name: "JSON Handler",
+		files: ["**/*.json"],
+		handler: jsonHandler,
+	},
+
+	// match only package.json
+	{
+		name: "package.json Handler",
+		files: ["package.json"],
+		handler: packageJsonHandler,
+	},
+];
+```
+
+In this example, there are two config objects: the first matches all JSON files in all directories and the second matches just `package.json` in the base path directory (all the globs are evaluated as relative to a base path that can be specified). When you retrieve a configuration for `foo.json`, only the first config object matches so `handler` is equal to `jsonHandler`; when you retrieve a configuration for `package.json`, `handler` is equal to `packageJsonHandler` (because both config objects match, the second one wins).
+
+## Usage
+
+First, import the `ConfigArray` constructor:
+
+```js
+import { ConfigArray } from "@eslint/config-array";
+
+// or using CommonJS
+
+const { ConfigArray } = require("@eslint/config-array");
+```
+
+When you create a new instance of `ConfigArray`, you must pass in two arguments: an array of configs and an options object. The array of configs is most likely read in from a configuration file, so here's a typical example:
+
+```js
+const configFilename = path.resolve(process.cwd(), "my.config.js");
+const { default: rawConfigs } = await import(configFilename);
+const configs = new ConfigArray(rawConfigs, {
+	// the path to match filenames from
+	basePath: process.cwd(),
+
+	// additional items in each config
+	schema: mySchema,
+});
+```
+
+This example reads in an object or array from `my.config.js` and passes it into the `ConfigArray` constructor as the first argument. The second argument is an object specifying the `basePath` (the directory in which `my.config.js` is found) and a `schema` to define the additional properties of a config object beyond `files`, `ignores`, `basePath`, and `name`.
+
+### Specifying a Schema
+
+The `schema` option is required for you to use additional properties in config objects. The schema is an object that follows the format of an [`ObjectSchema`](https://npmjs.com/package/@eslint/object-schema). The schema specifies both validation and merge rules that the `ConfigArray` instance needs to combine configs when there are multiple matches. Here's an example:
+
+```js
+const configFilename = path.resolve(process.cwd(), "my.config.js");
+const { default: rawConfigs } = await import(configFilename);
+
+const mySchema = {
+
+    // define the handler key in configs
+    handler: {
+        required: true,
+        merge(a, b) {
+            if (!b) return a;
+            if (!a) return b;
+        },
+        validate(value) {
+            if (typeof value !== "function") {
+                throw new TypeError("Function expected.");
+            }
+        }
+    }
+};
+
+const configs = new ConfigArray(rawConfigs, {
+
+    // the path to match filenames from
+    basePath: process.cwd(),
+
+    // additional item schemas in each config
+    schema: mySchema,
+
+    // additional config types supported (default: [])
+    extraConfigTypes: ["array", "function"];
+});
+```
+
+### Config Arrays
+
+Config arrays can be multidimensional, so it's possible for a config array to contain another config array when `extraConfigTypes` contains `"array"`, such as:
+
+```js
+export default [
+	// JS config
+	{
+		files: ["**/*.js"],
+		handler: jsHandler,
+	},
+
+	// JSON configs
+	[
+		// match all JSON files
+		{
+			name: "JSON Handler",
+			files: ["**/*.json"],
+			handler: jsonHandler,
+		},
+
+		// match only package.json
+		{
+			name: "package.json Handler",
+			files: ["package.json"],
+			handler: packageJsonHandler,
+		},
+	],
+
+	// filename must match function
+	{
+		files: [filePath => filePath.endsWith(".md")],
+		handler: markdownHandler,
+	},
+
+	// filename must match all patterns in subarray
+	{
+		files: [["*.test.*", "*.js"]],
+		handler: jsTestHandler,
+	},
+
+	// filename must not match patterns beginning with !
+	{
+		name: "Non-JS files",
+		files: ["!*.js"],
+		settings: {
+			js: false,
+		},
+	},
+
+	// specific settings for files inside `src` directory
+	{
+		name: "Source files",
+		basePath: "src",
+		files: ["**/*"],
+		settings: {
+			source: true,
+		},
+	},
+];
+```
+
+In this example, the array contains both config objects and a config array. When a config array is normalized (see details below), it is flattened so only config objects remain. However, the order of evaluation remains the same.
+
+If the `files` array contains a function, then that function is called with the path of the file as it was passed in. The function is expected to return `true` if there is a match and `false` if not. (The `ignores` array can also contain functions.)
+
+If the `files` array contains an item that is an array of strings and functions, then all patterns must match in order for the config to match. In the preceding examples, both `*.test.*` and `*.js` must match in order for the config object to be used.
+
+If a pattern in the files array begins with `!` then it excludes that pattern. In the preceding example, any filename that doesn't end with `.js` will automatically get a `settings.js` property set to `false`.
+
+You can also specify an `ignores` key that will force files matching those patterns to not be included. If the `ignores` key is in a config object without any other keys, then those ignores will always be applied; otherwise those ignores act as exclusions. Here's an example:
+
+```js
+export default [
+
+    // Always ignored
+    {
+        ignores: ["**/.git/**", "**/node_modules/**"]
+    },
+
+    // .eslintrc.js file is ignored only when .js file matches
+    {
+        files: ["**/*.js"],
+        ignores: [".eslintrc.js"]
+        handler: jsHandler
+    }
+];
+```
+
+You can use negated patterns in `ignores` to exclude a file that was already ignored, such as:
+
+```js
+export default [
+	// Ignore all JSON files except tsconfig.json
+	{
+		files: ["**/*"],
+		ignores: ["**/*.json", "!tsconfig.json"],
+	},
+];
+```
+
+### Config Functions
+
+Config arrays can also include config functions when `extraConfigTypes` contains `"function"`. A config function accepts a single parameter, `context` (defined by you), and must return either a config object or a config array (it cannot return another function). Config functions allow end users to execute code in the creation of appropriate config objects. Here's an example:
+
+```js
+export default [
+	// JS config
+	{
+		files: ["**/*.js"],
+		handler: jsHandler,
+	},
+
+	// JSON configs
+	function (context) {
+		return [
+			// match all JSON files
+			{
+				name: context.name + " JSON Handler",
+				files: ["**/*.json"],
+				handler: jsonHandler,
+			},
+
+			// match only package.json
+			{
+				name: context.name + " package.json Handler",
+				files: ["package.json"],
+				handler: packageJsonHandler,
+			},
+		];
+	},
+];
+```
+
+When a config array is normalized, each function is executed and replaced in the config array with the return value.
+
+**Note:** Config functions can also be async.
+
+### Normalizing Config Arrays
+
+Once a config array has been created and loaded with all of the raw config data, it must be normalized before it can be used. The normalization process goes through and flattens the config array as well as executing all config functions to get their final values.
+
+To normalize a config array, call the `normalize()` method and pass in a context object:
+
+```js
+await configs.normalize({
+	name: "MyApp",
+});
+```
+
+The `normalize()` method returns a promise, so be sure to use the `await` operator. The config array instance is normalized in-place, so you don't need to create a new variable.
+
+If you want to disallow async config functions, you can call `normalizeSync()` instead. This method is completely synchronous and does not require using the `await` operator as it does not return a promise:
+
+```js
+await configs.normalizeSync({
+	name: "MyApp",
+});
+```
+
+**Important:** Once a `ConfigArray` is normalized, it cannot be changed further. You can, however, create a new `ConfigArray` and pass in the normalized instance to create an unnormalized copy.
+
+### Getting Config for a File
+
+To get the config for a file, use the `getConfig()` method on a normalized config array and pass in the filename to get a config for:
+
+```js
+// pass in filename
+const fileConfig = configs.getConfig(
+	path.resolve(process.cwd(), "package.json"),
+);
+```
+
+The config array always returns an object, even if there are no configs matching the given filename. You can then inspect the returned config object to determine how to proceed.
+
+A few things to keep in mind:
+
+- If a filename is not an absolute path, it will be resolved relative to the base path directory.
+- The returned config object never has `files`, `ignores`, `basePath`, or `name` properties; the only properties on the object will be the other configuration options specified.
+- The config array caches configs, so subsequent calls to `getConfig()` with the same filename will return in a fast lookup rather than another calculation.
+- A config will only be generated if the filename matches an entry in a `files` key. A config will not be generated without matching a `files` key (configs without a `files` key are only applied when another config with a `files` key is applied; configs without `files` are never applied on their own). Any config with a `files` key entry that is `*` or ends with `/**` or `/*` will only be applied if another entry in the same `files` key matches or another config matches.
+
+## Determining Ignored Paths
+
+You can determine if a file is ignored by using the `isFileIgnored()` method and passing in the path of any file, as in this example:
+
+```js
+const ignored = configs.isFileIgnored("/foo/bar/baz.txt");
+```
+
+A file is considered ignored if any of the following is true:
+
+- **It's parent directory is ignored.** For example, if `foo` is in `ignores`, then `foo/a.js` is considered ignored.
+- **It has an ancestor directory that is ignored.** For example, if `foo` is in `ignores`, then `foo/baz/a.js` is considered ignored.
+- **It matches an ignored file pattern.** For example, if `**/a.js` is in `ignores`, then `foo/a.js` and `foo/baz/a.js` are considered ignored.
+- **If it matches an entry in `files` and also in `ignores`.** For example, if `**/*.js` is in `files` and `**/a.js` is in `ignores`, then `foo/a.js` and `foo/baz/a.js` are considered ignored.
+- **The file is outside the `basePath`.** If the `basePath` is `/usr/me`, then `/foo/a.js` is considered ignored.
+
+For directories, use the `isDirectoryIgnored()` method and pass in the path of any directory, as in this example:
+
+```js
+const ignored = configs.isDirectoryIgnored("/foo/bar/");
+```
+
+A directory is considered ignored if any of the following is true:
+
+- **It's parent directory is ignored.** For example, if `foo` is in `ignores`, then `foo/baz` is considered ignored.
+- **It has an ancestor directory that is ignored.** For example, if `foo` is in `ignores`, then `foo/bar/baz/a.js` is considered ignored.
+- **It matches and ignored file pattern.** For example, if `**/a.js` is in `ignores`, then `foo/a.js` and `foo/baz/a.js` are considered ignored.
+- **If it matches an entry in `files` and also in `ignores`.** For example, if `**/*.js` is in `files` and `**/a.js` is in `ignores`, then `foo/a.js` and `foo/baz/a.js` are considered ignored.
+- **The file is outside the `basePath`.** If the `basePath` is `/usr/me`, then `/foo/a.js` is considered ignored.
+
+**Important:** A pattern such as `foo/**` means that `foo` and `foo/` are _not_ ignored whereas `foo/bar` is ignored. If you want to ignore `foo` and all of its subdirectories, use the pattern `foo` or `foo/` in `ignores`.
+
+## Caching Mechanisms
+
+Each `ConfigArray` aggressively caches configuration objects to avoid unnecessary work. This caching occurs in two ways:
+
+1. **File-based Caching.** For each filename that is passed into a method, the resulting config is cached against that filename so you're always guaranteed to get the same object returned from `getConfig()` whenever you pass the same filename in.
+2. **Index-based Caching.** Whenever a config is calculated, the config elements that were used to create the config are also cached. So if a given filename matches elements 1, 5, and 7, the resulting config is cached with a key of `1,5,7`. That way, if another file is passed that matches the same config elements, the result is already known and doesn't have to be recalculated. That means two files that match all the same elements will return the same config from `getConfig()`.
+
+## Acknowledgements
+
+The design of this project was influenced by feedback on the ESLint RFC, and incorporates ideas from:
+
+- Teddy Katz (@not-an-aardvark)
+- Toru Nagashima (@mysticatea)
+- Kai Cataldo (@kaicataldo)
+
+## License
+
+Apache 2.0
+
+<!-- NOTE: This section is autogenerated. Do not manually edit.-->
+<!--sponsorsstart-->
+
+## Sponsors
+
+The following companies, organizations, and individuals support ESLint's ongoing maintenance and development. [Become a Sponsor](https://eslint.org/donate)
+to get your logo on our READMEs and [website](https://eslint.org/sponsors).
+
+<h3>Platinum Sponsors</h3>
+<p><a href="https://automattic.com"><img src="https://images.opencollective.com/automattic/d0ef3e1/logo.png" alt="Automattic" height="128"></a> <a href="https://www.airbnb.com/"><img src="https://images.opencollective.com/airbnb/d327d66/logo.png" alt="Airbnb" height="128"></a></p><h3>Gold Sponsors</h3>
+<p><a href="https://qlty.sh/"><img src="https://images.opencollective.com/qltysh/33d157d/logo.png" alt="Qlty Software" height="96"></a> <a href="https://trunk.io/"><img src="https://images.opencollective.com/trunkio/fb92d60/avatar.png" alt="trunk.io" height="96"></a> <a href="https://shopify.engineering/"><img src="https://avatars.githubusercontent.com/u/8085" alt="Shopify" height="96"></a></p><h3>Silver Sponsors</h3>
+<p><a href="https://vite.dev/"><img src="https://images.opencollective.com/vite/e6d15e1/logo.png" alt="Vite" height="64"></a> <a href="https://liftoff.io/"><img src="https://images.opencollective.com/liftoff/5c4fa84/logo.png" alt="Liftoff" height="64"></a> <a href="https://americanexpress.io"><img src="https://avatars.githubusercontent.com/u/3853301" alt="American Express" height="64"></a> <a href="https://stackblitz.com"><img src="https://avatars.githubusercontent.com/u/28635252" alt="StackBlitz" height="64"></a></p><h3>Bronze Sponsors</h3>
+<p><a href="https://syntax.fm"><img src="https://github.com/syntaxfm.png" alt="Syntax" height="32"></a> <a href="https://cybozu.co.jp/"><img src="https://images.opencollective.com/cybozu/933e46d/logo.png" alt="Cybozu" height="32"></a> <a href="https://sentry.io"><img src="https://github.com/getsentry.png" alt="Sentry" height="32"></a> <a href="https://discord.com"><img src="https://images.opencollective.com/discordapp/f9645d9/logo.png" alt="Discord" height="32"></a> <a href="https://www.gitbook.com"><img src="https://avatars.githubusercontent.com/u/7111340" alt="GitBook" height="32"></a> <a href="https://nx.dev"><img src="https://avatars.githubusercontent.com/u/23692104" alt="Nx" height="32"></a> <a href="https://opensource.mercedes-benz.com/"><img src="https://avatars.githubusercontent.com/u/34240465" alt="Mercedes-Benz Group" height="32"></a> <a href="https://herocoders.com"><img src="https://avatars.githubusercontent.com/u/37549774" alt="HeroCoders" height="32"></a> <a href="https://www.lambdatest.com"><img src="https://avatars.githubusercontent.com/u/171592363" alt="LambdaTest" height="32"></a></p>
+<h3>Technology Sponsors</h3>
+Technology sponsors allow us to use their products and services for free as part of a contribution to the open source ecosystem and our work.
+<p><a href="https://netlify.com"><img src="https://raw.githubusercontent.com/eslint/eslint.org/main/src/assets/images/techsponsors/netlify-icon.svg" alt="Netlify" height="32"></a> <a href="https://algolia.com"><img src="https://raw.githubusercontent.com/eslint/eslint.org/main/src/assets/images/techsponsors/algolia-icon.svg" alt="Algolia" height="32"></a> <a href="https://1password.com"><img src="https://raw.githubusercontent.com/eslint/eslint.org/main/src/assets/images/techsponsors/1password-icon.svg" alt="1Password" height="32"></a></p>
+<!--sponsorsend-->

node_modules/@eslint/config-array/dist/cjs/index.d.cts

@@ -0,0 +1,145 @@
+export { ObjectSchema } from "@eslint/object-schema";
+export type PropertyDefinition = $eslintobjectschema.PropertyDefinition;
+export type ObjectDefinition = $eslintobjectschema.ObjectDefinition;
+export type ConfigObject = $typests.ConfigObject;
+export type IMinimatchStatic = minimatch.IMinimatchStatic;
+export type IMinimatch = minimatch.IMinimatch;
+export type ObjectSchemaInstance = ObjectSchema;
+/**
+ * Represents an array of config objects and provides method for working with
+ * those config objects.
+ */
+export class ConfigArray extends Array<any> {
+    /**
+     * Creates a new instance of ConfigArray.
+     * @param {Iterable|Function|Object} configs An iterable yielding config
+     *      objects, or a config function, or a config object.
+     * @param {Object} options The options for the ConfigArray.
+     * @param {string} [options.basePath="/"] The absolute path of the config file directory.
+     * 		Defaults to `"/"`.
+     * @param {boolean} [options.normalized=false] Flag indicating if the
+     *      configs have already been normalized.
+     * @param {Object} [options.schema] The additional schema
+     *      definitions to use for the ConfigArray schema.
+     * @param {Array<string>} [options.extraConfigTypes] List of config types supported.
+     * @throws {TypeError} When the `basePath` is not a non-empty string,
+     */
+    constructor(configs: Iterable<any> | Function | any, { basePath, normalized, schema: customSchema, extraConfigTypes, }?: {
+        basePath?: string;
+        normalized?: boolean;
+        schema?: any;
+        extraConfigTypes?: Array<string>;
+    });
+    /**
+     * The path of the config file that this array was loaded from.
+     * This is used to calculate filename matches.
+     * @property basePath
+     * @type {string}
+     */
+    basePath: string;
+    /**
+     * The supported config types.
+     * @type {Array<string>}
+     */
+    extraConfigTypes: Array<string>;
+    /**
+     * Returns the `files` globs from every config object in the array.
+     * This can be used to determine which files will be matched by a
+     * config array or to use as a glob pattern when no patterns are provided
+     * for a command line interface.
+     * @returns {Array<string|Function>} An array of matchers.
+     */
+    get files(): Array<string | Function>;
+    /**
+     * Returns ignore matchers that should always be ignored regardless of
+     * the matching `files` fields in any configs. This is necessary to mimic
+     * the behavior of things like .gitignore and .eslintignore, allowing a
+     * globbing operation to be faster.
+     * @returns {Object[]} An array of config objects representing global ignores.
+     */
+    get ignores(): any[];
+    /**
+     * Indicates if the config array has been normalized.
+     * @returns {boolean} True if the config array is normalized, false if not.
+     */
+    isNormalized(): boolean;
+    /**
+     * Normalizes a config array by flattening embedded arrays and executing
+     * config functions.
+     * @param {Object} [context] The context object for config functions.
+     * @returns {Promise<ConfigArray>} The current ConfigArray instance.
+     */
+    normalize(context?: any): Promise<ConfigArray>;
+    /**
+     * Normalizes a config array by flattening embedded arrays and executing
+     * config functions.
+     * @param {Object} [context] The context object for config functions.
+     * @returns {ConfigArray} The current ConfigArray instance.
+     */
+    normalizeSync(context?: any): ConfigArray;
+    /**
+     * Returns the config object for a given file path and a status that can be used to determine why a file has no config.
+     * @param {string} filePath The path of a file to get a config for.
+     * @returns {{ config?: Object, status: "ignored"|"external"|"unconfigured"|"matched" }}
+     * An object with an optional property `config` and property `status`.
+     * `config` is the config object for the specified file as returned by {@linkcode ConfigArray.getConfig},
+     * `status` a is one of the constants returned by {@linkcode ConfigArray.getConfigStatus}.
+     */
+    getConfigWithStatus(filePath: string): {
+        config?: any;
+        status: "ignored" | "external" | "unconfigured" | "matched";
+    };
+    /**
+     * Returns the config object for a given file path.
+     * @param {string} filePath The path of a file to get a config for.
+     * @returns {Object|undefined} The config object for this file or `undefined`.
+     */
+    getConfig(filePath: string): any | undefined;
+    /**
+     * Determines whether a file has a config or why it doesn't.
+     * @param {string} filePath The path of the file to check.
+     * @returns {"ignored"|"external"|"unconfigured"|"matched"} One of the following values:
+     * * `"ignored"`: the file is ignored
+     * * `"external"`: the file is outside the base path
+     * * `"unconfigured"`: the file is not matched by any config
+     * * `"matched"`: the file has a matching config
+     */
+    getConfigStatus(filePath: string): "ignored" | "external" | "unconfigured" | "matched";
+    /**
+     * Determines if the given filepath is ignored based on the configs.
+     * @param {string} filePath The path of a file to check.
+     * @returns {boolean} True if the path is ignored, false if not.
+     * @deprecated Use `isFileIgnored` instead.
+     */
+    isIgnored(filePath: string): boolean;
+    /**
+     * Determines if the given filepath is ignored based on the configs.
+     * @param {string} filePath The path of a file to check.
+     * @returns {boolean} True if the path is ignored, false if not.
+     */
+    isFileIgnored(filePath: string): boolean;
+    /**
+     * Determines if the given directory is ignored based on the configs.
+     * This checks only default `ignores` that don't have `files` in the
+     * same config. A pattern such as `/foo` be considered to ignore the directory
+     * while a pattern such as `/foo/**` is not considered to ignore the
+     * directory because it is matching files.
+     * @param {string} directoryPath The path of a directory to check.
+     * @returns {boolean} True if the directory is ignored, false if not. Will
+     * 		return true for any directory that is not inside of `basePath`.
+     * @throws {Error} When the `ConfigArray` is not normalized.
+     */
+    isDirectoryIgnored(directoryPath: string): boolean;
+    #private;
+}
+export namespace ConfigArraySymbol {
+    let isNormalized: symbol;
+    let configCache: symbol;
+    let schema: symbol;
+    let finalizeConfig: symbol;
+    let preprocessConfig: symbol;
+}
+import type * as $eslintobjectschema from "@eslint/object-schema";
+import type * as $typests from "./types.cts";
+import minimatch from 'minimatch';
+import { ObjectSchema } from '@eslint/object-schema';

node_modules/@eslint/config-array/dist/cjs/types.cts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Types for the config-array package.
+ * @author Nicholas C. Zakas
+ */
+
+export interface ConfigObject {
+	/**
+	 * The base path for files and ignores.
+	 */
+	basePath?: string;
+
+	/**
+	 * The files to include.
+	 */
+	files?: string[];
+
+	/**
+	 * The files to exclude.
+	 */
+	ignores?: string[];
+
+	/**
+	 * The name of the config object.
+	 */
+	name?: string;
+
+	// may also have any number of other properties
+	[key: string]: unknown;
+}

node_modules/@eslint/config-array/dist/esm/index.d.ts

@@ -0,0 +1,145 @@
+export { ObjectSchema } from "@eslint/object-schema";
+export type PropertyDefinition = $eslintobjectschema.PropertyDefinition;
+export type ObjectDefinition = $eslintobjectschema.ObjectDefinition;
+export type ConfigObject = $typests.ConfigObject;
+export type IMinimatchStatic = minimatch.IMinimatchStatic;
+export type IMinimatch = minimatch.IMinimatch;
+export type ObjectSchemaInstance = ObjectSchema;
+/**
+ * Represents an array of config objects and provides method for working with
+ * those config objects.
+ */
+export class ConfigArray extends Array<any> {
+    /**
+     * Creates a new instance of ConfigArray.
+     * @param {Iterable|Function|Object} configs An iterable yielding config
+     *      objects, or a config function, or a config object.
+     * @param {Object} options The options for the ConfigArray.
+     * @param {string} [options.basePath="/"] The absolute path of the config file directory.
+     * 		Defaults to `"/"`.
+     * @param {boolean} [options.normalized=false] Flag indicating if the
+     *      configs have already been normalized.
+     * @param {Object} [options.schema] The additional schema
+     *      definitions to use for the ConfigArray schema.
+     * @param {Array<string>} [options.extraConfigTypes] List of config types supported.
+     * @throws {TypeError} When the `basePath` is not a non-empty string,
+     */
+    constructor(configs: Iterable<any> | Function | any, { basePath, normalized, schema: customSchema, extraConfigTypes, }?: {
+        basePath?: string;
+        normalized?: boolean;
+        schema?: any;
+        extraConfigTypes?: Array<string>;
+    });
+    /**
+     * The path of the config file that this array was loaded from.
+     * This is used to calculate filename matches.
+     * @property basePath
+     * @type {string}
+     */
+    basePath: string;
+    /**
+     * The supported config types.
+     * @type {Array<string>}
+     */
+    extraConfigTypes: Array<string>;
+    /**
+     * Returns the `files` globs from every config object in the array.
+     * This can be used to determine which files will be matched by a
+     * config array or to use as a glob pattern when no patterns are provided
+     * for a command line interface.
+     * @returns {Array<string|Function>} An array of matchers.
+     */
+    get files(): Array<string | Function>;
+    /**
+     * Returns ignore matchers that should always be ignored regardless of
+     * the matching `files` fields in any configs. This is necessary to mimic
+     * the behavior of things like .gitignore and .eslintignore, allowing a
+     * globbing operation to be faster.
+     * @returns {Object[]} An array of config objects representing global ignores.
+     */
+    get ignores(): any[];
+    /**
+     * Indicates if the config array has been normalized.
+     * @returns {boolean} True if the config array is normalized, false if not.
+     */
+    isNormalized(): boolean;
+    /**
+     * Normalizes a config array by flattening embedded arrays and executing
+     * config functions.
+     * @param {Object} [context] The context object for config functions.
+     * @returns {Promise<ConfigArray>} The current ConfigArray instance.
+     */
+    normalize(context?: any): Promise<ConfigArray>;
+    /**
+     * Normalizes a config array by flattening embedded arrays and executing
+     * config functions.
+     * @param {Object} [context] The context object for config functions.
+     * @returns {ConfigArray} The current ConfigArray instance.
+     */
+    normalizeSync(context?: any): ConfigArray;
+    /**
+     * Returns the config object for a given file path and a status that can be used to determine why a file has no config.
+     * @param {string} filePath The path of a file to get a config for.
+     * @returns {{ config?: Object, status: "ignored"|"external"|"unconfigured"|"matched" }}
+     * An object with an optional property `config` and property `status`.
+     * `config` is the config object for the specified file as returned by {@linkcode ConfigArray.getConfig},
+     * `status` a is one of the constants returned by {@linkcode ConfigArray.getConfigStatus}.
+     */
+    getConfigWithStatus(filePath: string): {
+        config?: any;
+        status: "ignored" | "external" | "unconfigured" | "matched";
+    };
+    /**
+     * Returns the config object for a given file path.
+     * @param {string} filePath The path of a file to get a config for.
+     * @returns {Object|undefined} The config object for this file or `undefined`.
+     */
+    getConfig(filePath: string): any | undefined;
+    /**
+     * Determines whether a file has a config or why it doesn't.
+     * @param {string} filePath The path of the file to check.
+     * @returns {"ignored"|"external"|"unconfigured"|"matched"} One of the following values:
+     * * `"ignored"`: the file is ignored
+     * * `"external"`: the file is outside the base path
+     * * `"unconfigured"`: the file is not matched by any config
+     * * `"matched"`: the file has a matching config
+     */
+    getConfigStatus(filePath: string): "ignored" | "external" | "unconfigured" | "matched";
+    /**
+     * Determines if the given filepath is ignored based on the configs.
+     * @param {string} filePath The path of a file to check.
+     * @returns {boolean} True if the path is ignored, false if not.
+     * @deprecated Use `isFileIgnored` instead.
+     */
+    isIgnored(filePath: string): boolean;
+    /**
+     * Determines if the given filepath is ignored based on the configs.
+     * @param {string} filePath The path of a file to check.
+     * @returns {boolean} True if the path is ignored, false if not.
+     */
+    isFileIgnored(filePath: string): boolean;
+    /**
+     * Determines if the given directory is ignored based on the configs.
+     * This checks only default `ignores` that don't have `files` in the
+     * same config. A pattern such as `/foo` be considered to ignore the directory
+     * while a pattern such as `/foo/**` is not considered to ignore the
+     * directory because it is matching files.
+     * @param {string} directoryPath The path of a directory to check.
+     * @returns {boolean} True if the directory is ignored, false if not. Will
+     * 		return true for any directory that is not inside of `basePath`.
+     * @throws {Error} When the `ConfigArray` is not normalized.
+     */
+    isDirectoryIgnored(directoryPath: string): boolean;
+    #private;
+}
+export namespace ConfigArraySymbol {
+    let isNormalized: symbol;
+    let configCache: symbol;
+    let schema: symbol;
+    let finalizeConfig: symbol;
+    let preprocessConfig: symbol;
+}
+import type * as $eslintobjectschema from "@eslint/object-schema";
+import type * as $typests from "./types.ts";
+import minimatch from 'minimatch';
+import { ObjectSchema } from '@eslint/object-schema';

node_modules/@eslint/config-array/dist/esm/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Types for the config-array package.
+ * @author Nicholas C. Zakas
+ */
+export interface ConfigObject {
+    /**
+     * The base path for files and ignores.
+     */
+    basePath?: string;
+    /**
+     * The files to include.
+     */
+    files?: string[];
+    /**
+     * The files to exclude.
+     */
+    ignores?: string[];
+    /**
+     * The name of the config object.
+     */
+    name?: string;
+    [key: string]: unknown;
+}

node_modules/@eslint/config-array/dist/esm/types.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Types for the config-array package.
+ * @author Nicholas C. Zakas
+ */
+
+export interface ConfigObject {
+	/**
+	 * The base path for files and ignores.
+	 */
+	basePath?: string;
+
+	/**
+	 * The files to include.
+	 */
+	files?: string[];
+
+	/**
+	 * The files to exclude.
+	 */
+	ignores?: string[];
+
+	/**
+	 * The name of the config object.
+	 */
+	name?: string;
+
+	// may also have any number of other properties
+	[key: string]: unknown;
+}

node_modules/@eslint/config-array/node_modules/brace-expansion/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@eslint/config-array/node_modules/brace-expansion/README.md

@@ -0,0 +1,129 @@
+# brace-expansion
+
+[Brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html), 
+as known from sh/bash, in JavaScript.
+
+[![build status](https://secure.travis-ci.org/juliangruber/brace-expansion.svg)](http://travis-ci.org/juliangruber/brace-expansion)
+[![downloads](https://img.shields.io/npm/dm/brace-expansion.svg)](https://www.npmjs.org/package/brace-expansion)
+[![Greenkeeper badge](https://badges.greenkeeper.io/juliangruber/brace-expansion.svg)](https://greenkeeper.io/)
+
+[![testling badge](https://ci.testling.com/juliangruber/brace-expansion.png)](https://ci.testling.com/juliangruber/brace-expansion)
+
+## Example
+
+```js
+var expand = require('brace-expansion');
+
+expand('file-{a,b,c}.jpg')
+// => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg']
+
+expand('-v{,,}')
+// => ['-v', '-v', '-v']
+
+expand('file{0..2}.jpg')
+// => ['file0.jpg', 'file1.jpg', 'file2.jpg']
+
+expand('file-{a..c}.jpg')
+// => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg']
+
+expand('file{2..0}.jpg')
+// => ['file2.jpg', 'file1.jpg', 'file0.jpg']
+
+expand('file{0..4..2}.jpg')
+// => ['file0.jpg', 'file2.jpg', 'file4.jpg']
+
+expand('file-{a..e..2}.jpg')
+// => ['file-a.jpg', 'file-c.jpg', 'file-e.jpg']
+
+expand('file{00..10..5}.jpg')
+// => ['file00.jpg', 'file05.jpg', 'file10.jpg']
+
+expand('{{A..C},{a..c}}')
+// => ['A', 'B', 'C', 'a', 'b', 'c']
+
+expand('ppp{,config,oe{,conf}}')
+// => ['ppp', 'pppconfig', 'pppoe', 'pppoeconf']
+```
+
+## API
+
+```js
+var expand = require('brace-expansion');
+```
+
+### var expanded = expand(str)
+
+Return an array of all possible and valid expansions of `str`. If none are
+found, `[str]` is returned.
+
+Valid expansions are:
+
+```js
+/^(.*,)+(.+)?$/
+// {a,b,...}
+```
+
+A comma separated list of options, like `{a,b}` or `{a,{b,c}}` or `{,a,}`.
+
+```js
+/^-?\d+\.\.-?\d+(\.\.-?\d+)?$/
+// {x..y[..incr]}
+```
+
+A numeric sequence from `x` to `y` inclusive, with optional increment.
+If `x` or `y` start with a leading `0`, all the numbers will be padded
+to have equal length. Negative numbers and backwards iteration work too.
+
+```js
+/^-?\d+\.\.-?\d+(\.\.-?\d+)?$/
+// {x..y[..incr]}
+```
+
+An alphabetic sequence from `x` to `y` inclusive, with optional increment.
+`x` and `y` must be exactly one character, and if given, `incr` must be a
+number.
+
+For compatibility reasons, the string `${` is not eligible for brace expansion.
+
+## Installation
+
+With [npm](https://npmjs.org) do:
+
+```bash
+npm install brace-expansion
+```
+
+## Contributors
+
+- [Julian Gruber](https://github.com/juliangruber)
+- [Isaac Z. Schlueter](https://github.com/isaacs)
+
+## Sponsors
+
+This module is proudly supported by my [Sponsors](https://github.com/juliangruber/sponsors)!
+
+Do you want to support modules like this to improve their quality, stability and weigh in on new features? Then please consider donating to my [Patreon](https://www.patreon.com/juliangruber). Not sure how much of my modules you're using? Try [feross/thanks](https://github.com/feross/thanks)!
+
+## License
+
+(MIT)
+
+Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@eslint/config-array/node_modules/brace-expansion/index.js

@@ -0,0 +1,201 @@
+var concatMap = require('concat-map');
+var balanced = require('balanced-match');
+
+module.exports = expandTop;
+
+var escSlash = '\0SLASH'+Math.random()+'\0';
+var escOpen = '\0OPEN'+Math.random()+'\0';
+var escClose = '\0CLOSE'+Math.random()+'\0';
+var escComma = '\0COMMA'+Math.random()+'\0';
+var escPeriod = '\0PERIOD'+Math.random()+'\0';
+
+function numeric(str) {
+  return parseInt(str, 10) == str
+    ? parseInt(str, 10)
+    : str.charCodeAt(0);
+}
+
+function escapeBraces(str) {
+  return str.split('\\\\').join(escSlash)
+            .split('\\{').join(escOpen)
+            .split('\\}').join(escClose)
+            .split('\\,').join(escComma)
+            .split('\\.').join(escPeriod);
+}
+
+function unescapeBraces(str) {
+  return str.split(escSlash).join('\\')
+            .split(escOpen).join('{')
+            .split(escClose).join('}')
+            .split(escComma).join(',')
+            .split(escPeriod).join('.');
+}
+
+
+// Basically just str.split(","), but handling cases
+// where we have nested braced sections, which should be
+// treated as individual members, like {a,{b,c},d}
+function parseCommaParts(str) {
+  if (!str)
+    return [''];
+
+  var parts = [];
+  var m = balanced('{', '}', str);
+
+  if (!m)
+    return str.split(',');
+
+  var pre = m.pre;
+  var body = m.body;
+  var post = m.post;
+  var p = pre.split(',');
+
+  p[p.length-1] += '{' + body + '}';
+  var postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length-1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+
+  parts.push.apply(parts, p);
+
+  return parts;
+}
+
+function expandTop(str) {
+  if (!str)
+    return [];
+
+  // I don't know why Bash 4.3 does this, but it does.
+  // Anything starting with {} will have the first two bytes preserved
+  // but *only* at the top level, so {},a}b will not expand to anything,
+  // but a{},b}c will be expanded to [a}c,abc].
+  // One could argue that this is a bug in Bash, but since the goal of
+  // this module is to match Bash's rules, we escape a leading {}
+  if (str.substr(0, 2) === '{}') {
+    str = '\\{\\}' + str.substr(2);
+  }
+
+  return expand(escapeBraces(str), true).map(unescapeBraces);
+}
+
+function identity(e) {
+  return e;
+}
+
+function embrace(str) {
+  return '{' + str + '}';
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+
+function expand(str, isTop) {
+  var expansions = [];
+
+  var m = balanced('{', '}', str);
+  if (!m || /\$$/.test(m.pre)) return [str];
+
+  var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+  var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+  var isSequence = isNumericSequence || isAlphaSequence;
+  var isOptions = m.body.indexOf(',') >= 0;
+  if (!isSequence && !isOptions) {
+    // {a},b}
+    if (m.post.match(/,(?!,).*\}/)) {
+      str = m.pre + '{' + m.body + escClose + m.post;
+      return expand(str);
+    }
+    return [str];
+  }
+
+  var n;
+  if (isSequence) {
+    n = m.body.split(/\.\./);
+  } else {
+    n = parseCommaParts(m.body);
+    if (n.length === 1) {
+      // x{{a,b}}y ==> x{a}y x{b}y
+      n = expand(n[0], false).map(embrace);
+      if (n.length === 1) {
+        var post = m.post.length
+          ? expand(m.post, false)
+          : [''];
+        return post.map(function(p) {
+          return m.pre + n[0] + p;
+        });
+      }
+    }
+  }
+
+  // at this point, n is the parts, and we know it's not a comma set
+  // with a single entry.
+
+  // no need to expand pre, since it is guaranteed to be free of brace-sets
+  var pre = m.pre;
+  var post = m.post.length
+    ? expand(m.post, false)
+    : [''];
+
+  var N;
+
+  if (isSequence) {
+    var x = numeric(n[0]);
+    var y = numeric(n[1]);
+    var width = Math.max(n[0].length, n[1].length)
+    var incr = n.length == 3
+      ? Math.abs(numeric(n[2]))
+      : 1;
+    var test = lte;
+    var reverse = y < x;
+    if (reverse) {
+      incr *= -1;
+      test = gte;
+    }
+    var pad = n.some(isPadded);
+
+    N = [];
+
+    for (var i = x; test(i, y); i += incr) {
+      var c;
+      if (isAlphaSequence) {
+        c = String.fromCharCode(i);
+        if (c === '\\')
+          c = '';
+      } else {
+        c = String(i);
+        if (pad) {
+          var need = width - c.length;
+          if (need > 0) {
+            var z = new Array(need + 1).join('0');
+            if (i < 0)
+              c = '-' + z + c.slice(1);
+            else
+              c = z + c;
+          }
+        }
+      }
+      N.push(c);
+    }
+  } else {
+    N = concatMap(n, function(el) { return expand(el, false) });
+  }
+
+  for (var j = 0; j < N.length; j++) {
+    for (var k = 0; k < post.length; k++) {
+      var expansion = pre + N[j] + post[k];
+      if (!isTop || isSequence || expansion)
+        expansions.push(expansion);
+    }
+  }
+
+  return expansions;
+}
+

node_modules/@eslint/config-array/node_modules/brace-expansion/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "brace-expansion",
+  "description": "Brace expansion as known from sh/bash",
+  "version": "1.1.12",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/juliangruber/brace-expansion.git"
+  },
+  "homepage": "https://github.com/juliangruber/brace-expansion",
+  "main": "index.js",
+  "scripts": {
+    "test": "tape test/*.js",
+    "gentest": "bash test/generate.sh",
+    "bench": "matcha test/perf/bench.js"
+  },
+  "dependencies": {
+    "balanced-match": "^1.0.0",
+    "concat-map": "0.0.1"
+  },
+  "devDependencies": {
+    "matcha": "^0.7.0",
+    "tape": "^4.6.0"
+  },
+  "keywords": [],
+  "author": {
+    "name": "Julian Gruber",
+    "email": "mail@juliangruber.com",
+    "url": "http://juliangruber.com"
+  },
+  "license": "MIT",
+  "testling": {
+    "files": "test/*.js",
+    "browsers": [
+      "ie/8..latest",
+      "firefox/20..latest",
+      "firefox/nightly",
+      "chrome/25..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  },
+  "publishConfig": {
+    "tag": "1.x"
+  }
+}

node_modules/@eslint/config-array/node_modules/minimatch/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

node_modules/@eslint/config-array/node_modules/minimatch/README.md

@@ -0,0 +1,230 @@
+# minimatch
+
+A minimal matching utility.
+
+[![Build Status](https://travis-ci.org/isaacs/minimatch.svg?branch=master)](http://travis-ci.org/isaacs/minimatch)
+
+
+This is the matching library used internally by npm.
+
+It works by converting glob expressions into JavaScript `RegExp`
+objects.
+
+## Usage
+
+```javascript
+var minimatch = require("minimatch")
+
+minimatch("bar.foo", "*.foo") // true!
+minimatch("bar.foo", "*.bar") // false!
+minimatch("bar.foo", "*.+(bar|foo)", { debug: true }) // true, and noisy!
+```
+
+## Features
+
+Supports these glob features:
+
+* Brace Expansion
+* Extended glob matching
+* "Globstar" `**` matching
+
+See:
+
+* `man sh`
+* `man bash`
+* `man 3 fnmatch`
+* `man 5 gitignore`
+
+## Minimatch Class
+
+Create a minimatch object by instantiating the `minimatch.Minimatch` class.
+
+```javascript
+var Minimatch = require("minimatch").Minimatch
+var mm = new Minimatch(pattern, options)
+```
+
+### Properties
+
+* `pattern` The original pattern the minimatch object represents.
+* `options` The options supplied to the constructor.
+* `set` A 2-dimensional array of regexp or string expressions.
+  Each row in the
+  array corresponds to a brace-expanded pattern.  Each item in the row
+  corresponds to a single path-part.  For example, the pattern
+  `{a,b/c}/d` would expand to a set of patterns like:
+
+        [ [ a, d ]
+        , [ b, c, d ] ]
+
+    If a portion of the pattern doesn't have any "magic" in it
+    (that is, it's something like `"foo"` rather than `fo*o?`), then it
+    will be left as a string rather than converted to a regular
+    expression.
+
+* `regexp` Created by the `makeRe` method.  A single regular expression
+  expressing the entire pattern.  This is useful in cases where you wish
+  to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
+* `negate` True if the pattern is negated.
+* `comment` True if the pattern is a comment.
+* `empty` True if the pattern is `""`.
+
+### Methods
+
+* `makeRe` Generate the `regexp` member if necessary, and return it.
+  Will return `false` if the pattern is invalid.
+* `match(fname)` Return true if the filename matches the pattern, or
+  false otherwise.
+* `matchOne(fileArray, patternArray, partial)` Take a `/`-split
+  filename, and match it against a single row in the `regExpSet`.  This
+  method is mainly for internal use, but is exposed so that it can be
+  used by a glob-walker that needs to avoid excessive filesystem calls.
+
+All other methods are internal, and will be called as necessary.
+
+### minimatch(path, pattern, options)
+
+Main export.  Tests a path against the pattern using the options.
+
+```javascript
+var isJS = minimatch(file, "*.js", { matchBase: true })
+```
+
+### minimatch.filter(pattern, options)
+
+Returns a function that tests its
+supplied argument, suitable for use with `Array.filter`.  Example:
+
+```javascript
+var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}))
+```
+
+### minimatch.match(list, pattern, options)
+
+Match against the list of
+files, in the style of fnmatch or glob.  If nothing is matched, and
+options.nonull is set, then return a list containing the pattern itself.
+
+```javascript
+var javascripts = minimatch.match(fileList, "*.js", {matchBase: true}))
+```
+
+### minimatch.makeRe(pattern, options)
+
+Make a regular expression object from the pattern.
+
+## Options
+
+All options are `false` by default.
+
+### debug
+
+Dump a ton of stuff to stderr.
+
+### nobrace
+
+Do not expand `{a,b}` and `{1..3}` brace sets.
+
+### noglobstar
+
+Disable `**` matching against multiple folder names.
+
+### dot
+
+Allow patterns to match filenames starting with a period, even if
+the pattern does not explicitly have a period in that spot.
+
+Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot`
+is set.
+
+### noext
+
+Disable "extglob" style patterns like `+(a|b)`.
+
+### nocase
+
+Perform a case-insensitive match.
+
+### nonull
+
+When a match is not found by `minimatch.match`, return a list containing
+the pattern itself if this option is set.  When not set, an empty list
+is returned if there are no matches.
+
+### matchBase
+
+If set, then patterns without slashes will be matched
+against the basename of the path if it contains slashes.  For example,
+`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
+
+### nocomment
+
+Suppress the behavior of treating `#` at the start of a pattern as a
+comment.
+
+### nonegate
+
+Suppress the behavior of treating a leading `!` character as negation.
+
+### flipNegate
+
+Returns from negate expressions the same as if they were not negated.
+(Ie, true on a hit, false on a miss.)
+
+### partial
+
+Compare a partial path to a pattern.  As long as the parts of the path that
+are present are not contradicted by the pattern, it will be treated as a
+match.  This is useful in applications where you're walking through a
+folder structure, and don't yet have the full path, but want to ensure that
+you do not walk down paths that can never be a match.
+
+For example,
+
+```js
+minimatch('/a/b', '/a/*/c/d', { partial: true })  // true, might be /a/b/c/d
+minimatch('/a/b', '/**/d', { partial: true })     // true, might be /a/b/.../d
+minimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a
+```
+
+### allowWindowsEscape
+
+Windows path separator `\` is by default converted to `/`, which
+prohibits the usage of `\` as a escape character. This flag skips that
+behavior and allows using the escape character.
+
+## Comparisons to other fnmatch/glob implementations
+
+While strict compliance with the existing standards is a worthwhile
+goal, some discrepancies exist between minimatch and other
+implementations, and are intentional.
+
+If the pattern starts with a `!` character, then it is negated.  Set the
+`nonegate` flag to suppress this behavior, and treat leading `!`
+characters normally.  This is perhaps relevant if you wish to start the
+pattern with a negative extglob pattern like `!(a|B)`.  Multiple `!`
+characters at the start of a pattern will negate the pattern multiple
+times.
+
+If a pattern starts with `#`, then it is treated as a comment, and
+will not match anything.  Use `\#` to match a literal `#` at the
+start of a line, or set the `nocomment` flag to suppress this behavior.
+
+The double-star character `**` is supported by default, unless the
+`noglobstar` flag is set.  This is supported in the manner of bsdglob
+and bash 4.1, where `**` only has special significance if it is the only
+thing in a path part.  That is, `a/**/b` will match `a/x/y/b`, but
+`a/**b` will not.
+
+If an escaped pattern has no matches, and the `nonull` flag is set,
+then minimatch.match returns the pattern as-provided, rather than
+interpreting the character escapes.  For example,
+`minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than
+`"*a?"`.  This is akin to setting the `nullglob` option in bash, except
+that it does not resolve escaped pattern characters.
+
+If brace expansion is not disabled, then it is performed before any
+other interpretation of the glob pattern.  Thus, a pattern like
+`+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded
+**first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are
+checked for validity.  Since those two are valid, matching proceeds.

node_modules/@eslint/config-array/node_modules/minimatch/minimatch.js

@@ -0,0 +1,947 @@
+module.exports = minimatch
+minimatch.Minimatch = Minimatch
+
+var path = (function () { try { return require('path') } catch (e) {}}()) || {
+  sep: '/'
+}
+minimatch.sep = path.sep
+
+var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
+var expand = require('brace-expansion')
+
+var plTypes = {
+  '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
+  '?': { open: '(?:', close: ')?' },
+  '+': { open: '(?:', close: ')+' },
+  '*': { open: '(?:', close: ')*' },
+  '@': { open: '(?:', close: ')' }
+}
+
+// any single thing other than /
+// don't need to escape / when using new RegExp()
+var qmark = '[^/]'
+
+// * => any number of characters
+var star = qmark + '*?'
+
+// ** when dots are allowed.  Anything goes, except .. and .
+// not (^ or / followed by one or two dots followed by $ or /),
+// followed by anything, any number of times.
+var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'
+
+// not a ^ or / followed by a dot,
+// followed by anything, any number of times.
+var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'
+
+// characters that need to be escaped in RegExp.
+var reSpecials = charSet('().*{}+?[]^$\\!')
+
+// "abc" -> { a:true, b:true, c:true }
+function charSet (s) {
+  return s.split('').reduce(function (set, c) {
+    set[c] = true
+    return set
+  }, {})
+}
+
+// normalizes slashes.
+var slashSplit = /\/+/
+
+minimatch.filter = filter
+function filter (pattern, options) {
+  options = options || {}
+  return function (p, i, list) {
+    return minimatch(p, pattern, options)
+  }
+}
+
+function ext (a, b) {
+  b = b || {}
+  var t = {}
+  Object.keys(a).forEach(function (k) {
+    t[k] = a[k]
+  })
+  Object.keys(b).forEach(function (k) {
+    t[k] = b[k]
+  })
+  return t
+}
+
+minimatch.defaults = function (def) {
+  if (!def || typeof def !== 'object' || !Object.keys(def).length) {
+    return minimatch
+  }
+
+  var orig = minimatch
+
+  var m = function minimatch (p, pattern, options) {
+    return orig(p, pattern, ext(def, options))
+  }
+
+  m.Minimatch = function Minimatch (pattern, options) {
+    return new orig.Minimatch(pattern, ext(def, options))
+  }
+  m.Minimatch.defaults = function defaults (options) {
+    return orig.defaults(ext(def, options)).Minimatch
+  }
+
+  m.filter = function filter (pattern, options) {
+    return orig.filter(pattern, ext(def, options))
+  }
+
+  m.defaults = function defaults (options) {
+    return orig.defaults(ext(def, options))
+  }
+
+  m.makeRe = function makeRe (pattern, options) {
+    return orig.makeRe(pattern, ext(def, options))
+  }
+
+  m.braceExpand = function braceExpand (pattern, options) {
+    return orig.braceExpand(pattern, ext(def, options))
+  }
+
+  m.match = function (list, pattern, options) {
+    return orig.match(list, pattern, ext(def, options))
+  }
+
+  return m
+}
+
+Minimatch.defaults = function (def) {
+  return minimatch.defaults(def).Minimatch
+}
+
+function minimatch (p, pattern, options) {
+  assertValidPattern(pattern)
+
+  if (!options) options = {}
+
+  // shortcut: comments match nothing.
+  if (!options.nocomment && pattern.charAt(0) === '#') {
+    return false
+  }
+
+  return new Minimatch(pattern, options).match(p)
+}
+
+function Minimatch (pattern, options) {
+  if (!(this instanceof Minimatch)) {
+    return new Minimatch(pattern, options)
+  }
+
+  assertValidPattern(pattern)
+
+  if (!options) options = {}
+
+  pattern = pattern.trim()
+
+  // windows support: need to use /, not \
+  if (!options.allowWindowsEscape && path.sep !== '/') {
+    pattern = pattern.split(path.sep).join('/')
+  }
+
+  this.options = options
+  this.set = []
+  this.pattern = pattern
+  this.regexp = null
+  this.negate = false
+  this.comment = false
+  this.empty = false
+  this.partial = !!options.partial
+
+  // make the set of regexps etc.
+  this.make()
+}
+
+Minimatch.prototype.debug = function () {}
+
+Minimatch.prototype.make = make
+function make () {
+  var pattern = this.pattern
+  var options = this.options
+
+  // empty patterns and comments match nothing.
+  if (!options.nocomment && pattern.charAt(0) === '#') {
+    this.comment = true
+    return
+  }
+  if (!pattern) {
+    this.empty = true
+    return
+  }
+
+  // step 1: figure out negation, etc.
+  this.parseNegate()
+
+  // step 2: expand braces
+  var set = this.globSet = this.braceExpand()
+
+  if (options.debug) this.debug = function debug() { console.error.apply(console, arguments) }
+
+  this.debug(this.pattern, set)
+
+  // step 3: now we have a set, so turn each one into a series of path-portion
+  // matching patterns.
+  // These will be regexps, except in the case of "**", which is
+  // set to the GLOBSTAR object for globstar behavior,
+  // and will not contain any / characters
+  set = this.globParts = set.map(function (s) {
+    return s.split(slashSplit)
+  })
+
+  this.debug(this.pattern, set)
+
+  // glob --> regexps
+  set = set.map(function (s, si, set) {
+    return s.map(this.parse, this)
+  }, this)
+
+  this.debug(this.pattern, set)
+
+  // filter out everything that didn't compile properly.
+  set = set.filter(function (s) {
+    return s.indexOf(false) === -1
+  })
+
+  this.debug(this.pattern, set)
+
+  this.set = set
+}
+
+Minimatch.prototype.parseNegate = parseNegate
+function parseNegate () {
+  var pattern = this.pattern
+  var negate = false
+  var options = this.options
+  var negateOffset = 0
+
+  if (options.nonegate) return
+
+  for (var i = 0, l = pattern.length
+    ; i < l && pattern.charAt(i) === '!'
+    ; i++) {
+    negate = !negate
+    negateOffset++
+  }
+
+  if (negateOffset) this.pattern = pattern.substr(negateOffset)
+  this.negate = negate
+}
+
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+minimatch.braceExpand = function (pattern, options) {
+  return braceExpand(pattern, options)
+}
+
+Minimatch.prototype.braceExpand = braceExpand
+
+function braceExpand (pattern, options) {
+  if (!options) {
+    if (this instanceof Minimatch) {
+      options = this.options
+    } else {
+      options = {}
+    }
+  }
+
+  pattern = typeof pattern === 'undefined'
+    ? this.pattern : pattern
+
+  assertValidPattern(pattern)
+
+  // Thanks to Yeting Li <https://github.com/yetingli> for
+  // improving this regexp to avoid a ReDOS vulnerability.
+  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+    // shortcut. no need to expand.
+    return [pattern]
+  }
+
+  return expand(pattern)
+}
+
+var MAX_PATTERN_LENGTH = 1024 * 64
+var assertValidPattern = function (pattern) {
+  if (typeof pattern !== 'string') {
+    throw new TypeError('invalid pattern')
+  }
+
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    throw new TypeError('pattern is too long')
+  }
+}
+
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion.  Otherwise, any series
+// of * is equivalent to a single *.  Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+Minimatch.prototype.parse = parse
+var SUBPARSE = {}
+function parse (pattern, isSub) {
+  assertValidPattern(pattern)
+
+  var options = this.options
+
+  // shortcuts
+  if (pattern === '**') {
+    if (!options.noglobstar)
+      return GLOBSTAR
+    else
+      pattern = '*'
+  }
+  if (pattern === '') return ''
+
+  var re = ''
+  var hasMagic = !!options.nocase
+  var escaping = false
+  // ? => one single character
+  var patternListStack = []
+  var negativeLists = []
+  var stateChar
+  var inClass = false
+  var reClassStart = -1
+  var classStart = -1
+  // . and .. never match anything that doesn't start with .,
+  // even when options.dot is set.
+  var patternStart = pattern.charAt(0) === '.' ? '' // anything
+  // not (start or / followed by . or .. followed by / or end)
+  : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
+  : '(?!\\.)'
+  var self = this
+
+  function clearStateChar () {
+    if (stateChar) {
+      // we had some state-tracking character
+      // that wasn't consumed by this pass.
+      switch (stateChar) {
+        case '*':
+          re += star
+          hasMagic = true
+        break
+        case '?':
+          re += qmark
+          hasMagic = true
+        break
+        default:
+          re += '\\' + stateChar
+        break
+      }
+      self.debug('clearStateChar %j %j', stateChar, re)
+      stateChar = false
+    }
+  }
+
+  for (var i = 0, len = pattern.length, c
+    ; (i < len) && (c = pattern.charAt(i))
+    ; i++) {
+    this.debug('%s\t%s %s %j', pattern, i, re, c)
+
+    // skip over any that are escaped.
+    if (escaping && reSpecials[c]) {
+      re += '\\' + c
+      escaping = false
+      continue
+    }
+
+    switch (c) {
+      /* istanbul ignore next */
+      case '/': {
+        // completely not allowed, even escaped.
+        // Should already be path-split by now.
+        return false
+      }
+
+      case '\\':
+        clearStateChar()
+        escaping = true
+      continue
+
+      // the various stateChar values
+      // for the "extglob" stuff.
+      case '?':
+      case '*':
+      case '+':
+      case '@':
+      case '!':
+        this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c)
+
+        // all of those are literals inside a class, except that
+        // the glob [!a] means [^a] in regexp
+        if (inClass) {
+          this.debug('  in class')
+          if (c === '!' && i === classStart + 1) c = '^'
+          re += c
+          continue
+        }
+
+        // if we already have a stateChar, then it means
+        // that there was something like ** or +? in there.
+        // Handle the stateChar, then proceed with this one.
+        self.debug('call clearStateChar %j', stateChar)
+        clearStateChar()
+        stateChar = c
+        // if extglob is disabled, then +(asdf|foo) isn't a thing.
+        // just clear the statechar *now*, rather than even diving into
+        // the patternList stuff.
+        if (options.noext) clearStateChar()
+      continue
+
+      case '(':
+        if (inClass) {
+          re += '('
+          continue
+        }
+
+        if (!stateChar) {
+          re += '\\('
+          continue
+        }
+
+        patternListStack.push({
+          type: stateChar,
+          start: i - 1,
+          reStart: re.length,
+          open: plTypes[stateChar].open,
+          close: plTypes[stateChar].close
+        })
+        // negation is (?:(?!js)[^/]*)
+        re += stateChar === '!' ? '(?:(?!(?:' : '(?:'
+        this.debug('plType %j %j', stateChar, re)
+        stateChar = false
+      continue
+
+      case ')':
+        if (inClass || !patternListStack.length) {
+          re += '\\)'
+          continue
+        }
+
+        clearStateChar()
+        hasMagic = true
+        var pl = patternListStack.pop()
+        // negation is (?:(?!js)[^/]*)
+        // The others are (?:<pattern>)<type>
+        re += pl.close
+        if (pl.type === '!') {
+          negativeLists.push(pl)
+        }
+        pl.reEnd = re.length
+      continue
+
+      case '|':
+        if (inClass || !patternListStack.length || escaping) {
+          re += '\\|'
+          escaping = false
+          continue
+        }
+
+        clearStateChar()
+        re += '|'
+      continue
+
+      // these are mostly the same in regexp and glob
+      case '[':
+        // swallow any state-tracking char before the [
+        clearStateChar()
+
+        if (inClass) {
+          re += '\\' + c
+          continue
+        }
+
+        inClass = true
+        classStart = i
+        reClassStart = re.length
+        re += c
+      continue
+
+      case ']':
+        //  a right bracket shall lose its special
+        //  meaning and represent itself in
+        //  a bracket expression if it occurs
+        //  first in the list.  -- POSIX.2 2.8.3.2
+        if (i === classStart + 1 || !inClass) {
+          re += '\\' + c
+          escaping = false
+          continue
+        }
+
+        // handle the case where we left a class open.
+        // "[z-a]" is valid, equivalent to "\[z-a\]"
+        // split where the last [ was, make sure we don't have
+        // an invalid re. if so, re-walk the contents of the
+        // would-be class to re-translate any characters that
+        // were passed through as-is
+        // TODO: It would probably be faster to determine this
+        // without a try/catch and a new RegExp, but it's tricky
+        // to do safely.  For now, this is safe and works.
+        var cs = pattern.substring(classStart + 1, i)
+        try {
+          RegExp('[' + cs + ']')
+        } catch (er) {
+          // not a valid class!
+          var sp = this.parse(cs, SUBPARSE)
+          re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
+          hasMagic = hasMagic || sp[1]
+          inClass = false
+          continue
+        }
+
+        // finish up the class.
+        hasMagic = true
+        inClass = false
+        re += c
+      continue
+
+      default:
+        // swallow any state char that wasn't consumed
+        clearStateChar()
+
+        if (escaping) {
+          // no need
+          escaping = false
+        } else if (reSpecials[c]
+          && !(c === '^' && inClass)) {
+          re += '\\'
+        }
+
+        re += c
+
+    } // switch
+  } // for
+
+  // handle the case where we left a class open.
+  // "[abc" is valid, equivalent to "\[abc"
+  if (inClass) {
+    // split where the last [ was, and escape it
+    // this is a huge pita.  We now have to re-walk
+    // the contents of the would-be class to re-translate
+    // any characters that were passed through as-is
+    cs = pattern.substr(classStart + 1)
+    sp = this.parse(cs, SUBPARSE)
+    re = re.substr(0, reClassStart) + '\\[' + sp[0]
+    hasMagic = hasMagic || sp[1]
+  }
+
+  // handle the case where we had a +( thing at the *end*
+  // of the pattern.
+  // each pattern list stack adds 3 chars, and we need to go through
+  // and escape any | chars that were passed through as-is for the regexp.
+  // Go through and escape them, taking care not to double-escape any
+  // | chars that were already escaped.
+  for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+    var tail = re.slice(pl.reStart + pl.open.length)
+    this.debug('setting tail', re, pl)
+    // maybe some even number of \, then maybe 1 \, followed by a |
+    tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
+      if (!$2) {
+        // the | isn't already escaped, so escape it.
+        $2 = '\\'
+      }
+
+      // need to escape all those slashes *again*, without escaping the
+      // one that we need for escaping the | character.  As it works out,
+      // escaping an even number of slashes can be done by simply repeating
+      // it exactly after itself.  That's why this trick works.
+      //
+      // I am sorry that you have to see this.
+      return $1 + $1 + $2 + '|'
+    })
+
+    this.debug('tail=%j\n   %s', tail, tail, pl, re)
+    var t = pl.type === '*' ? star
+      : pl.type === '?' ? qmark
+      : '\\' + pl.type
+
+    hasMagic = true
+    re = re.slice(0, pl.reStart) + t + '\\(' + tail
+  }
+
+  // handle trailing things that only matter at the very end.
+  clearStateChar()
+  if (escaping) {
+    // trailing \\
+    re += '\\\\'
+  }
+
+  // only need to apply the nodot start if the re starts with
+  // something that could conceivably capture a dot
+  var addPatternStart = false
+  switch (re.charAt(0)) {
+    case '[': case '.': case '(': addPatternStart = true
+  }
+
+  // Hack to work around lack of negative lookbehind in JS
+  // A pattern like: *.!(x).!(y|z) needs to ensure that a name
+  // like 'a.xyz.yz' doesn't match.  So, the first negative
+  // lookahead, has to look ALL the way ahead, to the end of
+  // the pattern.
+  for (var n = negativeLists.length - 1; n > -1; n--) {
+    var nl = negativeLists[n]
+
+    var nlBefore = re.slice(0, nl.reStart)
+    var nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
+    var nlLast = re.slice(nl.reEnd - 8, nl.reEnd)
+    var nlAfter = re.slice(nl.reEnd)
+
+    nlLast += nlAfter
+
+    // Handle nested stuff like *(*.js|!(*.json)), where open parens
+    // mean that we should *not* include the ) in the bit that is considered
+    // "after" the negated section.
+    var openParensBefore = nlBefore.split('(').length - 1
+    var cleanAfter = nlAfter
+    for (i = 0; i < openParensBefore; i++) {
+      cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
+    }
+    nlAfter = cleanAfter
+
+    var dollar = ''
+    if (nlAfter === '' && isSub !== SUBPARSE) {
+      dollar = '$'
+    }
+    var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast
+    re = newRe
+  }
+
+  // if the re is not "" at this point, then we need to make sure
+  // it doesn't match against an empty path part.
+  // Otherwise a/* will match a/, which it should not.
+  if (re !== '' && hasMagic) {
+    re = '(?=.)' + re
+  }
+
+  if (addPatternStart) {
+    re = patternStart + re
+  }
+
+  // parsing just a piece of a larger pattern.
+  if (isSub === SUBPARSE) {
+    return [re, hasMagic]
+  }
+
+  // skip the regexp for non-magical patterns
+  // unescape anything in it, though, so that it'll be
+  // an exact match against a file etc.
+  if (!hasMagic) {
+    return globUnescape(pattern)
+  }
+
+  var flags = options.nocase ? 'i' : ''
+  try {
+    var regExp = new RegExp('^' + re + '$', flags)
+  } catch (er) /* istanbul ignore next - should be impossible */ {
+    // If it was an invalid regular expression, then it can't match
+    // anything.  This trick looks for a character after the end of
+    // the string, which is of course impossible, except in multi-line
+    // mode, but it's not a /m regex.
+    return new RegExp('$.')
+  }
+
+  regExp._glob = pattern
+  regExp._src = re
+
+  return regExp
+}
+
+minimatch.makeRe = function (pattern, options) {
+  return new Minimatch(pattern, options || {}).makeRe()
+}
+
+Minimatch.prototype.makeRe = makeRe
+function makeRe () {
+  if (this.regexp || this.regexp === false) return this.regexp
+
+  // at this point, this.set is a 2d array of partial
+  // pattern strings, or "**".
+  //
+  // It's better to use .match().  This function shouldn't
+  // be used, really, but it's pretty convenient sometimes,
+  // when you just want to work with a regex.
+  var set = this.set
+
+  if (!set.length) {
+    this.regexp = false
+    return this.regexp
+  }
+  var options = this.options
+
+  var twoStar = options.noglobstar ? star
+    : options.dot ? twoStarDot
+    : twoStarNoDot
+  var flags = options.nocase ? 'i' : ''
+
+  var re = set.map(function (pattern) {
+    return pattern.map(function (p) {
+      return (p === GLOBSTAR) ? twoStar
+      : (typeof p === 'string') ? regExpEscape(p)
+      : p._src
+    }).join('\\\/')
+  }).join('|')
+
+  // must match entire pattern
+  // ending in a * or ** will make it less strict.
+  re = '^(?:' + re + ')$'
+
+  // can match anything, as long as it's not this.
+  if (this.negate) re = '^(?!' + re + ').*$'
+
+  try {
+    this.regexp = new RegExp(re, flags)
+  } catch (ex) /* istanbul ignore next - should be impossible */ {
+    this.regexp = false
+  }
+  return this.regexp
+}
+
+minimatch.match = function (list, pattern, options) {
+  options = options || {}
+  var mm = new Minimatch(pattern, options)
+  list = list.filter(function (f) {
+    return mm.match(f)
+  })
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern)
+  }
+  return list
+}
+
+Minimatch.prototype.match = function match (f, partial) {
+  if (typeof partial === 'undefined') partial = this.partial
+  this.debug('match', f, this.pattern)
+  // short-circuit in the case of busted things.
+  // comments, etc.
+  if (this.comment) return false
+  if (this.empty) return f === ''
+
+  if (f === '/' && partial) return true
+
+  var options = this.options
+
+  // windows: need to use /, not \
+  if (path.sep !== '/') {
+    f = f.split(path.sep).join('/')
+  }
+
+  // treat the test path as a set of pathparts.
+  f = f.split(slashSplit)
+  this.debug(this.pattern, 'split', f)
+
+  // just ONE of the pattern sets in this.set needs to match
+  // in order for it to be valid.  If negating, then just one
+  // match means that we have failed.
+  // Either way, return on the first hit.
+
+  var set = this.set
+  this.debug(this.pattern, 'set', set)
+
+  // Find the basename of the path by looking for the last non-empty segment
+  var filename
+  var i
+  for (i = f.length - 1; i >= 0; i--) {
+    filename = f[i]
+    if (filename) break
+  }
+
+  for (i = 0; i < set.length; i++) {
+    var pattern = set[i]
+    var file = f
+    if (options.matchBase && pattern.length === 1) {
+      file = [filename]
+    }
+    var hit = this.matchOne(file, pattern, partial)
+    if (hit) {
+      if (options.flipNegate) return true
+      return !this.negate
+    }
+  }
+
+  // didn't get any hits.  this is success if it's a negative
+  // pattern, failure otherwise.
+  if (options.flipNegate) return false
+  return this.negate
+}
+
+// set partial to true to test if, for example,
+// "/a/b" matches the start of "/*/b/*/d"
+// Partial means, if you run out of file before you run
+// out of pattern, then that's fine, as long as all
+// the parts match.
+Minimatch.prototype.matchOne = function (file, pattern, partial) {
+  var options = this.options
+
+  this.debug('matchOne',
+    { 'this': this, file: file, pattern: pattern })
+
+  this.debug('matchOne', file.length, pattern.length)
+
+  for (var fi = 0,
+      pi = 0,
+      fl = file.length,
+      pl = pattern.length
+      ; (fi < fl) && (pi < pl)
+      ; fi++, pi++) {
+    this.debug('matchOne loop')
+    var p = pattern[pi]
+    var f = file[fi]
+
+    this.debug(pattern, p, f)
+
+    // should be impossible.
+    // some invalid regexp stuff in the set.
+    /* istanbul ignore if */
+    if (p === false) return false
+
+    if (p === GLOBSTAR) {
+      this.debug('GLOBSTAR', [pattern, p, f])
+
+      // "**"
+      // a/**/b/**/c would match the following:
+      // a/b/x/y/z/c
+      // a/x/y/z/b/c
+      // a/b/x/b/x/c
+      // a/b/c
+      // To do this, take the rest of the pattern after
+      // the **, and see if it would match the file remainder.
+      // If so, return success.
+      // If not, the ** "swallows" a segment, and try again.
+      // This is recursively awful.
+      //
+      // a/**/b/**/c matching a/b/x/y/z/c
+      // - a matches a
+      // - doublestar
+      //   - matchOne(b/x/y/z/c, b/**/c)
+      //     - b matches b
+      //     - doublestar
+      //       - matchOne(x/y/z/c, c) -> no
+      //       - matchOne(y/z/c, c) -> no
+      //       - matchOne(z/c, c) -> no
+      //       - matchOne(c, c) yes, hit
+      var fr = fi
+      var pr = pi + 1
+      if (pr === pl) {
+        this.debug('** at the end')
+        // a ** at the end will just swallow the rest.
+        // We have found a match.
+        // however, it will not swallow /.x, unless
+        // options.dot is set.
+        // . and .. are *never* matched by **, for explosively
+        // exponential reasons.
+        for (; fi < fl; fi++) {
+          if (file[fi] === '.' || file[fi] === '..' ||
+            (!options.dot && file[fi].charAt(0) === '.')) return false
+        }
+        return true
+      }
+
+      // ok, let's see if we can swallow whatever we can.
+      while (fr < fl) {
+        var swallowee = file[fr]
+
+        this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)
+
+        // XXX remove this slice.  Just pass the start index.
+        if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+          this.debug('globstar found match!', fr, fl, swallowee)
+          // found a match.
+          return true
+        } else {
+          // can't swallow "." or ".." ever.
+          // can only swallow ".foo" when explicitly asked.
+          if (swallowee === '.' || swallowee === '..' ||
+            (!options.dot && swallowee.charAt(0) === '.')) {
+            this.debug('dot detected!', file, fr, pattern, pr)
+            break
+          }
+
+          // ** swallows a segment, and continue.
+          this.debug('globstar swallow a segment, and continue')
+          fr++
+        }
+      }
+
+      // no match was found.
+      // However, in partial mode, we can't say this is necessarily over.
+      // If there's more *pattern* left, then
+      /* istanbul ignore if */
+      if (partial) {
+        // ran out of file
+        this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
+        if (fr === fl) return true
+      }
+      return false
+    }
+
+    // something other than **
+    // non-magic patterns just have to match exactly
+    // patterns with magic have been turned into regexps.
+    var hit
+    if (typeof p === 'string') {
+      hit = f === p
+      this.debug('string match', p, f, hit)
+    } else {
+      hit = f.match(p)
+      this.debug('pattern match', p, f, hit)
+    }
+
+    if (!hit) return false
+  }
+
+  // Note: ending in / means that we'll get a final ""
+  // at the end of the pattern.  This can only match a
+  // corresponding "" at the end of the file.
+  // If the file ends in /, then it can only match a
+  // a pattern that ends in /, unless the pattern just
+  // doesn't have any more for it. But, a/b/ should *not*
+  // match "a/b/*", even though "" matches against the
+  // [^/]*? pattern, except in partial mode, where it might
+  // simply not be reached yet.
+  // However, a/b/ should still satisfy a/*
+
+  // now either we fell off the end of the pattern, or we're done.
+  if (fi === fl && pi === pl) {
+    // ran out of pattern and filename at the same time.
+    // an exact hit!
+    return true
+  } else if (fi === fl) {
+    // ran out of file, but still had pattern left.
+    // this is ok if we're doing the match as part of
+    // a glob fs traversal.
+    return partial
+  } else /* istanbul ignore else */ if (pi === pl) {
+    // ran out of pattern, still have file left.
+    // this is only acceptable if we're on the very last
+    // empty segment of a file with a trailing slash.
+    // a/* should match a/b/
+    return (fi === fl - 1) && (file[fi] === '')
+  }
+
+  // should be unreachable.
+  /* istanbul ignore next */
+  throw new Error('wtf?')
+}
+
+// replace stuff like \* with *
+function globUnescape (s) {
+  return s.replace(/\\(.)/g, '$1')
+}
+
+function regExpEscape (s) {
+  return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
+}

node_modules/@eslint/config-array/node_modules/minimatch/package.json

@@ -0,0 +1,33 @@
+{
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)",
+  "name": "minimatch",
+  "description": "a glob matcher in javascript",
+  "version": "3.1.2",
+  "publishConfig": {
+    "tag": "v3-legacy"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/minimatch.git"
+  },
+  "main": "minimatch.js",
+  "scripts": {
+    "test": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "postpublish": "git push origin --all; git push origin --tags"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "dependencies": {
+    "brace-expansion": "^1.1.7"
+  },
+  "devDependencies": {
+    "tap": "^15.1.6"
+  },
+  "license": "ISC",
+  "files": [
+    "minimatch.js"
+  ]
+}

node_modules/@eslint/config-array/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@eslint/config-array",
+  "version": "0.21.1",
+  "description": "General purpose glob-based configuration matching.",
+  "author": "Nicholas C. Zakas",
+  "type": "module",
+  "main": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    "require": {
+      "types": "./dist/cjs/index.d.cts",
+      "default": "./dist/cjs/index.cjs"
+    },
+    "import": {
+      "types": "./dist/esm/index.d.ts",
+      "default": "./dist/esm/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eslint/rewrite.git",
+    "directory": "packages/config-array"
+  },
+  "bugs": {
+    "url": "https://github.com/eslint/rewrite/issues"
+  },
+  "homepage": "https://github.com/eslint/rewrite/tree/main/packages/config-array#readme",
+  "scripts": {
+    "build:dedupe-types": "node ../../tools/dedupe-types.js dist/cjs/index.cjs dist/esm/index.js",
+    "build:cts": "node ../../tools/build-cts.js dist/esm/index.d.ts dist/cjs/index.d.cts",
+    "build:std__path": "rollup -c rollup.std__path-config.js && node fix-std__path-imports",
+    "build": "rollup -c && npm run build:dedupe-types && tsc -p tsconfig.esm.json && npm run build:cts && npm run build:std__path",
+    "pretest": "npm run build",
+    "test": "mocha \"tests/**/*.test.js\"",
+    "test:coverage": "c8 npm test",
+    "test:jsr": "npx jsr@latest publish --dry-run",
+    "test:types": "tsc -p tests/types/tsconfig.json"
+  },
+  "keywords": [
+    "configuration",
+    "configarray",
+    "config file"
+  ],
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@eslint/object-schema": "^2.1.7",
+    "debug": "^4.3.1",
+    "minimatch": "^3.1.2"
+  },
+  "devDependencies": {
+    "@jsr/std__path": "^1.0.4",
+    "@types/minimatch": "^3.0.5",
+    "rollup-plugin-copy": "^3.5.0"
+  },
+  "engines": {
+    "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+  }
+}

node_modules/@eslint/config-helpers/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

node_modules/@eslint/config-helpers/README.md

@@ -0,0 +1,97 @@
+# @eslint/config-helpers
+
+## Description
+
+Helper utilities for creating ESLint configuration.
+
+## Installation
+
+For Node.js and compatible runtimes:
+
+```shell
+npm install @eslint/config-helpers
+# or
+yarn add @eslint/config-helpers
+# or
+pnpm install @eslint/config-helpers
+# or
+bun add @eslint/config-helpers
+```
+
+For Deno:
+
+```shell
+deno add @eslint/config-helpers
+```
+
+## Usage
+
+### `defineConfig()`
+
+The `defineConfig()` function allows you to specify an ESLint configuration with full type checking and additional capabilities, such as `extends`. Here's an example:
+
+```js
+// eslint.config.js
+import { defineConfig } from "@eslint/config-helpers";
+import js from "@eslint/js";
+
+export default defineConfig([
+	{
+		files: ["src/**/*.js"],
+		plugins: { js },
+		extends: ["js/recommended"],
+		rules: {
+			semi: "error",
+			"prefer-const": "error",
+		},
+	},
+	{
+		files: ["test/**/*.js"],
+		rules: {
+			"no-console": "off",
+		},
+	},
+]);
+```
+
+### `globalIgnores()`
+
+The `globalIgnores()` function allows you to specify patterns for files and directories that should be globally ignored by ESLint. This is useful for excluding files that you don't want to lint, such as build directories or third-party libraries. Here's an example:
+
+```js
+// eslint.config.js
+import { defineConfig, globalIgnores } from "@eslint/config-helpers";
+
+export default defineConfig([
+	{
+		files: ["src/**/*.js"],
+		rules: {
+			semi: "error",
+			"prefer-const": "error",
+		},
+	},
+	globalIgnores(["node_modules/", "dist/", "coverage/"]),
+]);
+```
+
+## License
+
+Apache 2.0
+
+<!-- NOTE: This section is autogenerated. Do not manually edit.-->
+<!--sponsorsstart-->
+
+## Sponsors
+
+The following companies, organizations, and individuals support ESLint's ongoing maintenance and development. [Become a Sponsor](https://eslint.org/donate)
+to get your logo on our READMEs and [website](https://eslint.org/sponsors).
+
+<h3>Platinum Sponsors</h3>
+<p><a href="https://automattic.com"><img src="https://images.opencollective.com/automattic/d0ef3e1/logo.png" alt="Automattic" height="128"></a> <a href="https://www.airbnb.com/"><img src="https://images.opencollective.com/airbnb/d327d66/logo.png" alt="Airbnb" height="128"></a></p><h3>Gold Sponsors</h3>
+<p><a href="https://qlty.sh/"><img src="https://images.opencollective.com/qltysh/33d157d/logo.png" alt="Qlty Software" height="96"></a> <a href="https://trunk.io/"><img src="https://images.opencollective.com/trunkio/fb92d60/avatar.png" alt="trunk.io" height="96"></a> <a href="https://shopify.engineering/"><img src="https://avatars.githubusercontent.com/u/8085" alt="Shopify" height="96"></a></p><h3>Silver Sponsors</h3>
+<p><a href="https://vite.dev/"><img src="https://images.opencollective.com/vite/e6d15e1/logo.png" alt="Vite" height="64"></a> <a href="https://liftoff.io/"><img src="https://images.opencollective.com/liftoff/5c4fa84/logo.png" alt="Liftoff" height="64"></a> <a href="https://americanexpress.io"><img src="https://avatars.githubusercontent.com/u/3853301" alt="American Express" height="64"></a> <a href="https://stackblitz.com"><img src="https://avatars.githubusercontent.com/u/28635252" alt="StackBlitz" height="64"></a></p><h3>Bronze Sponsors</h3>
+<p><a href="https://cybozu.co.jp/"><img src="https://images.opencollective.com/cybozu/933e46d/logo.png" alt="Cybozu" height="32"></a> <a href="https://www.crosswordsolver.org/anagram-solver/"><img src="https://images.opencollective.com/anagram-solver/2666271/logo.png" alt="Anagram Solver" height="32"></a> <a href="https://icons8.com/"><img src="https://images.opencollective.com/icons8/7fa1641/logo.png" alt="Icons8" height="32"></a> <a href="https://discord.com"><img src="https://images.opencollective.com/discordapp/f9645d9/logo.png" alt="Discord" height="32"></a> <a href="https://www.gitbook.com"><img src="https://avatars.githubusercontent.com/u/7111340" alt="GitBook" height="32"></a> <a href="https://nx.dev"><img src="https://avatars.githubusercontent.com/u/23692104" alt="Nx" height="32"></a> <a href="https://opensource.mercedes-benz.com/"><img src="https://avatars.githubusercontent.com/u/34240465" alt="Mercedes-Benz Group" height="32"></a> <a href="https://herocoders.com"><img src="https://avatars.githubusercontent.com/u/37549774" alt="HeroCoders" height="32"></a> <a href="https://www.lambdatest.com"><img src="https://avatars.githubusercontent.com/u/171592363" alt="LambdaTest" height="32"></a></p>
+<h3>Technology Sponsors</h3>
+Technology sponsors allow us to use their products and services for free as part of a contribution to the open source ecosystem and our work.
+<p><a href="https://netlify.com"><img src="https://raw.githubusercontent.com/eslint/eslint.org/main/src/assets/images/techsponsors/netlify-icon.svg" alt="Netlify" height="32"></a> <a href="https://algolia.com"><img src="https://raw.githubusercontent.com/eslint/eslint.org/main/src/assets/images/techsponsors/algolia-icon.svg" alt="Algolia" height="32"></a> <a href="https://1password.com"><img src="https://raw.githubusercontent.com/eslint/eslint.org/main/src/assets/images/techsponsors/1password-icon.svg" alt="1Password" height="32"></a></p>
+<!--sponsorsend-->

node_modules/@eslint/config-helpers/dist/cjs/index.cjs

@@ -0,0 +1,581 @@
+'use strict';
+
+/**
+ * @fileoverview defineConfig helper
+ * @author Nicholas C. Zakas
+ */
+
+//-----------------------------------------------------------------------------
+// Type Definitions
+//-----------------------------------------------------------------------------
+
+/** @typedef {import("eslint").Linter.Config} Config */
+/** @typedef {import("eslint").Linter.LegacyConfig} LegacyConfig */
+/** @typedef {import("eslint").ESLint.Plugin} Plugin */
+/** @typedef {import("eslint").Linter.RuleEntry} RuleEntry */
+/** @typedef {import("./types.ts").ExtendsElement} ExtendsElement */
+/** @typedef {import("./types.ts").SimpleExtendsElement} SimpleExtendsElement */
+/** @typedef {import("./types.ts").ConfigWithExtends} ConfigWithExtends */
+/** @typedef {import("./types.ts").InfiniteArray<Config>} InfiniteConfigArray */
+/** @typedef {import("./types.ts").ConfigWithExtendsArray} ConfigWithExtendsArray */
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+const eslintrcKeys = [
+	"env",
+	"extends",
+	"globals",
+	"ignorePatterns",
+	"noInlineConfig",
+	"overrides",
+	"parser",
+	"parserOptions",
+	"reportUnusedDisableDirectives",
+	"root",
+];
+
+const allowedGlobalIgnoreKeys = new Set(["basePath", "ignores", "name"]);
+
+/**
+ * Gets the name of a config object.
+ * @param {Config} config The config object.
+ * @param {string} indexPath The index path of the config object.
+ * @return {string} The name of the config object.
+ */
+function getConfigName(config, indexPath) {
+	if (config.name) {
+		return config.name;
+	}
+
+	return `UserConfig${indexPath}`;
+}
+
+/**
+ * Gets the name of an extension.
+ * @param {SimpleExtendsElement} extension The extension.
+ * @param {string} indexPath The index of the extension.
+ * @return {string} The name of the extension.
+ */
+function getExtensionName(extension, indexPath) {
+	if (typeof extension === "string") {
+		return extension;
+	}
+
+	if (extension.name) {
+		return extension.name;
+	}
+
+	return `ExtendedConfig${indexPath}`;
+}
+
+/**
+ * Determines if a config object is a legacy config.
+ * @param {Config|LegacyConfig} config The config object to check.
+ * @return {config is LegacyConfig} `true` if the config object is a legacy config.
+ */
+function isLegacyConfig(config) {
+	for (const key of eslintrcKeys) {
+		if (key in config) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * Determines if a config object is a global ignores config.
+ * @param {Config} config The config object to check.
+ * @return {boolean} `true` if the config object is a global ignores config.
+ */
+function isGlobalIgnores(config) {
+	return Object.keys(config).every(key => allowedGlobalIgnoreKeys.has(key));
+}
+
+/**
+ * Parses a plugin member ID (rule, processor, etc.) and returns
+ * the namespace and member name.
+ * @param {string} id The ID to parse.
+ * @returns {{namespace:string, name:string}} The namespace and member name.
+ */
+function getPluginMember(id) {
+	const firstSlashIndex = id.indexOf("/");
+
+	if (firstSlashIndex === -1) {
+		return { namespace: "", name: id };
+	}
+
+	let namespace = id.slice(0, firstSlashIndex);
+
+	/*
+	 * Special cases:
+	 * 1. The namespace is `@`, that means it's referring to the
+	 *    core plugin so `@` is the full namespace.
+	 * 2. The namespace starts with `@`, that means it's referring to
+	 *    an npm scoped package. That means the namespace is the scope
+	 *    and the package name (i.e., `@eslint/core`).
+	 */
+	if (namespace[0] === "@" && namespace !== "@") {
+		const secondSlashIndex = id.indexOf("/", firstSlashIndex + 1);
+		if (secondSlashIndex !== -1) {
+			namespace = id.slice(0, secondSlashIndex);
+			return { namespace, name: id.slice(secondSlashIndex + 1) };
+		}
+	}
+
+	const name = id.slice(firstSlashIndex + 1);
+
+	return { namespace, name };
+}
+
+/**
+ * Normalizes the plugin config by replacing the namespace with the plugin namespace.
+ * @param {string} userNamespace The namespace of the plugin.
+ * @param {Plugin} plugin The plugin config object.
+ * @param {Config} config The config object to normalize.
+ * @return {Config} The normalized config object.
+ */
+function normalizePluginConfig(userNamespace, plugin, config) {
+	const pluginNamespace = plugin.meta?.namespace;
+
+	// don't do anything if the plugin doesn't have a namespace or rules
+	if (
+		!pluginNamespace ||
+		pluginNamespace === userNamespace ||
+		(!config.rules && !config.processor && !config.language)
+	) {
+		return config;
+	}
+
+	const result = { ...config };
+
+	// update the rules
+	if (result.rules) {
+		const ruleIds = Object.keys(result.rules);
+
+		/** @type {Record<string,RuleEntry|undefined>} */
+		const newRules = {};
+
+		for (let i = 0; i < ruleIds.length; i++) {
+			const ruleId = ruleIds[i];
+			const { namespace: ruleNamespace, name: ruleName } =
+				getPluginMember(ruleId);
+
+			if (ruleNamespace === pluginNamespace) {
+				newRules[`${userNamespace}/${ruleName}`] = result.rules[ruleId];
+			} else {
+				newRules[ruleId] = result.rules[ruleId];
+			}
+		}
+
+		result.rules = newRules;
+	}
+
+	// update the processor
+
+	if (typeof result.processor === "string") {
+		const { namespace: processorNamespace, name: processorName } =
+			getPluginMember(result.processor);
+
+		if (processorNamespace) {
+			if (processorNamespace === pluginNamespace) {
+				result.processor = `${userNamespace}/${processorName}`;
+			}
+		}
+	}
+
+	// update the language
+	if (typeof result.language === "string") {
+		const { namespace: languageNamespace, name: languageName } =
+			getPluginMember(result.language);
+
+		if (languageNamespace === pluginNamespace) {
+			result.language = `${userNamespace}/${languageName}`;
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Deeply normalizes a plugin config, traversing recursively into an arrays.
+ * @param {string} userPluginNamespace The namespace of the plugin.
+ * @param {Plugin} plugin The plugin object.
+ * @param {Config|LegacyConfig|(Config|LegacyConfig)[]} pluginConfig The plugin config to normalize.
+ * @param {string} pluginConfigName The name of the plugin config.
+ * @return {InfiniteConfigArray} The normalized plugin config.
+ * @throws {TypeError} If the plugin config is a legacy config.
+ */
+function deepNormalizePluginConfig(
+	userPluginNamespace,
+	plugin,
+	pluginConfig,
+	pluginConfigName,
+) {
+	// if it's an array then it's definitely a new config
+	if (Array.isArray(pluginConfig)) {
+		return pluginConfig.map(pluginSubConfig =>
+			deepNormalizePluginConfig(
+				userPluginNamespace,
+				plugin,
+				pluginSubConfig,
+				pluginConfigName,
+			),
+		);
+	}
+
+	// if it's a legacy config, throw an error
+	if (isLegacyConfig(pluginConfig)) {
+		throw new TypeError(
+			`Plugin config "${pluginConfigName}" is an eslintrc config and cannot be used in this context.`,
+		);
+	}
+
+	return normalizePluginConfig(userPluginNamespace, plugin, pluginConfig);
+}
+
+/**
+ * Finds a plugin config by name in the given config.
+ * @param {Config} config The config object.
+ * @param {string} pluginConfigName The name of the plugin config.
+ * @return {InfiniteConfigArray} The plugin config.
+ * @throws {TypeError} If the plugin config is not found or is a legacy config.
+ */
+function findPluginConfig(config, pluginConfigName) {
+	const { namespace: userPluginNamespace, name: configName } =
+		getPluginMember(pluginConfigName);
+	const plugin = config.plugins?.[userPluginNamespace];
+
+	if (!plugin) {
+		throw new TypeError(`Plugin "${userPluginNamespace}" not found.`);
+	}
+
+	const directConfig = plugin.configs?.[configName];
+	if (directConfig) {
+		// Arrays are always flat configs, and non-legacy configs can be used directly
+		if (Array.isArray(directConfig) || !isLegacyConfig(directConfig)) {
+			return deepNormalizePluginConfig(
+				userPluginNamespace,
+				plugin,
+				directConfig,
+				pluginConfigName,
+			);
+		}
+
+		// If it's a legacy config, look for the flat version
+		const flatConfig = plugin.configs?.[`flat/${configName}`];
+
+		if (
+			flatConfig &&
+			(Array.isArray(flatConfig) || !isLegacyConfig(flatConfig))
+		) {
+			return deepNormalizePluginConfig(
+				userPluginNamespace,
+				plugin,
+				flatConfig,
+				pluginConfigName,
+			);
+		}
+
+		throw new TypeError(
+			`Plugin config "${configName}" in plugin "${userPluginNamespace}" is an eslintrc config and cannot be used in this context.`,
+		);
+	}
+
+	throw new TypeError(
+		`Plugin config "${configName}" not found in plugin "${userPluginNamespace}".`,
+	);
+}
+
+/**
+ * Flattens an array while keeping track of the index path.
+ * @param {any[]} configList The array to traverse.
+ * @param {string} indexPath The index path of the value in a multidimensional array.
+ * @return {IterableIterator<{indexPath:string, value:any}>} The flattened list of values.
+ */
+function* flatTraverse(configList, indexPath = "") {
+	for (let i = 0; i < configList.length; i++) {
+		const newIndexPath = indexPath ? `${indexPath}[${i}]` : `[${i}]`;
+
+		// if it's an array then traverse it as well
+		if (Array.isArray(configList[i])) {
+			yield* flatTraverse(configList[i], newIndexPath);
+			continue;
+		}
+
+		yield { indexPath: newIndexPath, value: configList[i] };
+	}
+}
+
+/**
+ * Extends a list of config files by creating every combination of base and extension files.
+ * @param {(string|string[])[]} [baseFiles] The base files.
+ * @param {(string|string[])[]} [extensionFiles] The extension files.
+ * @return {(string|string[])[]} The extended files.
+ */
+function extendConfigFiles(baseFiles = [], extensionFiles = []) {
+	if (!extensionFiles.length) {
+		return baseFiles.concat();
+	}
+
+	if (!baseFiles.length) {
+		return extensionFiles.concat();
+	}
+
+	/** @type {(string|string[])[]} */
+	const result = [];
+
+	for (const baseFile of baseFiles) {
+		for (const extensionFile of extensionFiles) {
+			/*
+			 * Each entry can be a string or array of strings. The end result
+			 * needs to be an array of strings, so we need to be sure to include
+			 * all of the items when there's an array.
+			 */
+
+			const entry = [];
+
+			if (Array.isArray(baseFile)) {
+				entry.push(...baseFile);
+			} else {
+				entry.push(baseFile);
+			}
+
+			if (Array.isArray(extensionFile)) {
+				entry.push(...extensionFile);
+			} else {
+				entry.push(extensionFile);
+			}
+
+			result.push(entry);
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Extends a config object with another config object.
+ * @param {Config} baseConfig The base config object.
+ * @param {string} baseConfigName The name of the base config object.
+ * @param {Config} extension The extension config object.
+ * @param {string} extensionName The index of the extension config object.
+ * @return {Config} The extended config object.
+ */
+function extendConfig(baseConfig, baseConfigName, extension, extensionName) {
+	const result = { ...extension };
+
+	// for global ignores there is no further work to be done, we just keep everything
+	if (!isGlobalIgnores(extension)) {
+		// for files we need to create every combination of base and extension files
+		if (baseConfig.files) {
+			result.files = extendConfigFiles(baseConfig.files, extension.files);
+		}
+
+		// for ignores we just concatenation the extension ignores onto the base ignores
+		if (baseConfig.ignores) {
+			result.ignores = baseConfig.ignores.concat(extension.ignores ?? []);
+		}
+	}
+
+	result.name = `${baseConfigName} > ${extensionName}`;
+
+	// @ts-ignore -- ESLint types aren't updated yet
+	if (baseConfig.basePath) {
+		// @ts-ignore -- ESLint types aren't updated yet
+		result.basePath = baseConfig.basePath;
+	}
+
+	return result;
+}
+
+/**
+ * Processes a list of extends elements.
+ * @param {ConfigWithExtends} config The config object.
+ * @param {WeakMap<Config, string>} configNames The map of config objects to their names.
+ * @return {Config[]} The flattened list of config objects.
+ * @throws {TypeError} If the `extends` property is not an array or if nested `extends` is found.
+ */
+function processExtends(config, configNames) {
+	if (!config.extends) {
+		return [config];
+	}
+
+	if (!Array.isArray(config.extends)) {
+		throw new TypeError("The `extends` property must be an array.");
+	}
+
+	const {
+		/** @type {Config[]} */
+		extends: extendsList,
+
+		/** @type {Config} */
+		...configObject
+	} = config;
+
+	const extensionNames = new WeakMap();
+
+	// replace strings with the actual configs
+	const objectExtends = extendsList.map(extendsElement => {
+		if (typeof extendsElement === "string") {
+			const pluginConfig = findPluginConfig(config, extendsElement);
+
+			// assign names
+			if (Array.isArray(pluginConfig)) {
+				pluginConfig.forEach((pluginConfigElement, index) => {
+					extensionNames.set(
+						pluginConfigElement,
+						`${extendsElement}[${index}]`,
+					);
+				});
+			} else {
+				extensionNames.set(pluginConfig, extendsElement);
+			}
+
+			return pluginConfig;
+		}
+
+		return /** @type {Config} */ (extendsElement);
+	});
+
+	const result = [];
+
+	for (const { indexPath, value: extendsElement } of flatTraverse(
+		objectExtends,
+	)) {
+		const extension = /** @type {Config} */ (extendsElement);
+
+		if ("basePath" in extension) {
+			throw new TypeError("'basePath' in `extends` is not allowed.");
+		}
+
+		if ("extends" in extension) {
+			throw new TypeError("Nested 'extends' is not allowed.");
+		}
+
+		const baseConfigName = /** @type {string} */ (configNames.get(config));
+		const extensionName =
+			extensionNames.get(extendsElement) ??
+			getExtensionName(extendsElement, indexPath);
+
+		result.push(
+			extendConfig(
+				configObject,
+				baseConfigName,
+				extension,
+				extensionName,
+			),
+		);
+	}
+
+	/*
+	 * If the base config object has only `ignores` and `extends`, then
+	 * removing `extends` turns it into a global ignores, which is not what
+	 * we want. So we need to check if the base config object is a global ignores
+	 * and if so, we don't add it to the array.
+	 *
+	 * (The other option would be to add a `files` entry, but that would result
+	 * in a config that didn't actually do anything because there are no
+	 * other keys in the config.)
+	 */
+	if (!isGlobalIgnores(configObject)) {
+		result.push(configObject);
+	}
+
+	return result.flat();
+}
+
+/**
+ * Processes a list of config objects and arrays.
+ * @param {ConfigWithExtends[]} configList The list of config objects and arrays.
+ * @param {WeakMap<Config, string>} configNames The map of config objects to their names.
+ * @return {Config[]} The flattened list of config objects.
+ */
+function processConfigList(configList, configNames) {
+	return configList.flatMap(config => processExtends(config, configNames));
+}
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * Helper function to define a config array.
+ * @param {ConfigWithExtendsArray} args The arguments to the function.
+ * @returns {Config[]} The config array.
+ * @throws {TypeError} If no arguments are provided or if an argument is not an object.
+ */
+function defineConfig(...args) {
+	const configNames = new WeakMap();
+	const configs = [];
+
+	if (args.length === 0) {
+		throw new TypeError("Expected one or more arguments.");
+	}
+
+	// first flatten the list of configs and get the names
+	for (const { indexPath, value } of flatTraverse(args)) {
+		if (typeof value !== "object" || value === null) {
+			throw new TypeError(
+				`Expected an object but received ${String(value)}.`,
+			);
+		}
+
+		const config = /** @type {ConfigWithExtends} */ (value);
+
+		// save config name for easy reference later
+		configNames.set(config, getConfigName(config, indexPath));
+		configs.push(config);
+	}
+
+	return processConfigList(configs, configNames);
+}
+
+/**
+ * @fileoverview Global ignores helper function.
+ * @author Nicholas C. Zakas
+ */
+
+//-----------------------------------------------------------------------------
+// Type Definitions
+//-----------------------------------------------------------------------------
+
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+let globalIgnoreCount = 0;
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * Creates a global ignores config with the given patterns.
+ * @param {string[]} ignorePatterns The ignore patterns.
+ * @param {string} [name] The name of the global ignores config.
+ * @returns {Config} The global ignores config.
+ * @throws {TypeError} If ignorePatterns is not an array or if it is empty.
+ */
+function globalIgnores(ignorePatterns, name) {
+	if (!Array.isArray(ignorePatterns)) {
+		throw new TypeError("ignorePatterns must be an array");
+	}
+
+	if (ignorePatterns.length === 0) {
+		throw new TypeError("ignorePatterns must contain at least one pattern");
+	}
+
+	const id = globalIgnoreCount++;
+
+	return {
+		name: name || `globalIgnores ${id}`,
+		ignores: ignorePatterns,
+	};
+}
+
+exports.defineConfig = defineConfig;
+exports.globalIgnores = globalIgnores;

node_modules/@eslint/config-helpers/dist/cjs/index.d.cts

@@ -0,0 +1,24 @@
+export type Config = import("eslint").Linter.Config;
+export type LegacyConfig = import("eslint").Linter.LegacyConfig;
+export type Plugin = import("eslint").ESLint.Plugin;
+export type RuleEntry = import("eslint").Linter.RuleEntry;
+export type ExtendsElement = import("./types.cts").ExtendsElement;
+export type SimpleExtendsElement = import("./types.cts").SimpleExtendsElement;
+export type ConfigWithExtends = import("./types.cts").ConfigWithExtends;
+export type InfiniteConfigArray = import("./types.cts").InfiniteArray<Config>;
+export type ConfigWithExtendsArray = import("./types.cts").ConfigWithExtendsArray;
+/**
+ * Helper function to define a config array.
+ * @param {ConfigWithExtendsArray} args The arguments to the function.
+ * @returns {Config[]} The config array.
+ * @throws {TypeError} If no arguments are provided or if an argument is not an object.
+ */
+export function defineConfig(...args: ConfigWithExtendsArray): Config[];
+/**
+ * Creates a global ignores config with the given patterns.
+ * @param {string[]} ignorePatterns The ignore patterns.
+ * @param {string} [name] The name of the global ignores config.
+ * @returns {Config} The global ignores config.
+ * @throws {TypeError} If ignorePatterns is not an array or if it is empty.
+ */
+export function globalIgnores(ignorePatterns: string[], name?: string): Config;

node_modules/@eslint/config-helpers/dist/cjs/types.cts

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Types for this package.
+ */
+
+import type { Linter } from "eslint";
+
+/**
+ * Infinite array type.
+ */
+export type InfiniteArray<T> = T | InfiniteArray<T>[];
+
+/**
+ * The type of array element in the `extends` property after flattening.
+ */
+export type SimpleExtendsElement = string | Linter.Config;
+
+/**
+ * The type of array element in the `extends` property before flattening.
+ */
+export type ExtendsElement =
+	| SimpleExtendsElement
+	| InfiniteArray<Linter.Config>;
+
+/**
+ * Config with extends. Valid only inside of `defineConfig()`.
+ */
+export interface ConfigWithExtends extends Linter.Config {
+	extends?: ExtendsElement[];
+}
+
+export type ConfigWithExtendsArray = InfiniteArray<ConfigWithExtends>[];

node_modules/@eslint/config-helpers/dist/esm/index.d.ts

@@ -0,0 +1,24 @@
+export type Config = import("eslint").Linter.Config;
+export type LegacyConfig = import("eslint").Linter.LegacyConfig;
+export type Plugin = import("eslint").ESLint.Plugin;
+export type RuleEntry = import("eslint").Linter.RuleEntry;
+export type ExtendsElement = import("./types.ts").ExtendsElement;
+export type SimpleExtendsElement = import("./types.ts").SimpleExtendsElement;
+export type ConfigWithExtends = import("./types.ts").ConfigWithExtends;
+export type InfiniteConfigArray = import("./types.ts").InfiniteArray<Config>;
+export type ConfigWithExtendsArray = import("./types.ts").ConfigWithExtendsArray;
+/**
+ * Helper function to define a config array.
+ * @param {ConfigWithExtendsArray} args The arguments to the function.
+ * @returns {Config[]} The config array.
+ * @throws {TypeError} If no arguments are provided or if an argument is not an object.
+ */
+export function defineConfig(...args: ConfigWithExtendsArray): Config[];
+/**
+ * Creates a global ignores config with the given patterns.
+ * @param {string[]} ignorePatterns The ignore patterns.
+ * @param {string} [name] The name of the global ignores config.
+ * @returns {Config} The global ignores config.
+ * @throws {TypeError} If ignorePatterns is not an array or if it is empty.
+ */
+export function globalIgnores(ignorePatterns: string[], name?: string): Config;

node_modules/@eslint/config-helpers/dist/esm/index.js

@@ -0,0 +1,579 @@
+// @ts-self-types="./index.d.ts"
+/**
+ * @fileoverview defineConfig helper
+ * @author Nicholas C. Zakas
+ */
+
+//-----------------------------------------------------------------------------
+// Type Definitions
+//-----------------------------------------------------------------------------
+
+/** @typedef {import("eslint").Linter.Config} Config */
+/** @typedef {import("eslint").Linter.LegacyConfig} LegacyConfig */
+/** @typedef {import("eslint").ESLint.Plugin} Plugin */
+/** @typedef {import("eslint").Linter.RuleEntry} RuleEntry */
+/** @typedef {import("./types.ts").ExtendsElement} ExtendsElement */
+/** @typedef {import("./types.ts").SimpleExtendsElement} SimpleExtendsElement */
+/** @typedef {import("./types.ts").ConfigWithExtends} ConfigWithExtends */
+/** @typedef {import("./types.ts").InfiniteArray<Config>} InfiniteConfigArray */
+/** @typedef {import("./types.ts").ConfigWithExtendsArray} ConfigWithExtendsArray */
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+const eslintrcKeys = [
+	"env",
+	"extends",
+	"globals",
+	"ignorePatterns",
+	"noInlineConfig",
+	"overrides",
+	"parser",
+	"parserOptions",
+	"reportUnusedDisableDirectives",
+	"root",
+];
+
+const allowedGlobalIgnoreKeys = new Set(["basePath", "ignores", "name"]);
+
+/**
+ * Gets the name of a config object.
+ * @param {Config} config The config object.
+ * @param {string} indexPath The index path of the config object.
+ * @return {string} The name of the config object.
+ */
+function getConfigName(config, indexPath) {
+	if (config.name) {
+		return config.name;
+	}
+
+	return `UserConfig${indexPath}`;
+}
+
+/**
+ * Gets the name of an extension.
+ * @param {SimpleExtendsElement} extension The extension.
+ * @param {string} indexPath The index of the extension.
+ * @return {string} The name of the extension.
+ */
+function getExtensionName(extension, indexPath) {
+	if (typeof extension === "string") {
+		return extension;
+	}
+
+	if (extension.name) {
+		return extension.name;
+	}
+
+	return `ExtendedConfig${indexPath}`;
+}
+
+/**
+ * Determines if a config object is a legacy config.
+ * @param {Config|LegacyConfig} config The config object to check.
+ * @return {config is LegacyConfig} `true` if the config object is a legacy config.
+ */
+function isLegacyConfig(config) {
+	for (const key of eslintrcKeys) {
+		if (key in config) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * Determines if a config object is a global ignores config.
+ * @param {Config} config The config object to check.
+ * @return {boolean} `true` if the config object is a global ignores config.
+ */
+function isGlobalIgnores(config) {
+	return Object.keys(config).every(key => allowedGlobalIgnoreKeys.has(key));
+}
+
+/**
+ * Parses a plugin member ID (rule, processor, etc.) and returns
+ * the namespace and member name.
+ * @param {string} id The ID to parse.
+ * @returns {{namespace:string, name:string}} The namespace and member name.
+ */
+function getPluginMember(id) {
+	const firstSlashIndex = id.indexOf("/");
+
+	if (firstSlashIndex === -1) {
+		return { namespace: "", name: id };
+	}
+
+	let namespace = id.slice(0, firstSlashIndex);
+
+	/*
+	 * Special cases:
+	 * 1. The namespace is `@`, that means it's referring to the
+	 *    core plugin so `@` is the full namespace.
+	 * 2. The namespace starts with `@`, that means it's referring to
+	 *    an npm scoped package. That means the namespace is the scope
+	 *    and the package name (i.e., `@eslint/core`).
+	 */
+	if (namespace[0] === "@" && namespace !== "@") {
+		const secondSlashIndex = id.indexOf("/", firstSlashIndex + 1);
+		if (secondSlashIndex !== -1) {
+			namespace = id.slice(0, secondSlashIndex);
+			return { namespace, name: id.slice(secondSlashIndex + 1) };
+		}
+	}
+
+	const name = id.slice(firstSlashIndex + 1);
+
+	return { namespace, name };
+}
+
+/**
+ * Normalizes the plugin config by replacing the namespace with the plugin namespace.
+ * @param {string} userNamespace The namespace of the plugin.
+ * @param {Plugin} plugin The plugin config object.
+ * @param {Config} config The config object to normalize.
+ * @return {Config} The normalized config object.
+ */
+function normalizePluginConfig(userNamespace, plugin, config) {
+	const pluginNamespace = plugin.meta?.namespace;
+
+	// don't do anything if the plugin doesn't have a namespace or rules
+	if (
+		!pluginNamespace ||
+		pluginNamespace === userNamespace ||
+		(!config.rules && !config.processor && !config.language)
+	) {
+		return config;
+	}
+
+	const result = { ...config };
+
+	// update the rules
+	if (result.rules) {
+		const ruleIds = Object.keys(result.rules);
+
+		/** @type {Record<string,RuleEntry|undefined>} */
+		const newRules = {};
+
+		for (let i = 0; i < ruleIds.length; i++) {
+			const ruleId = ruleIds[i];
+			const { namespace: ruleNamespace, name: ruleName } =
+				getPluginMember(ruleId);
+
+			if (ruleNamespace === pluginNamespace) {
+				newRules[`${userNamespace}/${ruleName}`] = result.rules[ruleId];
+			} else {
+				newRules[ruleId] = result.rules[ruleId];
+			}
+		}
+
+		result.rules = newRules;
+	}
+
+	// update the processor
+
+	if (typeof result.processor === "string") {
+		const { namespace: processorNamespace, name: processorName } =
+			getPluginMember(result.processor);
+
+		if (processorNamespace) {
+			if (processorNamespace === pluginNamespace) {
+				result.processor = `${userNamespace}/${processorName}`;
+			}
+		}
+	}
+
+	// update the language
+	if (typeof result.language === "string") {
+		const { namespace: languageNamespace, name: languageName } =
+			getPluginMember(result.language);
+
+		if (languageNamespace === pluginNamespace) {
+			result.language = `${userNamespace}/${languageName}`;
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Deeply normalizes a plugin config, traversing recursively into an arrays.
+ * @param {string} userPluginNamespace The namespace of the plugin.
+ * @param {Plugin} plugin The plugin object.
+ * @param {Config|LegacyConfig|(Config|LegacyConfig)[]} pluginConfig The plugin config to normalize.
+ * @param {string} pluginConfigName The name of the plugin config.
+ * @return {InfiniteConfigArray} The normalized plugin config.
+ * @throws {TypeError} If the plugin config is a legacy config.
+ */
+function deepNormalizePluginConfig(
+	userPluginNamespace,
+	plugin,
+	pluginConfig,
+	pluginConfigName,
+) {
+	// if it's an array then it's definitely a new config
+	if (Array.isArray(pluginConfig)) {
+		return pluginConfig.map(pluginSubConfig =>
+			deepNormalizePluginConfig(
+				userPluginNamespace,
+				plugin,
+				pluginSubConfig,
+				pluginConfigName,
+			),
+		);
+	}
+
+	// if it's a legacy config, throw an error
+	if (isLegacyConfig(pluginConfig)) {
+		throw new TypeError(
+			`Plugin config "${pluginConfigName}" is an eslintrc config and cannot be used in this context.`,
+		);
+	}
+
+	return normalizePluginConfig(userPluginNamespace, plugin, pluginConfig);
+}
+
+/**
+ * Finds a plugin config by name in the given config.
+ * @param {Config} config The config object.
+ * @param {string} pluginConfigName The name of the plugin config.
+ * @return {InfiniteConfigArray} The plugin config.
+ * @throws {TypeError} If the plugin config is not found or is a legacy config.
+ */
+function findPluginConfig(config, pluginConfigName) {
+	const { namespace: userPluginNamespace, name: configName } =
+		getPluginMember(pluginConfigName);
+	const plugin = config.plugins?.[userPluginNamespace];
+
+	if (!plugin) {
+		throw new TypeError(`Plugin "${userPluginNamespace}" not found.`);
+	}
+
+	const directConfig = plugin.configs?.[configName];
+	if (directConfig) {
+		// Arrays are always flat configs, and non-legacy configs can be used directly
+		if (Array.isArray(directConfig) || !isLegacyConfig(directConfig)) {
+			return deepNormalizePluginConfig(
+				userPluginNamespace,
+				plugin,
+				directConfig,
+				pluginConfigName,
+			);
+		}
+
+		// If it's a legacy config, look for the flat version
+		const flatConfig = plugin.configs?.[`flat/${configName}`];
+
+		if (
+			flatConfig &&
+			(Array.isArray(flatConfig) || !isLegacyConfig(flatConfig))
+		) {
+			return deepNormalizePluginConfig(
+				userPluginNamespace,
+				plugin,
+				flatConfig,
+				pluginConfigName,
+			);
+		}
+
+		throw new TypeError(
+			`Plugin config "${configName}" in plugin "${userPluginNamespace}" is an eslintrc config and cannot be used in this context.`,
+		);
+	}
+
+	throw new TypeError(
+		`Plugin config "${configName}" not found in plugin "${userPluginNamespace}".`,
+	);
+}
+
+/**
+ * Flattens an array while keeping track of the index path.
+ * @param {any[]} configList The array to traverse.
+ * @param {string} indexPath The index path of the value in a multidimensional array.
+ * @return {IterableIterator<{indexPath:string, value:any}>} The flattened list of values.
+ */
+function* flatTraverse(configList, indexPath = "") {
+	for (let i = 0; i < configList.length; i++) {
+		const newIndexPath = indexPath ? `${indexPath}[${i}]` : `[${i}]`;
+
+		// if it's an array then traverse it as well
+		if (Array.isArray(configList[i])) {
+			yield* flatTraverse(configList[i], newIndexPath);
+			continue;
+		}
+
+		yield { indexPath: newIndexPath, value: configList[i] };
+	}
+}
+
+/**
+ * Extends a list of config files by creating every combination of base and extension files.
+ * @param {(string|string[])[]} [baseFiles] The base files.
+ * @param {(string|string[])[]} [extensionFiles] The extension files.
+ * @return {(string|string[])[]} The extended files.
+ */
+function extendConfigFiles(baseFiles = [], extensionFiles = []) {
+	if (!extensionFiles.length) {
+		return baseFiles.concat();
+	}
+
+	if (!baseFiles.length) {
+		return extensionFiles.concat();
+	}
+
+	/** @type {(string|string[])[]} */
+	const result = [];
+
+	for (const baseFile of baseFiles) {
+		for (const extensionFile of extensionFiles) {
+			/*
+			 * Each entry can be a string or array of strings. The end result
+			 * needs to be an array of strings, so we need to be sure to include
+			 * all of the items when there's an array.
+			 */
+
+			const entry = [];
+
+			if (Array.isArray(baseFile)) {
+				entry.push(...baseFile);
+			} else {
+				entry.push(baseFile);
+			}
+
+			if (Array.isArray(extensionFile)) {
+				entry.push(...extensionFile);
+			} else {
+				entry.push(extensionFile);
+			}
+
+			result.push(entry);
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Extends a config object with another config object.
+ * @param {Config} baseConfig The base config object.
+ * @param {string} baseConfigName The name of the base config object.
+ * @param {Config} extension The extension config object.
+ * @param {string} extensionName The index of the extension config object.
+ * @return {Config} The extended config object.
+ */
+function extendConfig(baseConfig, baseConfigName, extension, extensionName) {
+	const result = { ...extension };
+
+	// for global ignores there is no further work to be done, we just keep everything
+	if (!isGlobalIgnores(extension)) {
+		// for files we need to create every combination of base and extension files
+		if (baseConfig.files) {
+			result.files = extendConfigFiles(baseConfig.files, extension.files);
+		}
+
+		// for ignores we just concatenation the extension ignores onto the base ignores
+		if (baseConfig.ignores) {
+			result.ignores = baseConfig.ignores.concat(extension.ignores ?? []);
+		}
+	}
+
+	result.name = `${baseConfigName} > ${extensionName}`;
+
+	// @ts-ignore -- ESLint types aren't updated yet
+	if (baseConfig.basePath) {
+		// @ts-ignore -- ESLint types aren't updated yet
+		result.basePath = baseConfig.basePath;
+	}
+
+	return result;
+}
+
+/**
+ * Processes a list of extends elements.
+ * @param {ConfigWithExtends} config The config object.
+ * @param {WeakMap<Config, string>} configNames The map of config objects to their names.
+ * @return {Config[]} The flattened list of config objects.
+ * @throws {TypeError} If the `extends` property is not an array or if nested `extends` is found.
+ */
+function processExtends(config, configNames) {
+	if (!config.extends) {
+		return [config];
+	}
+
+	if (!Array.isArray(config.extends)) {
+		throw new TypeError("The `extends` property must be an array.");
+	}
+
+	const {
+		/** @type {Config[]} */
+		extends: extendsList,
+
+		/** @type {Config} */
+		...configObject
+	} = config;
+
+	const extensionNames = new WeakMap();
+
+	// replace strings with the actual configs
+	const objectExtends = extendsList.map(extendsElement => {
+		if (typeof extendsElement === "string") {
+			const pluginConfig = findPluginConfig(config, extendsElement);
+
+			// assign names
+			if (Array.isArray(pluginConfig)) {
+				pluginConfig.forEach((pluginConfigElement, index) => {
+					extensionNames.set(
+						pluginConfigElement,
+						`${extendsElement}[${index}]`,
+					);
+				});
+			} else {
+				extensionNames.set(pluginConfig, extendsElement);
+			}
+
+			return pluginConfig;
+		}
+
+		return /** @type {Config} */ (extendsElement);
+	});
+
+	const result = [];
+
+	for (const { indexPath, value: extendsElement } of flatTraverse(
+		objectExtends,
+	)) {
+		const extension = /** @type {Config} */ (extendsElement);
+
+		if ("basePath" in extension) {
+			throw new TypeError("'basePath' in `extends` is not allowed.");
+		}
+
+		if ("extends" in extension) {
+			throw new TypeError("Nested 'extends' is not allowed.");
+		}
+
+		const baseConfigName = /** @type {string} */ (configNames.get(config));
+		const extensionName =
+			extensionNames.get(extendsElement) ??
+			getExtensionName(extendsElement, indexPath);
+
+		result.push(
+			extendConfig(
+				configObject,
+				baseConfigName,
+				extension,
+				extensionName,
+			),
+		);
+	}
+
+	/*
+	 * If the base config object has only `ignores` and `extends`, then
+	 * removing `extends` turns it into a global ignores, which is not what
+	 * we want. So we need to check if the base config object is a global ignores
+	 * and if so, we don't add it to the array.
+	 *
+	 * (The other option would be to add a `files` entry, but that would result
+	 * in a config that didn't actually do anything because there are no
+	 * other keys in the config.)
+	 */
+	if (!isGlobalIgnores(configObject)) {
+		result.push(configObject);
+	}
+
+	return result.flat();
+}
+
+/**
+ * Processes a list of config objects and arrays.
+ * @param {ConfigWithExtends[]} configList The list of config objects and arrays.
+ * @param {WeakMap<Config, string>} configNames The map of config objects to their names.
+ * @return {Config[]} The flattened list of config objects.
+ */
+function processConfigList(configList, configNames) {
+	return configList.flatMap(config => processExtends(config, configNames));
+}
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * Helper function to define a config array.
+ * @param {ConfigWithExtendsArray} args The arguments to the function.
+ * @returns {Config[]} The config array.
+ * @throws {TypeError} If no arguments are provided or if an argument is not an object.
+ */
+function defineConfig(...args) {
+	const configNames = new WeakMap();
+	const configs = [];
+
+	if (args.length === 0) {
+		throw new TypeError("Expected one or more arguments.");
+	}
+
+	// first flatten the list of configs and get the names
+	for (const { indexPath, value } of flatTraverse(args)) {
+		if (typeof value !== "object" || value === null) {
+			throw new TypeError(
+				`Expected an object but received ${String(value)}.`,
+			);
+		}
+
+		const config = /** @type {ConfigWithExtends} */ (value);
+
+		// save config name for easy reference later
+		configNames.set(config, getConfigName(config, indexPath));
+		configs.push(config);
+	}
+
+	return processConfigList(configs, configNames);
+}
+
+/**
+ * @fileoverview Global ignores helper function.
+ * @author Nicholas C. Zakas
+ */
+
+//-----------------------------------------------------------------------------
+// Type Definitions
+//-----------------------------------------------------------------------------
+
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+let globalIgnoreCount = 0;
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * Creates a global ignores config with the given patterns.
+ * @param {string[]} ignorePatterns The ignore patterns.
+ * @param {string} [name] The name of the global ignores config.
+ * @returns {Config} The global ignores config.
+ * @throws {TypeError} If ignorePatterns is not an array or if it is empty.
+ */
+function globalIgnores(ignorePatterns, name) {
+	if (!Array.isArray(ignorePatterns)) {
+		throw new TypeError("ignorePatterns must be an array");
+	}
+
+	if (ignorePatterns.length === 0) {
+		throw new TypeError("ignorePatterns must contain at least one pattern");
+	}
+
+	const id = globalIgnoreCount++;
+
+	return {
+		name: name || `globalIgnores ${id}`,
+		ignores: ignorePatterns,
+	};
+}
+
+export { defineConfig, globalIgnores };

node_modules/@eslint/config-helpers/dist/esm/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Types for this package.
+ */
+import type { Linter } from "eslint";
+/**
+ * Infinite array type.
+ */
+export type InfiniteArray<T> = T | InfiniteArray<T>[];
+/**
+ * The type of array element in the `extends` property after flattening.
+ */
+export type SimpleExtendsElement = string | Linter.Config;
+/**
+ * The type of array element in the `extends` property before flattening.
+ */
+export type ExtendsElement = SimpleExtendsElement | InfiniteArray<Linter.Config>;
+/**
+ * Config with extends. Valid only inside of `defineConfig()`.
+ */
+export interface ConfigWithExtends extends Linter.Config {
+    extends?: ExtendsElement[];
+}
+export type ConfigWithExtendsArray = InfiniteArray<ConfigWithExtends>[];

node_modules/@eslint/config-helpers/dist/esm/types.ts

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Types for this package.
+ */
+
+import type { Linter } from "eslint";
+
+/**
+ * Infinite array type.
+ */
+export type InfiniteArray<T> = T | InfiniteArray<T>[];
+
+/**
+ * The type of array element in the `extends` property after flattening.
+ */
+export type SimpleExtendsElement = string | Linter.Config;
+
+/**
+ * The type of array element in the `extends` property before flattening.
+ */
+export type ExtendsElement =
+	| SimpleExtendsElement
+	| InfiniteArray<Linter.Config>;
+
+/**
+ * Config with extends. Valid only inside of `defineConfig()`.
+ */
+export interface ConfigWithExtends extends Linter.Config {
+	extends?: ExtendsElement[];
+}
+
+export type ConfigWithExtendsArray = InfiniteArray<ConfigWithExtends>[];

node_modules/@eslint/config-helpers/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@eslint/config-helpers",
+  "version": "0.3.1",
+  "description": "Helper utilities for creating ESLint configuration",
+  "type": "module",
+  "main": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    "require": {
+      "types": "./dist/cjs/index.d.cts",
+      "default": "./dist/cjs/index.cjs"
+    },
+    "import": {
+      "types": "./dist/esm/index.d.ts",
+      "default": "./dist/esm/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "build:dedupe-types": "node ../../tools/dedupe-types.js dist/cjs/index.cjs dist/esm/index.js",
+    "build:cts": "node ../../tools/build-cts.js dist/esm/index.d.ts dist/cjs/index.d.cts",
+    "build": "rollup -c && npm run build:dedupe-types && tsc -p tsconfig.esm.json && npm run build:cts",
+    "test:jsr": "npx jsr@latest publish --dry-run",
+    "test": "mocha tests/*.js",
+    "test:coverage": "c8 npm test",
+    "test:types": "tsc -p tests/types/tsconfig.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eslint/rewrite.git",
+    "directory": "packages/config-helpers"
+  },
+  "keywords": [
+    "eslint"
+  ],
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/eslint/rewrite/issues"
+  },
+  "homepage": "https://github.com/eslint/rewrite/tree/main/packages/config-helpers#readme",
+  "devDependencies": {
+    "@eslint/core": "^0.15.2",
+    "eslint": "^9.27.0",
+    "rollup-plugin-copy": "^3.5.0"
+  },
+  "engines": {
+    "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+  }
+}