Initial commit - Todo app frontend

node_modules/typescript-eslint/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 typescript-eslint and other contributors
+
+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/typescript-eslint/README.md

@@ -0,0 +1,12 @@
+# `typescript-eslint`
+
+> Tooling which enables you to use TypeScript with ESLint
+
+[![NPM Version](https://img.shields.io/npm/v/typescript-eslint.svg?style=flat-square)](https://www.npmjs.com/package/typescript-eslint)
+[![NPM Downloads](https://img.shields.io/npm/dm/typescript-eslint.svg?style=flat-square)](https://www.npmjs.com/package/typescript-eslint)
+
+👉 See **https://typescript-eslint.io/packages/typescript-eslint** for documentation on this package.
+
+> See https://typescript-eslint.io for general documentation on typescript-eslint, the tooling that allows you to run ESLint and Prettier on TypeScript code.
+
+<!-- Local path for docs: docs/packages/typescript-eslint.mdx -->

node_modules/typescript-eslint/dist/compatibility-types.d.ts

@@ -0,0 +1,16 @@
+export interface CompatibleParser {
+    parseForESLint(text: string): {
+        ast: unknown;
+        scopeManager: unknown;
+    };
+}
+export interface CompatibleConfig {
+    name?: string;
+    rules?: object;
+}
+export type CompatibleConfigArray = CompatibleConfig[];
+export interface CompatiblePlugin {
+    meta: {
+        name: string;
+    };
+}

node_modules/typescript-eslint/dist/compatibility-types.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * This file contains types that are intentionally wide/inaccurate, that exist
+ * for the purpose of satisfying both `defineConfig()` and `tseslint.config()`.
+ * See https://github.com/typescript-eslint/typescript-eslint/issues/10899
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/typescript-eslint/dist/config-helper.d.ts

@@ -0,0 +1,70 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type InfiniteDepthConfigWithExtends = ConfigWithExtends | InfiniteDepthConfigWithExtends[];
+export interface ConfigWithExtends extends TSESLint.FlatConfig.Config {
+    /**
+     * Allows you to "extend" a set of configs similar to `extends` from the
+     * classic configs.
+     *
+     * This is just a convenience short-hand to help reduce duplication.
+     *
+     * ```js
+     * export default tseslint.config({
+     *   files: ['** /*.ts'],
+     *   extends: [
+     *     eslint.configs.recommended,
+     *     tseslint.configs.recommended,
+     *   ],
+     *   rules: {
+     *     '@typescript-eslint/array-type': 'error',
+     *     '@typescript-eslint/consistent-type-imports': 'error',
+     *   },
+     * })
+     *
+     * // expands to
+     *
+     * export default [
+     *   {
+     *     ...eslint.configs.recommended,
+     *     files: ['** /*.ts'],
+     *   },
+     *   ...tseslint.configs.recommended.map(conf => ({
+     *     ...conf,
+     *     files: ['** /*.ts'],
+     *   })),
+     *   {
+     *     files: ['** /*.ts'],
+     *     rules: {
+     *       '@typescript-eslint/array-type': 'error',
+     *       '@typescript-eslint/consistent-type-imports': 'error',
+     *     },
+     *   },
+     * ]
+     * ```
+     */
+    extends?: InfiniteDepthConfigWithExtends[];
+}
+export type ConfigArray = TSESLint.FlatConfig.ConfigArray;
+/**
+ * Utility function to make it easy to strictly type your "Flat" config file
+ * @example
+ * ```js
+ * // @ts-check
+ *
+ * import eslint from '@eslint/js';
+ * import tseslint from 'typescript-eslint';
+ *
+ * export default tseslint.config(
+ *   eslint.configs.recommended,
+ *   tseslint.configs.recommended,
+ *   {
+ *     rules: {
+ *       '@typescript-eslint/array-type': 'error',
+ *     },
+ *   },
+ * );
+ * ```
+ *
+ * @deprecated ESLint core now provides this functionality via `defineConfig()`,
+ * which we now recommend instead. See {@link https://typescript-eslint.io/packages/typescript-eslint/#config-deprecated}.
+ */
+export declare function config(...configs: InfiniteDepthConfigWithExtends[]): ConfigArray;

node_modules/typescript-eslint/dist/config-helper.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = config;
+/**
+ * Utility function to make it easy to strictly type your "Flat" config file
+ * @example
+ * ```js
+ * // @ts-check
+ *
+ * import eslint from '@eslint/js';
+ * import tseslint from 'typescript-eslint';
+ *
+ * export default tseslint.config(
+ *   eslint.configs.recommended,
+ *   tseslint.configs.recommended,
+ *   {
+ *     rules: {
+ *       '@typescript-eslint/array-type': 'error',
+ *     },
+ *   },
+ * );
+ * ```
+ *
+ * @deprecated ESLint core now provides this functionality via `defineConfig()`,
+ * which we now recommend instead. See {@link https://typescript-eslint.io/packages/typescript-eslint/#config-deprecated}.
+ */
+function config(...configs) {
+    return configImpl(...configs);
+}
+// Implementation of the config function without assuming the runtime type of
+// the input.
+function configImpl(...configs) {
+    const flattened = configs.flat(Infinity);
+    return flattened.flatMap((configWithExtends, configIndex) => {
+        if (configWithExtends == null ||
+            typeof configWithExtends !== 'object' ||
+            !('extends' in configWithExtends)) {
+            // Unless the object is a config object with extends key, just forward it
+            // along to eslint.
+            return configWithExtends;
+        }
+        const { extends: extendsArr, ..._config } = configWithExtends;
+        const config = _config;
+        if (extendsArr == null) {
+            // If the extends value is nullish, just forward along the rest of the
+            // config object to eslint.
+            return config;
+        }
+        const name = (() => {
+            if ('name' in configWithExtends && configWithExtends.name != null) {
+                if (typeof configWithExtends.name !== 'string') {
+                    throw new Error(`tseslint.config(): Config at index ${configIndex} has a 'name' property that is not a string.`);
+                }
+                return configWithExtends.name;
+            }
+            return undefined;
+        })();
+        const nameErrorPhrase = name != null ? `, named "${name}",` : ' (anonymous)';
+        if (!Array.isArray(extendsArr)) {
+            throw new TypeError(`tseslint.config(): Config at index ${configIndex}${nameErrorPhrase} has an 'extends' property that is not an array.`);
+        }
+        const extendsArrFlattened = extendsArr.flat(Infinity);
+        const nonObjectExtensions = [];
+        for (const [extensionIndex, extension] of extendsArrFlattened.entries()) {
+            // special error message to be clear we don't support eslint's stringly typed extends.
+            // https://eslint.org/docs/latest/use/configure/configuration-files#extending-configurations
+            if (typeof extension === 'string') {
+                throw new Error(`tseslint.config(): Config at index ${configIndex}${nameErrorPhrase} has an 'extends' array that contains a string (${JSON.stringify(extension)}) at index ${extensionIndex}.` +
+                    " This is a feature of eslint's `defineConfig()` helper and is not supported by typescript-eslint." +
+                    ' Please provide a config object instead.');
+            }
+            if (extension == null || typeof extension !== 'object') {
+                nonObjectExtensions.push(extensionIndex);
+                continue;
+            }
+            // https://github.com/eslint/rewrite/blob/82d07fd0e8e06780b552a41f8bcbe2a4f8741d42/packages/config-helpers/src/define-config.js#L448-L450
+            if ('basePath' in extension) {
+                throw new TypeError(`tseslint.config(): Config at index ${configIndex}${nameErrorPhrase} has an 'extends' array that contains a config with a 'basePath' property at index ${extensionIndex}.` +
+                    ` 'basePath' in 'extends' is not allowed.`);
+            }
+            if ('extends' in extension) {
+                throw new TypeError(`tseslint.config(): Config at index ${configIndex}${nameErrorPhrase} has an 'extends' array that contains a config with an 'extends' property at index ${extensionIndex}.` +
+                    ` Nested 'extends' is not allowed.`);
+            }
+        }
+        if (nonObjectExtensions.length > 0) {
+            const extensionIndices = nonObjectExtensions.join(', ');
+            throw new TypeError(`tseslint.config(): Config at index ${configIndex}${nameErrorPhrase} contains non-object` +
+                ` extensions at the following indices: ${extensionIndices}.`);
+        }
+        const configArray = [];
+        for (const _extension of extendsArrFlattened) {
+            const extension = _extension;
+            const resolvedConfigName = [name, extension.name]
+                .filter(Boolean)
+                .join('__');
+            if (isPossiblyGlobalIgnores(extension)) {
+                // If it's a global ignores, then just pass it along
+                configArray.push({
+                    ...extension,
+                    ...(resolvedConfigName !== '' ? { name: resolvedConfigName } : {}),
+                });
+            }
+            else {
+                configArray.push({
+                    ...extension,
+                    ...(config.files ? { files: config.files } : {}),
+                    ...(config.ignores ? { ignores: config.ignores } : {}),
+                    ...(config.basePath ? { basePath: config.basePath } : {}),
+                    ...(resolvedConfigName !== '' ? { name: resolvedConfigName } : {}),
+                });
+            }
+        }
+        // If the base config could form a global ignores object, then we mustn't include
+        // it in the output. Otherwise, we must add it in order for it to have effect.
+        if (!isPossiblyGlobalIgnores(config)) {
+            configArray.push(config);
+        }
+        return configArray;
+    });
+}
+/**
+ * This utility function returns false if the config objects contains any field
+ * that would prevent it from being considered a global ignores object and true
+ * otherwise. Note in particular that the `ignores` field may not be present and
+ * the return value can still be true.
+ */
+function isPossiblyGlobalIgnores(config) {
+    return Object.keys(config).every(key => ['name', 'ignores', 'basePath'].includes(key));
+}

node_modules/typescript-eslint/dist/getTSConfigRootDirFromStack.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Infers the `tsconfigRootDir` from the current call stack, using the V8 API.
+ *
+ * See https://v8.dev/docs/stack-trace-api
+ *
+ * This API is implemented in Deno and Bun as well.
+ */
+export declare function getTSConfigRootDirFromStack(): string | undefined;

node_modules/typescript-eslint/dist/getTSConfigRootDirFromStack.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTSConfigRootDirFromStack = getTSConfigRootDirFromStack;
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+/**
+ * Infers the `tsconfigRootDir` from the current call stack, using the V8 API.
+ *
+ * See https://v8.dev/docs/stack-trace-api
+ *
+ * This API is implemented in Deno and Bun as well.
+ */
+function getTSConfigRootDirFromStack() {
+    function getStack() {
+        const stackTraceLimit = Error.stackTraceLimit;
+        Error.stackTraceLimit = Infinity;
+        const prepareStackTrace = Error.prepareStackTrace;
+        Error.prepareStackTrace = (_, structuredStackTrace) => structuredStackTrace;
+        const dummyObject = {};
+        Error.captureStackTrace(dummyObject, getTSConfigRootDirFromStack);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- stack is set by captureStackTrace
+        const rv = dummyObject.stack;
+        Error.prepareStackTrace = prepareStackTrace;
+        Error.stackTraceLimit = stackTraceLimit;
+        return rv;
+    }
+    for (const callSite of getStack()) {
+        const stackFrameFilePathOrUrl = callSite.getFileName();
+        if (!stackFrameFilePathOrUrl) {
+            continue;
+        }
+        // ESM seem to return a file URL, so we'll convert it to a file path.
+        // AFAICT this isn't documented in the v8 API docs, but it seems to be the case.
+        // See https://github.com/typescript-eslint/typescript-eslint/issues/11429
+        const stackFrameFilePath = stackFrameFilePathOrUrl.startsWith('file://')
+            ? (0, node_url_1.fileURLToPath)(stackFrameFilePathOrUrl)
+            : stackFrameFilePathOrUrl;
+        const parsedPath = node_path_1.default.parse(stackFrameFilePath);
+        if (/^eslint\.config\.(c|m)?(j|t)s$/.test(parsedPath.base)) {
+            if (process.platform === 'win32') {
+                // workaround for https://github.com/typescript-eslint/typescript-eslint/issues/11530
+                // (caused by https://github.com/unjs/jiti/issues/397)
+                return parsedPath.dir.replaceAll('/', node_path_1.default.sep);
+            }
+            return parsedPath.dir;
+        }
+    }
+    return undefined;
+}

node_modules/typescript-eslint/dist/index.d.ts

@@ -0,0 +1,154 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+import type { CompatibleConfig, CompatibleConfigArray, CompatibleParser, CompatiblePlugin } from './compatibility-types';
+import { config } from './config-helper';
+export type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+export declare const parser: CompatibleParser;
+export declare const plugin: CompatiblePlugin;
+export declare const configs: {
+    /**
+     * Enables each the rules provided as a part of typescript-eslint. Note that many rules are not applicable in all codebases, or are meant to be configured.
+     * @see {@link https://typescript-eslint.io/users/configs#all}
+     */
+    all: CompatibleConfigArray;
+    /**
+     * A minimal ruleset that sets only the required parser and plugin options needed to run typescript-eslint.
+     * We don't recommend using this directly; instead, extend from an earlier recommended rule.
+     * @see {@link https://typescript-eslint.io/users/configs#base}
+     */
+    base: CompatibleConfig;
+    /**
+     * A utility ruleset that will disable type-aware linting and all type-aware rules available in our project.
+     * @see {@link https://typescript-eslint.io/users/configs#disable-type-checked}
+     */
+    disableTypeChecked: CompatibleConfig;
+    /**
+     * This is a compatibility ruleset that:
+     * - disables rules from eslint:recommended which are already handled by TypeScript.
+     * - enables rules that make sense due to TS's typechecking / transpilation.
+     * @see {@link https://typescript-eslint.io/users/configs/#eslint-recommended}
+     */
+    eslintRecommended: CompatibleConfig;
+    /**
+     * Recommended rules for code correctness that you can drop in without additional configuration.
+     * @see {@link https://typescript-eslint.io/users/configs#recommended}
+     */
+    recommended: CompatibleConfigArray;
+    /**
+     * Contains all of `recommended` along with additional recommended rules that require type information.
+     * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked}
+     */
+    recommendedTypeChecked: CompatibleConfigArray;
+    /**
+     * A version of `recommended` that only contains type-checked rules and disables of any corresponding core ESLint rules.
+     * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked-only}
+     */
+    recommendedTypeCheckedOnly: CompatibleConfigArray;
+    /**
+     * Contains all of `recommended`, as well as additional strict rules that can also catch bugs.
+     * @see {@link https://typescript-eslint.io/users/configs#strict}
+     */
+    strict: CompatibleConfigArray;
+    /**
+     * Contains all of `recommended`, `recommended-type-checked`, and `strict`, along with additional strict rules that require type information.
+     * @see {@link https://typescript-eslint.io/users/configs#strict-type-checked}
+     */
+    strictTypeChecked: CompatibleConfigArray;
+    /**
+     * A version of `strict` that only contains type-checked rules and disables of any corresponding core ESLint rules.
+     * @see {@link https://typescript-eslint.io/users/configs#strict-type-checked-only}
+     */
+    strictTypeCheckedOnly: CompatibleConfigArray;
+    /**
+     * Rules considered to be best practice for modern TypeScript codebases, but that do not impact program logic.
+     * @see {@link https://typescript-eslint.io/users/configs#stylistic}
+     */
+    stylistic: CompatibleConfigArray;
+    /**
+     * Contains all of `stylistic`, along with additional stylistic rules that require type information.
+     * @see {@link https://typescript-eslint.io/users/configs#stylistic-type-checked}
+     */
+    stylisticTypeChecked: CompatibleConfigArray;
+    /**
+     * A version of `stylistic` that only contains type-checked rules and disables of any corresponding core ESLint rules.
+     * @see {@link https://typescript-eslint.io/users/configs#stylistic-type-checked-only}
+     */
+    stylisticTypeCheckedOnly: CompatibleConfigArray;
+};
+export type Config = TSESLint.FlatConfig.ConfigFile;
+declare const _default: {
+    config: typeof config;
+    configs: {
+        /**
+         * Enables each the rules provided as a part of typescript-eslint. Note that many rules are not applicable in all codebases, or are meant to be configured.
+         * @see {@link https://typescript-eslint.io/users/configs#all}
+         */
+        all: CompatibleConfigArray;
+        /**
+         * A minimal ruleset that sets only the required parser and plugin options needed to run typescript-eslint.
+         * We don't recommend using this directly; instead, extend from an earlier recommended rule.
+         * @see {@link https://typescript-eslint.io/users/configs#base}
+         */
+        base: CompatibleConfig;
+        /**
+         * A utility ruleset that will disable type-aware linting and all type-aware rules available in our project.
+         * @see {@link https://typescript-eslint.io/users/configs#disable-type-checked}
+         */
+        disableTypeChecked: CompatibleConfig;
+        /**
+         * This is a compatibility ruleset that:
+         * - disables rules from eslint:recommended which are already handled by TypeScript.
+         * - enables rules that make sense due to TS's typechecking / transpilation.
+         * @see {@link https://typescript-eslint.io/users/configs/#eslint-recommended}
+         */
+        eslintRecommended: CompatibleConfig;
+        /**
+         * Recommended rules for code correctness that you can drop in without additional configuration.
+         * @see {@link https://typescript-eslint.io/users/configs#recommended}
+         */
+        recommended: CompatibleConfigArray;
+        /**
+         * Contains all of `recommended` along with additional recommended rules that require type information.
+         * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked}
+         */
+        recommendedTypeChecked: CompatibleConfigArray;
+        /**
+         * A version of `recommended` that only contains type-checked rules and disables of any corresponding core ESLint rules.
+         * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked-only}
+         */
+        recommendedTypeCheckedOnly: CompatibleConfigArray;
+        /**
+         * Contains all of `recommended`, as well as additional strict rules that can also catch bugs.
+         * @see {@link https://typescript-eslint.io/users/configs#strict}
+         */
+        strict: CompatibleConfigArray;
+        /**
+         * Contains all of `recommended`, `recommended-type-checked`, and `strict`, along with additional strict rules that require type information.
+         * @see {@link https://typescript-eslint.io/users/configs#strict-type-checked}
+         */
+        strictTypeChecked: CompatibleConfigArray;
+        /**
+         * A version of `strict` that only contains type-checked rules and disables of any corresponding core ESLint rules.
+         * @see {@link https://typescript-eslint.io/users/configs#strict-type-checked-only}
+         */
+        strictTypeCheckedOnly: CompatibleConfigArray;
+        /**
+         * Rules considered to be best practice for modern TypeScript codebases, but that do not impact program logic.
+         * @see {@link https://typescript-eslint.io/users/configs#stylistic}
+         */
+        stylistic: CompatibleConfigArray;
+        /**
+         * Contains all of `stylistic`, along with additional stylistic rules that require type information.
+         * @see {@link https://typescript-eslint.io/users/configs#stylistic-type-checked}
+         */
+        stylisticTypeChecked: CompatibleConfigArray;
+        /**
+         * A version of `stylistic` that only contains type-checked rules and disables of any corresponding core ESLint rules.
+         * @see {@link https://typescript-eslint.io/users/configs#stylistic-type-checked-only}
+         */
+        stylisticTypeCheckedOnly: CompatibleConfigArray;
+    };
+    parser: CompatibleParser;
+    plugin: CompatiblePlugin;
+};
+export default _default;
+export { config, type ConfigWithExtends, type InfiniteDepthConfigWithExtends, type ConfigArray, } from './config-helper';

node_modules/typescript-eslint/dist/index.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.configs = exports.plugin = exports.parser = void 0;
+const eslint_plugin_1 = __importDefault(require("@typescript-eslint/eslint-plugin"));
+const raw_plugin_1 = __importDefault(require("@typescript-eslint/eslint-plugin/use-at-your-own-risk/raw-plugin"));
+const typescript_estree_1 = require("@typescript-eslint/typescript-estree");
+const config_helper_1 = require("./config-helper");
+const getTSConfigRootDirFromStack_1 = require("./getTSConfigRootDirFromStack");
+exports.parser = raw_plugin_1.default.parser;
+/*
+we could build a plugin object here without the `configs` key - but if we do
+that then we create a situation in which
+```
+require('typescript-eslint').plugin !== require('@typescript-eslint/eslint-plugin')
+```
+
+This is bad because it means that 3rd party configs would be required to use
+`typescript-eslint` or else they would break a user's config if the user either
+used `tseslint.configs.recommended` et al or
+```
+{
+  plugins: {
+    '@typescript-eslint': tseslint.plugin,
+  },
+}
+```
+
+This might be something we could consider okay (eg 3rd party flat configs must
+use our new package); however legacy configs consumed via `@eslint/eslintrc`
+would never be able to satisfy this constraint and thus users would be blocked
+from using them.
+*/
+exports.plugin = eslint_plugin_1.default;
+exports.configs = createConfigsGetters({
+    /**
+     * Enables each the rules provided as a part of typescript-eslint. Note that many rules are not applicable in all codebases, or are meant to be configured.
+     * @see {@link https://typescript-eslint.io/users/configs#all}
+     */
+    all: raw_plugin_1.default.flatConfigs['flat/all'],
+    /**
+     * A minimal ruleset that sets only the required parser and plugin options needed to run typescript-eslint.
+     * We don't recommend using this directly; instead, extend from an earlier recommended rule.
+     * @see {@link https://typescript-eslint.io/users/configs#base}
+     */
+    base: raw_plugin_1.default.flatConfigs['flat/base'],
+    /**
+     * A utility ruleset that will disable type-aware linting and all type-aware rules available in our project.
+     * @see {@link https://typescript-eslint.io/users/configs#disable-type-checked}
+     */
+    disableTypeChecked: raw_plugin_1.default.flatConfigs['flat/disable-type-checked'],
+    /**
+     * This is a compatibility ruleset that:
+     * - disables rules from eslint:recommended which are already handled by TypeScript.
+     * - enables rules that make sense due to TS's typechecking / transpilation.
+     * @see {@link https://typescript-eslint.io/users/configs/#eslint-recommended}
+     */
+    eslintRecommended: raw_plugin_1.default.flatConfigs['flat/eslint-recommended'],
+    /**
+     * Recommended rules for code correctness that you can drop in without additional configuration.
+     * @see {@link https://typescript-eslint.io/users/configs#recommended}
+     */
+    recommended: raw_plugin_1.default.flatConfigs['flat/recommended'],
+    /**
+     * Contains all of `recommended` along with additional recommended rules that require type information.
+     * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked}
+     */
+    recommendedTypeChecked: raw_plugin_1.default.flatConfigs['flat/recommended-type-checked'],
+    /**
+     * A version of `recommended` that only contains type-checked rules and disables of any corresponding core ESLint rules.
+     * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked-only}
+     */
+    recommendedTypeCheckedOnly: raw_plugin_1.default.flatConfigs['flat/recommended-type-checked-only'],
+    /**
+     * Contains all of `recommended`, as well as additional strict rules that can also catch bugs.
+     * @see {@link https://typescript-eslint.io/users/configs#strict}
+     */
+    strict: raw_plugin_1.default.flatConfigs['flat/strict'],
+    /**
+     * Contains all of `recommended`, `recommended-type-checked`, and `strict`, along with additional strict rules that require type information.
+     * @see {@link https://typescript-eslint.io/users/configs#strict-type-checked}
+     */
+    strictTypeChecked: raw_plugin_1.default.flatConfigs['flat/strict-type-checked'],
+    /**
+     * A version of `strict` that only contains type-checked rules and disables of any corresponding core ESLint rules.
+     * @see {@link https://typescript-eslint.io/users/configs#strict-type-checked-only}
+     */
+    strictTypeCheckedOnly: raw_plugin_1.default.flatConfigs['flat/strict-type-checked-only'],
+    /**
+     * Rules considered to be best practice for modern TypeScript codebases, but that do not impact program logic.
+     * @see {@link https://typescript-eslint.io/users/configs#stylistic}
+     */
+    stylistic: raw_plugin_1.default.flatConfigs['flat/stylistic'],
+    /**
+     * Contains all of `stylistic`, along with additional stylistic rules that require type information.
+     * @see {@link https://typescript-eslint.io/users/configs#stylistic-type-checked}
+     */
+    stylisticTypeChecked: raw_plugin_1.default.flatConfigs['flat/stylistic-type-checked'],
+    /**
+     * A version of `stylistic` that only contains type-checked rules and disables of any corresponding core ESLint rules.
+     * @see {@link https://typescript-eslint.io/users/configs#stylistic-type-checked-only}
+     */
+    stylisticTypeCheckedOnly: raw_plugin_1.default.flatConfigs['flat/stylistic-type-checked-only'],
+});
+function createConfigsGetters(values) {
+    const configs = {};
+    Object.defineProperties(configs, Object.fromEntries(Object.entries(values).map(([key, value]) => [
+        key,
+        {
+            enumerable: true,
+            get: () => {
+                const candidateRootDir = (0, getTSConfigRootDirFromStack_1.getTSConfigRootDirFromStack)();
+                if (candidateRootDir) {
+                    (0, typescript_estree_1.addCandidateTSConfigRootDir)(candidateRootDir);
+                }
+                return value;
+            },
+        },
+    ])));
+    return configs;
+}
+/*
+we do both a default and named exports to allow people to use this package from
+both CJS and ESM in very natural ways.
+
+EG it means that all of the following are valid:
+
+```ts
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  ...tseslint.configs.recommended,
+);
+```
+```ts
+import { config, parser, plugin } from 'typescript-eslint';
+
+export default config(
+  {
+    languageOptions: { parser }
+    plugins: { ts: plugin },
+  }
+);
+```
+```ts
+const tseslint = require('typescript-eslint');
+
+module.exports = tseslint.config(
+  ...tseslint.configs.recommended,
+);
+```
+```ts
+const { config, parser, plugin } = require('typescript-eslint');
+
+module.exports = config(
+  {
+    languageOptions: { parser }
+    plugins: { ts: plugin },
+  }
+);
+```
+*/
+exports.default = {
+    config: config_helper_1.config,
+    configs: exports.configs,
+    parser: exports.parser,
+    plugin: exports.plugin,
+};
+var config_helper_2 = require("./config-helper");
+// eslint-disable-next-line @typescript-eslint/no-deprecated
+Object.defineProperty(exports, "config", { enumerable: true, get: function () { return config_helper_2.config; } });

node_modules/typescript-eslint/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "typescript-eslint",
+  "version": "8.54.0",
+  "description": "Tooling which enables you to use TypeScript with ESLint",
+  "files": [
+    "dist",
+    "!*.tsbuildinfo",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "engines": {
+    "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/typescript-eslint/typescript-eslint.git",
+    "directory": "packages/typescript-eslint"
+  },
+  "bugs": {
+    "url": "https://github.com/typescript-eslint/typescript-eslint/issues"
+  },
+  "homepage": "https://typescript-eslint.io/packages/typescript-eslint",
+  "license": "MIT",
+  "keywords": [
+    "ast",
+    "ecmascript",
+    "javascript",
+    "typescript",
+    "parser",
+    "syntax",
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin"
+  ],
+  "scripts": {
+    "build": "yarn run -BT nx build",
+    "clean": "rimraf dist/ coverage/",
+    "format": "yarn run -T format",
+    "lint": "yarn run -BT nx lint",
+    "test": "yarn run -BT nx test",
+    "typecheck": "yarn run -BT nx typecheck"
+  },
+  "dependencies": {
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@typescript-eslint/parser": "8.54.0",
+    "@typescript-eslint/typescript-estree": "8.54.0",
+    "@typescript-eslint/utils": "8.54.0"
+  },
+  "peerDependencies": {
+    "eslint": "^8.57.0 || ^9.0.0",
+    "typescript": ">=4.8.4 <6.0.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "*",
+    "rimraf": "*",
+    "typescript": "*",
+    "vitest": "^3.2.4"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/typescript-eslint"
+  },
+  "nx": {
+    "name": "typescript-eslint",
+    "includedScripts": [
+      "clean"
+    ],
+    "targets": {
+      "lint": {
+        "command": "eslint"
+      },
+      "typecheck": {
+        "outputs": [
+          "{workspaceRoot}/dist",
+          "{projectRoot}/dist"
+        ]
+      },
+      "test": {
+        "dependsOn": [
+          "^build",
+          "typecheck"
+        ]
+      }
+    }
+  }
+}