test-inventory 0.5.0 → 0.6.1

package/dist/diagnostics.js

@@ -26,6 +26,7 @@ export const LEVELS = {
     'config-value-unknown': 'warning',
     'file-not-run': 'warning',
     'forbidden-only': 'error',
+    'dependency-not-followed': 'warning',
     'symlink-ignored': 'warning',
     'invalid-import': 'error',
     'globals-not-enabled': 'warning',

package/dist/extract.d.ts

@@ -18,6 +18,10 @@ export interface Scope {
     hookRun: RunSettings;
     /** Fixtures of the hooks in the scope that run around each test. */
     hookFixtures: string[];
+    /** Fixtures of every hook in the scope, `beforeAll` and `afterAll` too, which set up what its tests run. */
+    setupFixtures: string[];
+    /** A hook in the scope takes its fixtures whole, so it may use any. */
+    takesAllFixtures: boolean;
     suite: PendingSuite | null;
 }
 /** Where a test or describe registered through an imported helper is written, in the helper's module. */
@@ -33,6 +37,10 @@ export interface PendingSuite {
     /** For a describe declared in an imported helper, the call in the scanned file that registers it; null otherwise. */
     site: Span | null;
     declaredAt: DeclaredAt | null;
+    /** The file the describe is written in. */
+    frame: Frame;
+    /** The outermost helper call in the scanned file that declares the describe; null when the file declares it. */
+    registeredBy: CallExpression | null;
     /** Where the scanned file registers the describe: its own call, or the outermost helper call that declares it. */
     order: number;
     /** Statements of the tests and describes directly inside, left out of the describe's body hash. */
@@ -48,6 +56,10 @@ export interface PendingTest {
     /** For a test declared in an imported helper, the call in the scanned file that registers it; null otherwise. */
     site: Span | null;
     declaredAt: DeclaredAt | null;
+    /** The file the test is written in. */
+    frame: Frame;
+    /** The outermost helper call in the scanned file that declares the test; null when the file declares it. */
+    registeredBy: CallExpression | null;
     /** Where the scanned file registers the test: its own call, or the outermost helper call that declares it. */
     order: number;
     /** States from the declaration, then from calls in the body such as `test.skip(condition)`. */

package/dist/extract.js

@@ -140,6 +140,8 @@ class Walker {
             hooks: noHooks(),
             hookRun: {},
             hookFixtures: [],
+            setupFixtures: [],
+            takesAllFixtures: false,
             suite: null,
         };
     }
@@ -158,7 +160,7 @@ class Walker {
             helper: null,
             declaredIn: null,
             quiet: false,
-            registeredAt: null,
+            registeredBy: null,
         });
         // Functions defined inside these are deferred in turn; the loop reaches them too, as they are added to the end.
         for (const entry of this.deferred)
@@ -418,6 +420,8 @@ class Walker {
                     context.scope.hooks[api.name] += 1;
                     if (EACH_HOOKS.has(api.name))
                         context.scope.hookFixtures.push(...api.fixtures);
+                    context.scope.setupFixtures.push(...api.fixtures);
+                    context.scope.takesAllFixtures ||= api.takesAllFixtures;
                 }
                 if (api.fn) {
                     if (!call.arguments.includes(api.fn))
@@ -628,7 +632,7 @@ class Walker {
                 ...context,
                 isInFunction: true,
                 declaredIn: null,
-                registeredAt: context.registeredAt ?? call.start,
+                registeredBy: context.registeredBy ?? call,
             });
         });
         this.callStack.pop();
@@ -749,13 +753,16 @@ class Walker {
             mergeRun(call.target.hookRun, settings);
         }
     }
-    /** Counts `expect()`, `expect.soft()` and `expect.poll()`, and reads `expect.assertions(n)` and `expect.hasAssertions()`. */
+    /**
+     * Counts `expect()`, `expect.soft()`, `expect.poll()` and `expect.element()`, and reads `expect.assertions(n)` and
+     * `expect.hasAssertions()`.
+     */
     expectCall(call, test) {
         const callee = unwrap(call.callee);
         const [root, member] = callee.type === 'MemberExpression' ? [unwrap(callee.object), propertyName(callee)] : [callee, 'call'];
         if (root.type !== 'Identifier' || root.name !== 'expect')
             return;
-        if (member === 'call' || member === 'soft' || member === 'poll')
+        if (member === 'call' || member === 'soft' || member === 'poll' || member === 'element')
             test.expectCount += 1;
         if (member === 'hasAssertions')
             test.expectsAssertions = true;
@@ -926,7 +933,9 @@ class Walker {
             call,
             site: this.site,
             declaredAt: this.declaredAt(call),
-            order: context.registeredAt ?? call.start,
+            frame: this.frame,
+            registeredBy: context.registeredBy,
+            order: (context.registeredBy ?? call).start,
             states: [...declaration.states],
             annotations: [...declaration.details.annotations],
             isInLoop: context.isInLoop,
@@ -976,6 +985,8 @@ class Walker {
             hooks: noHooks(),
             hookRun: {},
             hookFixtures: [],
+            setupFixtures: [],
+            takesAllFixtures: false,
             suite: null,
         };
         const suite = {
@@ -984,7 +995,9 @@ class Walker {
             call,
             site: this.site,
             declaredAt: this.declaredAt(call),
-            order: context.registeredAt ?? call.start,
+            frame: this.frame,
+            registeredBy: context.registeredBy,
+            order: (context.registeredBy ?? call).start,
             cuts: [],
             isInCondition: context.isInCondition,
             isInFunction: context.isInFunction,

package/dist/filter.d.ts

@@ -11,6 +11,12 @@ export interface InventoryFilter {
     only?: boolean;
     /** Keeps tests that don't run and give no reason. Tests in a file the runner refuses are left out. */
     withoutReason?: boolean;
+    /**
+     * Keeps the tests a change to one of these files can affect: those whose `dependencies` include it, and those that
+     * reach code the scan can't follow (`hasUnfollowedDependencies`). Paths are from the project root, as
+     * `dependencies` writes them. An empty list keeps only the tests the scan can't follow.
+     */
+    related?: string[];
 }
 /** An inventory whose test records have only `id` and the keys picked with `pickTestFields()`. */
 export type PickedInventory<K extends keyof TestRecord> = Omit<Inventory, 'tests'> & {

package/dist/filter.js

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import { checkObject, OptionsError } from "./options.js";
 import { summarize } from "./summary.js";
 const STATES = ['active', 'skip', 'fixme', 'todo', 'expectedToFail', 'notLoaded'];
@@ -7,11 +8,15 @@ const FILTER_KEYS = [
     'grep',
     'only',
     'withoutReason',
+    'related',
 ];
 // Typed as a record of every key, so a key added to TestRecord fails to compile until it is listed here.
 const TEST_KEYS = Object.keys({
     id: true,
     bodyHash: true,
+    dependencyHash: true,
+    dependencies: true,
+    hasUnfollowedDependencies: true,
     suiteId: true,
     suitePath: true,
     relativeFilePath: true,
@@ -117,11 +122,16 @@ export function matcher(filter) {
     const grep = pattern(checked.grep);
     const only = flag(checked.only, 'filter.only');
     const withoutReason = flag(checked.withoutReason, 'filter.withoutReason');
+    // Written as a shell or Windows may write them, as `./pages/order-ticket.ts` or `pages\\order-ticket.ts`.
+    const related = checked.related === undefined
+        ? null
+        : new Set(list(checked.related, 'filter.related', null).map((file) => path.posix.normalize(file.replaceAll('\\', '/'))));
     return (test) => (states.length === 0 || states.includes(test.state)) &&
         (tags.length === 0 || test.tags.some((tag) => tags.includes(tag))) &&
         (grep === null || grep.test(test.fullName)) &&
         (!only || test.isOnly) &&
-        (!withoutReason || (!test.isActive && !test.isNotLoaded && test.reason === null));
+        (!withoutReason || (!test.isActive && !test.isNotLoaded && test.reason === null)) &&
+        (related === null || test.hasUnfollowedDependencies || test.dependencies.some((file) => related.has(file)));
 }
 /**
  * Keeps the tests that pass every condition of the filter; a list keeps a test that has any of its values. The

package/dist/frameworks/common.d.ts

@@ -116,6 +116,11 @@ export declare function readOptions(file: FileContext, scopes: readonly Node[],
 export declare function unresolvedOptions(file: FileContext, options: Options, result: string): Problem[];
 /** The names a function takes from the object pattern of one of its parameters, in source order. */
 export declare function destructuredNames(fn: FunctionNode | null, index: number | null): string[];
+/**
+ * Whether a function takes one of its parameters whole, as in `(fixtures) => ...`, or keeps the rest of its object
+ * pattern, so that any key of it may be used.
+ */
+export declare function takesWhole(fn: FunctionNode | null, index: number | null): boolean;
 /** A whole number, such as a timeout in milliseconds; null, with a warning, when it can't be worked out. */
 export declare function readCount(file: FileContext, name: string, option: OptionValue, problems: Problem[]): number | null;
 /** A warning for one option whose value could not be worked out. */

package/dist/frameworks/common.js

@@ -287,6 +287,17 @@ export function destructuredNames(fn, index) {
     const names = parameter.properties.map((property) => (property.type === 'Property' ? propertyKey(property) : null));
     return names.filter((name) => name !== null);
 }
+/**
+ * Whether a function takes one of its parameters whole, as in `(fixtures) => ...`, or keeps the rest of its object
+ * pattern, so that any key of it may be used.
+ */
+export function takesWhole(fn, index) {
+    const parameter = index === null ? undefined : fn?.params[index];
+    if (!parameter)
+        return false;
+    return (parameter.type !== 'ObjectPattern' ||
+        parameter.properties.some((property) => property.type === 'RestElement' || property.computed));
+}
 /** A whole number, such as a timeout in milliseconds; null, with a warning, when it can't be worked out. */
 export function readCount(file, name, option, problems) {
     const { node, resolved } = option;

package/dist/frameworks/playwright.js

@@ -1,7 +1,7 @@
 import { childNodes, isFunctionNode, propertyKey, propertyName, unwrap } from "../ast.js";
 import { snippet } from "../source.js";
 import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, ModuleFunctions, requiredModule, } from "./bindings.js";
-import { atLeast, findFunction, hookFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, destructuredNames, readCondition, readCount, readOptions, readReason, readStrings, readTitle, refused, returnedFunction, returnedTestObject, text, unresolvedOption, unresolvedOptions, } from "./common.js";
+import { atLeast, findFunction, hookFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, destructuredNames, takesWhole, readCondition, readCount, readOptions, readReason, readStrings, readTitle, refused, returnedFunction, returnedTestObject, text, unresolvedOption, unresolvedOptions, } from "./common.js";
 const MISMATCHED_SOURCES = new Set(['vitest', '@jest/globals']);
 // Maps rather than object literals, so names such as `constructor` don't match inherited properties.
 const DESCRIBES = new Map([
@@ -259,7 +259,14 @@ export class PlaywrightAdapter {
             return this.configure(call, context);
         if (HOOKS.has(key)) {
             const fn = hookFunction(this.file, context.scopes, call.arguments);
-            return { kind: 'hook', name: key, fn, testContext: null, fixtures: destructuredNames(fn, 0) };
+            return {
+                kind: 'hook',
+                name: key,
+                fn,
+                testContext: null,
+                fixtures: destructuredNames(fn, 0),
+                takesAllFixtures: takesWhole(fn, 0),
+            };
         }
         if (RUN_MEMBERS.has(key))
             return this.runSetting(call, key, context);
@@ -475,6 +482,7 @@ export class PlaywrightAdapter {
             caseCount: null,
             testContext: null,
             fixtures: destructuredNames(hashed, 0),
+            takesAllFixtures: takesWhole(hashed, 0),
             usesBench: false,
             problems,
         };

package/dist/frameworks/vitest.d.ts

@@ -75,7 +75,7 @@ export declare class VitestAdapter implements Adapter {
     /** Vitest's order: `only` wins over `skip`, which wins over `todo`. */
     private states;
     private readDeclarationOptions;
-    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`; the runner ignores an object before. */
+    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`. */
     private retry;
     private meta;
     private caseCount;

package/dist/frameworks/vitest.js

@@ -1,7 +1,7 @@
 import { childNodes, isFunctionNode, isImportMetaVitest, propertyKey, propertyName, unwrap, } from "../ast.js";
 import { snippet } from "../source.js";
 import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, ModuleFunctions, requiredModule, } from "./bindings.js";
-import { atLeast, hookFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, destructuredNames, readCount, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, refused, text, } from "./common.js";
+import { atLeast, hookFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, destructuredNames, takesWhole, readCount, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, refused, text, } from "./common.js";
 /** What a test function chosen at run time, as in `isCI ? it.skip : it`, is either way: only the links both have. */
 function shared(a, b) {
     if (!a || a.kind !== b?.kind)
@@ -27,6 +27,7 @@ const MODIFIERS = {
 };
 const TABLES = new Set(['each', 'for']);
 const CONDITIONS = new Set(['skipIf', 'runIf']);
+const STATE_FLAGS = ['only', 'todo', 'fails'];
 const DERIVATIONS = new Set(['extend', 'override', 'scoped']);
 /** Hooks, with the position of the test context among their callback's parameters. */
 const HOOKS = new Map([
@@ -528,6 +529,7 @@ export class VitestAdapter {
             fn,
             testContext: index === null ? null : contextNames(fn, index),
             fixtures: fixturesOf(fn, index, this.file.version),
+            takesAllFixtures: takesWhole(fn, index),
         };
     }
     contextSkip(call, context) {
@@ -633,6 +635,17 @@ export class VitestAdapter {
         const chain = new Set(links.filter((link) => MODIFIERS[kind].has(link.name)).map((link) => link.name));
         const flags = new Set(chain);
         let conditions = links.filter((link) => CONDITIONS.has(link.name)).map((link) => this.linkCondition(link, context));
+        // From Vitest 5.0.5 a test's `skip`, `skipIf` and `runIf` each set its `skip`, so the last of them decides, and a
+        // `skipIf` or `runIf` replaces the skip of a tag or of a describe around. The scan applies that to all of Vitest 5.
+        const lastSkip = links.filter((link) => link.name === 'skip' || CONDITIONS.has(link.name)).at(-1);
+        const skipsByChain = kind === 'test' && lastSkip !== undefined && atLeast(this.file.version, 5, 0);
+        const conditionSetsSkip = skipsByChain && CONDITIONS.has(lastSkip.name);
+        if (skipsByChain) {
+            flags.delete('skip');
+            conditions = conditionSetsSkip ? [this.linkCondition(lastSkip, context)] : [];
+            if (!conditionSetsSkip)
+                flags.add('skip');
+        }
         // A test's own options win over its chain, so `test.skip('title', { skip: false }, fn)` runs. The chain wins for a
         // test's mode, and for everything on a describe.
         for (const [flag, value] of read.flags) {
@@ -652,7 +665,7 @@ export class VitestAdapter {
         // win. A `skip` passed down skips them, and turns todo into skip, as skip goes before todo.
         const line = this.file.source.line(call.start);
         const around = context.passedDown;
-        const passed = read.skip ? null : around;
+        const passed = read.skip || conditionSetsSkip ? null : around;
         const skips = passed?.condition.applies === 'always' && !flags.has('only');
         const table = links.find((link) => TABLES.has(link.name)) ?? null;
         const isTodo = flags.has('todo') || body === undefined;
@@ -701,7 +714,12 @@ export class VitestAdapter {
                 ...base,
                 testContext: contextNames(base.hashed, index),
                 fixtures: fixturesOf(base.hashed, index, this.file.version),
+                takesAllFixtures: takesWhole(base.hashed, index),
                 usesBench: atLeast(this.file.version, 5, 0) && destructuredNames(base.hashed, index).includes('bench'),
+                ownStateOptions: [
+                    ...(read.skip || conditionSetsSkip ? ['skip'] : []),
+                    ...STATE_FLAGS.filter((flag) => read.flags.has(flag)),
+                ],
             };
         }
         return refusal ? refused(call, refusal, context, () => declared) : declared;
@@ -761,8 +779,14 @@ export class VitestAdapter {
             return result;
         const options = readOptions(this.file, context.scopes, node);
         problems.push(...unresolvedOptions(this.file, options, 'its flags, tags and meta are missing'));
+        // From Vitest 5.0.5 an option set to `undefined` replaces nothing; the scan applies that to all of Vitest 5.
+        const given = (key) => {
+            const option = options.values.get(key);
+            const isUndefined = option?.resolved.ok === true && option.resolved.value === undefined;
+            return isUndefined && atLeast(this.file.version, 5, 0) ? undefined : option;
+        };
         for (const flag of ['only', 'todo', 'fails', 'concurrent', 'sequential', 'shuffle']) {
-            const option = options.values.get(flag);
+            const option = given(flag);
             if (option && !option.resolved.ok) {
                 const { importedFrom } = option.resolved;
                 problems.push(unresolvedOption(this.file, flag, option.node, importedFrom, 'it is not applied'));
@@ -774,7 +798,7 @@ export class VitestAdapter {
                 result.flags.set(flag, Boolean(option.resolved.value));
             }
         }
-        const skip = options.values.get('skip');
+        const skip = given('skip');
         if (skip) {
             result.skip = skip.resolved.ok
                 ? { applies: skip.resolved.value ? 'always' : 'never', text: null }
@@ -804,7 +828,7 @@ export class VitestAdapter {
             this.retry(retry, details, context, problems);
         return result;
     }
-    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`; the runner ignores an object before. */
+    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`. */
     retry(option, details, context, problems) {
         const node = unwrap(option.node);
         if (node.type !== 'ObjectExpression') {
@@ -813,8 +837,14 @@ export class VitestAdapter {
                 details.run.retry = { count, delay: null, condition: null };
             return;
         }
-        if (!atLeast(this.file.version, 4, 1))
+        if (!atLeast(this.file.version, 4, 1)) {
+            // Before 4.1 the runner compares the attempt number with the object, so it never runs the test.
+            const source = snippet(text(this.file, node));
+            const message = `Option retry: ${source} is an object, which Vitest reads from 4.1; before, it never runs the test.`;
+            problems.push(problem('unresolved-option', node, message, source));
+            details.run.retry = null;
             return;
+        }
         const values = readOptions(this.file, context.scopes, node);
         problems.push(...unresolvedOptions(this.file, values, 'the retry is not applied'));
         const read = (key) => {

package/dist/hash.d.ts

@@ -1,6 +1,6 @@
 import type { Node } from 'oxc-parser';
 import type { Span } from './model.ts';
-export declare function shortHash(input: string): string;
+export declare function shortHash(input: string | Uint8Array): string;
 /**
  * Hashes code by its syntax tree, so formatting, comments, quote style, trailing commas and line endings don't change
  * the hash. Nodes at the `cut` spans, such as the tests inside a describe, are left out. Returns null when no code is

package/dist/model.d.ts

@@ -2,6 +2,8 @@ import type { CallExpression, Expression, Node } from 'oxc-parser';
 import type { FunctionNode } from './ast.ts';
 import type { Annotation, DiagnosticCode, DiagnosticLevel, HookCounts, MetaValue } from './types.ts';
 export type State = 'skip' | 'fixme' | 'todo' | 'expectedToFail';
+/** The Vitest options that set a test's state. */
+export type StateOption = 'skip' | 'only' | 'todo' | 'fails';
 export type Mode = 'parallel' | 'serial' | 'default';
 /** A state set by a declaration, a describe or a call such as `test.skip(condition)`. */
 export interface StateSetting {
@@ -51,12 +53,15 @@ export interface Details {
 /** Run settings written in one place; a key that is missing is not set there. */
 export interface RunSettings {
     timeout?: number;
-    /** A retry setting replaces the whole `retry` of the describes around, delay and condition included. */
+    /**
+     * A retry setting replaces the whole `retry` of the describes around, delay and condition included; null when it is
+     * set to a value the runner can't use.
+     */
     retry?: {
         count: number;
         delay: number | null;
         condition: string | null;
-    };
+    } | null;
     repeats?: number;
     /** Playwright `test.slow()`: the conditions of the calls, any of which makes the test slow; null when one always does. */
     slow?: {
@@ -86,8 +91,12 @@ export interface TestDeclaration extends Declaration {
     testContext: unknown;
     /** Names the test function takes from its context, without the framework's own keys. */
     fixtures: string[];
+    /** The test function takes its fixtures whole, or keeps the rest of them, so it may use any. */
+    takesAllFixtures: boolean;
     /** Uses Vitest 5's `bench` fixture. */
     usesBench: boolean;
+    /** Vitest: the state options the test sets itself, to `false` too, which replace those of its tags. */
+    ownStateOptions?: StateOption[];
 }
 export interface SuiteDeclaration extends Declaration {
     kind: 'describe';
@@ -128,6 +137,7 @@ export type ApiCall = TestDeclaration | SuiteDeclaration | {
     fn: FunctionNode | null;
     testContext: unknown;
     fixtures: string[];
+    takesAllFixtures: boolean;
 }
 /** Playwright `test.step()` or `test.step.skip()`. */
  | {
@@ -183,6 +193,8 @@ export interface Returns {
 /** A module read to see whether it exports a custom `test` object. */
 export interface ModuleSource {
     code: string;
+    /** The file's bytes when it isn't UTF-8 text, such as an image. */
+    bytes?: Uint8Array;
     relativeFilePath: string;
     /** Reads the modules this module imports in turn. */
     readModule: ModuleReader;

package/dist/parse.d.ts

@@ -15,6 +15,12 @@ export interface ParsedFile {
         end: number;
     } | null;
 }
+/**
+ * The offset of the first bracket nested more than `limit` deep, or null. Parentheses, brackets, braces and template
+ * substitutions count; strings, comments, regular expressions and template text are skipped. A closing bracket closes
+ * up to the one it matches, so a literal read wrongly unbalances only the brackets around it.
+ */
+export declare function tooDeeplyNested(text: string, limit: number): number | null;
 /** The first parser error, located at its first label, or at the start of the file when it has none. */
 export declare function firstError(errors: readonly OxcError[]): ParsedFile['error'];
 export declare function parseFile(fileName: string, code: string): ParsedFile;

package/dist/parse.js

@@ -7,6 +7,200 @@ function parserOptions(fileName) {
     const sourceType = extension.startsWith('.c') ? 'commonjs' : extension.startsWith('.m') ? 'module' : 'unambiguous';
     return { lang, sourceType, preserveParens: false };
 }
+/**
+ * How deep brackets may nest. oxc-parser recurses on the native stack, which no catch can stop: brackets about 2,400
+ * deep crash a worker thread's 4 MB stack and 4,800 the main thread's 8 MB. Of the 10,000 files in this package's
+ * development dependencies, minified bundles included, the deepest nests 34.
+ */
+const MAX_NESTING = 500;
+/** Words after which a `/` starts a regular expression rather than a division. */
+const BEFORE_REGEX = new Set([
+    'return',
+    'typeof',
+    'instanceof',
+    'in',
+    'of',
+    'new',
+    'delete',
+    'void',
+    'throw',
+    'case',
+    'do',
+    'else',
+    'yield',
+    'await',
+]);
+const Char = {
+    Tab: 9,
+    LineFeed: 10,
+    CarriageReturn: 13,
+    Space: 32,
+    DoubleQuote: 34,
+    Dollar: 36,
+    SingleQuote: 39,
+    OpenParen: 40,
+    CloseParen: 41,
+    Star: 42,
+    Slash: 47,
+    LessThan: 60,
+    GreaterThan: 62,
+    OpenBracket: 91,
+    Backslash: 92,
+    CloseBracket: 93,
+    Backtick: 96,
+    OpenBrace: 123,
+    CloseBrace: 125,
+};
+/** Letters, digits, `_`, `$` and anything outside ASCII, as identifiers and numbers use. */
+function isWordChar(code) {
+    return ((code >= 97 && code <= 122) ||
+        (code >= 65 && code <= 90) ||
+        (code >= 48 && code <= 57) ||
+        code === 95 ||
+        code === Char.Dollar ||
+        code > 127);
+}
+/** Whether the code right before `end` is a word after which a `/` starts a regular expression. */
+function afterKeyword(text, end) {
+    let wordEnd = end;
+    while (wordEnd > 0 && /\s/.test(text[wordEnd - 1]))
+        wordEnd--;
+    let wordStart = wordEnd;
+    while (wordStart > 0 && isWordChar(text.charCodeAt(wordStart - 1)))
+        wordStart--;
+    return BEFORE_REGEX.has(text.slice(wordStart, wordEnd));
+}
+/**
+ * Whether the slash at `at` ends a JSX tag, as in `</ul>` or `<OrderLeg leg={leg} />`, where a regular expression
+ * could otherwise start and run on over the brackets after it.
+ */
+function endsJsxTag(text, at) {
+    if (text.charCodeAt(at - 1) === Char.LessThan)
+        return true;
+    if (text.charCodeAt(at + 1) !== Char.GreaterThan)
+        return false;
+    let before = at - 1;
+    while (before > 0 && /\s/.test(text[before]))
+        before--;
+    return text.charCodeAt(before) === Char.CloseBrace;
+}
+/**
+ * The offset of the first bracket nested more than `limit` deep, or null. Parentheses, brackets, braces and template
+ * substitutions count; strings, comments, regular expressions and template text are skipped. A closing bracket closes
+ * up to the one it matches, so a literal read wrongly unbalances only the brackets around it.
+ */
+export function tooDeeplyNested(text, limit) {
+    // Open brackets by their character; a substitution is kept as its backtick.
+    const open = [];
+    const counts = new Uint32Array(128);
+    let regexAllowed = true;
+    let index = 0;
+    const push = (code) => {
+        open.push(code);
+        counts[code]++;
+        return open.length > limit;
+    };
+    // Reads template text up to its end or a substitution; true when the substitution is one too deep.
+    const templateText = () => {
+        while (index < text.length) {
+            const code = text.charCodeAt(index);
+            if (code === Char.Backslash)
+                index += 2;
+            else if (code === Char.Backtick) {
+                index++;
+                regexAllowed = false;
+                return false;
+            }
+            else if (code === Char.Dollar && text.charCodeAt(index + 1) === Char.OpenBrace) {
+                if (push(Char.Backtick))
+                    return true;
+                index += 2;
+                regexAllowed = true;
+                return false;
+            }
+            else
+                index++;
+        }
+        return false;
+    };
+    // Skips a string or regular expression; neither goes past the end of the line.
+    const literal = (end) => {
+        let inClass = false;
+        while (index < text.length) {
+            const code = text.charCodeAt(index);
+            if (code === Char.LineFeed)
+                return;
+            index += code === Char.Backslash ? 2 : 1;
+            if (end === Char.Slash && code === Char.OpenBracket)
+                inClass = true;
+            else if (code === Char.CloseBracket)
+                inClass = false;
+            else if (code === end && !inClass)
+                return;
+        }
+    };
+    while (index < text.length) {
+        const code = text.charCodeAt(index);
+        const next = text.charCodeAt(index + 1);
+        const start = index;
+        if (code === Char.Space || code === Char.LineFeed || code === Char.Tab || code === Char.CarriageReturn) {
+            index++;
+        }
+        else if (code === Char.Slash && next === Char.Slash) {
+            const end = text.indexOf('\n', index);
+            index = end === -1 ? text.length : end;
+        }
+        else if (code === Char.Slash && next === Char.Star) {
+            const end = text.indexOf('*/', index + 2);
+            index = end === -1 ? text.length : end + 2;
+        }
+        else if (code === Char.SingleQuote ||
+            code === Char.DoubleQuote ||
+            (code === Char.Slash && (regexAllowed || afterKeyword(text, start)) && !endsJsxTag(text, start))) {
+            index++;
+            literal(code);
+            regexAllowed = false;
+        }
+        else if (code === Char.Backtick) {
+            index++;
+            if (templateText())
+                return index;
+        }
+        else if (isWordChar(code)) {
+            while (index < text.length && isWordChar(text.charCodeAt(index)))
+                index++;
+            regexAllowed = false;
+        }
+        else if (code === Char.OpenParen || code === Char.OpenBracket || code === Char.OpenBrace) {
+            if (push(code))
+                return start;
+            index++;
+            regexAllowed = true;
+        }
+        else if (code === Char.CloseParen || code === Char.CloseBracket || code === Char.CloseBrace) {
+            index++;
+            // A block can end right before a regular expression; a value in parentheses or brackets is divided.
+            regexAllowed = code === Char.CloseBrace;
+            const opener = code === Char.CloseParen ? Char.OpenParen : code === Char.CloseBracket ? Char.OpenBracket : Char.OpenBrace;
+            const closesSubstitution = code === Char.CloseBrace && counts[Char.Backtick] !== 0;
+            if (counts[opener] === 0 && !closesSubstitution)
+                continue;
+            let closed;
+            do {
+                closed = open.pop();
+                counts[closed]--;
+            } while (closed !== opener && !(closed === Char.Backtick && code === Char.CloseBrace));
+            // A substitution after this one is as deep as the one it closed, so it is never the first too deep.
+            if (closed === Char.Backtick)
+                templateText();
+        }
+        else {
+            index++;
+            regexAllowed = true;
+        }
+    }
+    return null;
+}
 /** The first parser error, located at its first label, or at the start of the file when it has none. */
 export function firstError(errors) {
     const first = errors.at(0);
@@ -18,6 +212,16 @@ export function firstError(errors) {
 export function parseFile(fileName, code) {
     // A byte order mark is not part of the code, and editors don't count it as a column.
     const text = code.charCodeAt(0) === 0xfeff ? code.slice(1) : code;
+    const tooDeep = tooDeeplyNested(text, MAX_NESTING);
+    if (tooDeep !== null) {
+        const message = `Brackets are nested more than ${MAX_NESTING} deep, too deep to parse safely`;
+        return {
+            source: new SourceText(text),
+            program: parseSync(fileName, '', parserOptions(fileName)).program,
+            comments: [],
+            error: { message, start: tooDeep, end: tooDeep + 1 },
+        };
+    }
     const result = parseSync(fileName, text, parserOptions(fileName));
     return {
         source: new SourceText(text),