test-inventory 0.7.0 → 0.9.0

package/dist/resolve.js

@@ -272,39 +272,35 @@ function pnpmWorkspacePatterns(text) {
     }
     return patterns;
 }
-/** The folder of each package in the workspace a folder belongs to, by name; empty outside a workspace. */
-function workspacePackages(directory) {
-    for (let folder = directory;; folder = path.dirname(folder)) {
-        const workspaces = readJson(path.join(folder, 'package.json'))?.workspaces;
-        const fromManifest = Array.isArray(workspaces) ? workspaces : record(workspaces)?.packages;
-        const pnpm = readText(path.join(folder, 'pnpm-workspace.yaml'));
-        // pnpm reads only pnpm-workspace.yaml, and npm, Yarn and Bun only package.json, so a repository that moved to
-        // pnpm may still have an old list there. Packages from both are found.
-        const lists = [Array.isArray(fromManifest) ? fromManifest : null, pnpm ? pnpmWorkspacePatterns(pnpm) : null];
-        const patterns = lists.some((list) => list !== null)
-            ? lists.flat().filter((item) => typeof item === 'string')
-            : null;
-        if (patterns) {
-            // Packages are inside the workspace. A pattern or a link that leads out of its folder could send the search through
-            // the whole disk, so neither is followed.
-            const inside = patterns.filter((item) => !path.isAbsolute(item.replace(/^!/, '')) && !/(^|\/)\.\.(\/|$)/.test(item));
-            const manifests = globSync(inside.filter((item) => !item.startsWith('!')).map((item) => `${item.replace(/\/+$/, '')}/package.json`), {
-                cwd: folder,
-                absolute: true,
-                followSymbolicLinks: false,
-                ignore: ['**/node_modules/**', ...inside.filter((item) => item.startsWith('!')).map((item) => item.slice(1))],
-            });
-            const packages = new Map();
-            for (const manifest of manifests) {
-                const name = readJson(manifest)?.name;
-                if (typeof name === 'string')
-                    packages.set(name, path.dirname(manifest));
-            }
-            return packages;
-        }
-        if (path.dirname(folder) === folder)
-            return new Map();
+/** The folder of each package of the workspace a folder is the root of, by name; null when it isn't one. */
+function workspaceAt(folder) {
+    const workspaces = readJson(path.join(folder, 'package.json'))?.workspaces;
+    const fromManifest = Array.isArray(workspaces) ? workspaces : record(workspaces)?.packages;
+    const pnpm = readText(path.join(folder, 'pnpm-workspace.yaml'));
+    // pnpm reads only pnpm-workspace.yaml, and npm, Yarn and Bun only package.json, so a repository that moved to
+    // pnpm may still have an old list there. Packages from both are found.
+    const lists = [Array.isArray(fromManifest) ? fromManifest : null, pnpm ? pnpmWorkspacePatterns(pnpm) : null];
+    const patterns = lists.some((list) => list !== null)
+        ? lists.flat().filter((item) => typeof item === 'string')
+        : null;
+    if (!patterns)
+        return null;
+    // Packages are inside the workspace. A pattern or a link that leads out of its folder could send the search through
+    // the whole disk, so neither is followed.
+    const inside = patterns.filter((item) => !path.isAbsolute(item.replace(/^!/, '')) && !/(^|\/)\.\.(\/|$)/.test(item));
+    const manifests = globSync(inside.filter((item) => !item.startsWith('!')).map((item) => `${item.replace(/\/+$/, '')}/package.json`), {
+        cwd: folder,
+        absolute: true,
+        followSymbolicLinks: false,
+        ignore: ['**/node_modules/**', ...inside.filter((item) => item.startsWith('!')).map((item) => item.slice(1))],
+    });
+    const packages = new Map();
+    for (const manifest of manifests) {
+        const name = readJson(manifest)?.name;
+        if (typeof name === 'string')
+            packages.set(name, path.dirname(manifest));
     }
+    return packages;
 }
 /**
  * A workspace package followed to its TypeScript source: through its link in node_modules, or, before an install, from
@@ -327,13 +323,34 @@ function workspaceSource(specifier, directory, packagesOf) {
     const local = packagesOf(directory).get(name);
     return local ? packageEntry(local, subpath) : null;
 }
+/** A file a bare name stands for in the folders an import map adds; null when none has it. */
+function searched(specifier, directory, map) {
+    const folders = [...map.paths];
+    for (let folder = directory;; folder = path.dirname(folder)) {
+        folders.push(...map.directories.map((name) => path.join(folder, name)));
+        if (path.dirname(folder) === folder)
+            break;
+    }
+    return folders.map((folder) => findFile(path.join(folder, specifier))).find((file) => file !== null) ?? null;
+}
+/** The names an alias maps a specifier to; null when it doesn't match. */
+function mapped(specifier, alias) {
+    const { find, replacements } = alias;
+    if (typeof find === 'string') {
+        if (specifier !== find && !specifier.startsWith(`${find}/`))
+            return null;
+        return replacements.map((replacement) => replacement + specifier.slice(find.length));
+    }
+    return find.test(specifier) ? replacements.map((replacement) => specifier.replace(find, replacement)) : null;
+}
 /**
- * Returns a reader for the modules a test file imports. It follows relative paths, tsconfig `paths` and `baseUrl` from
- * the tsconfig nearest the importing file, package.json `imports` (`#name`), and workspace packages whose entry is
- * TypeScript source. Each module it reads carries a reader for the modules that module imports in turn.
+ * Returns a reader for the modules a test file imports. It follows the import map of the config the file runs with,
+ * relative paths, tsconfig `paths` and `baseUrl` from the tsconfig nearest the importing file, package.json `imports`
+ * (`#name`), and workspace packages whose entry is TypeScript source. Each module it reads carries a reader for the
+ * modules that module imports in turn, with the same import map.
  */
 export function moduleResolver(root) {
-    // Many test files import the same fixtures file and share a tsconfig; each is read once.
+    // Many test files import the same fixtures file and share a tsconfig; each is read once per import map.
     const modules = new Map();
     const tsconfigs = new Map();
     const pathOptions = new Map();
@@ -351,19 +368,26 @@ export function moduleResolver(root) {
         }
         return options;
     };
+    // The packages of the workspace a folder belongs to, empty outside one; each folder on the way up is looked at once.
     const packagesOf = (directory) => {
-        let packages = workspaces.get(directory);
-        if (!packages) {
-            packages = workspacePackages(directory);
-            workspaces.set(directory, packages);
+        const passed = [];
+        let packages;
+        for (let folder = directory; !packages; folder = path.dirname(folder)) {
+            packages = workspaces.get(folder);
+            if (packages)
+                break;
+            passed.push(folder);
+            packages = workspaceAt(folder) ?? (path.dirname(folder) === folder ? new Map() : null);
         }
+        for (const folder of passed)
+            workspaces.set(folder, packages);
         return packages;
     };
-    const reader = (fromFile) => (specifier) => {
-        const directory = path.dirname(fromFile);
+    /** The file a name stands for from a folder, or why it can't be followed. */
+    const locate = (specifier, directory, map) => {
         let candidates;
         // `.` and `..` are paths too: the index of the file's folder, or of the folder above.
-        if (/^\.\.?(?:\/|$)/.test(specifier)) {
+        if (/^\.\.?(?:\/|$)/.test(specifier) || path.isAbsolute(specifier)) {
             candidates = [path.resolve(directory, specifier)];
         }
         else if (specifier.startsWith('#')) {
@@ -385,29 +409,44 @@ export function moduleResolver(root) {
                 const workspace = fromBaseUrl ? null : workspaceSource(specifier, directory, packagesOf);
                 if (workspace && 'reason' in workspace)
                     return workspace;
-                const file = fromBaseUrl ?? workspace?.file;
+                const file = fromBaseUrl ?? workspace?.file ?? (map && searched(specifier, directory, map));
                 // No package name starts with `@/` or `~/`, so these are aliases, as Vite's `resolve.alias` sets them; any
                 // other name with no file may still be a package or a built-in module, as TypeScript takes it to be.
                 if (!file && /^[@~]\//.test(specifier)) {
-                    return { reason: targets ? 'could not be read' : 'is a path alias that no tsconfig paths define' };
+                    return { reason: targets ? 'could not be read' : 'is a path alias that no tsconfig paths or config define' };
                 }
                 if (!file)
                     return { reason: 'is not a local file, a path alias or a workspace package' };
                 candidates = [file];
             }
         }
-        const found = candidates.map(findFile).find((file) => file !== null);
-        if (!found)
-            return { reason: 'could not be read' };
-        if (!modules.has(found)) {
+        return candidates.map(findFile).find((file) => file !== null) ?? { reason: 'could not be read' };
+    };
+    const reader = (fromFile, map = null) => (specifier) => {
+        const directory = path.dirname(fromFile);
+        const aliased = map?.aliases.map((alias) => mapped(specifier, alias)).find((names) => names !== null);
+        // The config maps the name to others, each a path or a name looked up as written, the first that is found.
+        const located = (aliased ?? [specifier]).map((name) => locate(name, directory, map));
+        const found = located.find((item) => typeof item === 'string');
+        if (found === undefined) {
+            return aliased
+                ? { reason: `is mapped by the config to ${aliased.join(' or ')}, which could not be read` }
+                : located[0];
+        }
+        let known = modules.get(map);
+        if (!known) {
+            known = new Map();
+            modules.set(map, known);
+        }
+        if (!known.has(found)) {
             const content = readContent(found);
-            modules.set(found, content && {
+            known.set(found, content && {
                 ...content,
                 relativeFilePath: path.relative(root, found).replaceAll('\\', '/'),
-                readModule: reader(found),
+                readModule: reader(found, map),
             });
         }
-        return modules.get(found) ?? { reason: 'could not be read' };
+        return known.get(found) ?? { reason: 'could not be read' };
     };
     return reader;
 }

package/dist/scan-file.d.ts

@@ -1,6 +1,8 @@
 import type { RunsWith } from './config-dependencies.ts';
 import { DependencyGraph, type SnapshotFiles } from './dependency-hash.ts';
 import { ExportedValues } from './imported-values.ts';
+import { type MochaInterface } from './frameworks/mocha.ts';
+import { type WebdriverIOFramework } from './frameworks/webdriverio.ts';
 import type { ModuleReader } from './model.ts';
 import { type CommentsMode, type FileConfig, type FileRecords } from './records.ts';
 import type { Framework } from './types.ts';
@@ -18,6 +20,12 @@ export interface FileSettings {
     isBenchmarkFile?: boolean | null;
     /** What the config the file uses sets for its tests; null without a config. */
     config?: FileConfig | null;
+    /** The interface Mocha's config sets for the tests: `describe` and `it`, or `suite` and `test`. */
+    mochaInterface?: MochaInterface;
+    /** The length Vitest's config shortens a value in a case title to; Vitest's default, 40, when unset. */
+    titleTruncate?: number;
+    /** The framework a WebdriverIO config runs the specs with. */
+    webdriverioFramework?: WebdriverIOFramework;
     /** Shared by the files of one scan, so that code many tests reach is read once. */
     graph?: DependencyGraph;
     /** Shared by the files of one scan, so that each module's exported values are worked out once. */

package/dist/scan-file.js

@@ -6,19 +6,37 @@ import { ExportedValues } from "./imported-values.js";
 import { atLeast, problem } from "./frameworks/common.js";
 import { PlaywrightAdapter } from "./frameworks/playwright.js";
 import { VitestAdapter } from "./frameworks/vitest.js";
+import { JestAdapter } from "./frameworks/jest.js";
+import { MochaAdapter } from "./frameworks/mocha.js";
+import { BunAdapter } from "./frameworks/bun.js";
+import { CypressAdapter } from "./frameworks/cypress.js";
+import { NodeAdapter } from "./frameworks/node.js";
+import { WebdriverIOJasmineAdapter, WebdriverIOMochaAdapter, } from "./frameworks/webdriverio.js";
+import { JasmineAdapter } from "./frameworks/jasmine.js";
 import { parseFile } from "./parse.js";
 import { buildRecords, fileRecord } from "./records.js";
 import { snippet } from "./source.js";
 import { Values } from "./values.js";
 const TYPE_TEST = /\.(test|spec)-d\.[cm]?[jt]sx?$/;
 const BENCHMARK = /\.(bench|benchmark)\.[cm]?[jt]sx?$/;
+const ADAPTERS = {
+    playwright: (parsed, file, readModule) => new PlaywrightAdapter(parsed.program, file, readModule),
+    vitest: (parsed, file, readModule, settings) => new VitestAdapter(parsed, file, readModule, settings.titleTruncate),
+    jest: (parsed, file, readModule) => new JestAdapter(parsed, file, readModule),
+    mocha: (parsed, file, readModule, settings) => new MochaAdapter(parsed, file, readModule, settings.mochaInterface),
+    jasmine: (parsed, file, readModule) => new JasmineAdapter(parsed, file, readModule),
+    cypress: (parsed, file, readModule) => new CypressAdapter(parsed, file, readModule),
+    webdriverio: (parsed, file, readModule, settings) => settings.webdriverioFramework === 'jasmine'
+        ? new WebdriverIOJasmineAdapter(parsed, file, readModule)
+        : new WebdriverIOMochaAdapter(parsed, file, readModule, settings.mochaInterface),
+    node: (parsed, file, readModule) => new NodeAdapter(parsed, file, readModule),
+    bun: (parsed, file, readModule) => new BunAdapter(parsed, file, readModule),
+};
 /** A file read for the scan: the scanned file, or a module a helper function is imported from. */
 function frame(parsed, relativeFilePath, settings, readModule, exports) {
     const values = new Values(exports.reader(readModule));
     const file = { source: parsed.source, values, version: settings.version };
-    const adapter = settings.framework === 'playwright'
-        ? new PlaywrightAdapter(parsed.program, file, readModule)
-        : new VitestAdapter(parsed, file, readModule);
+    const adapter = ADAPTERS[settings.framework](parsed, file, readModule, settings);
     return { parsed, adapter, values: file.values, readModule, relativeFilePath };
 }
 /** The records of a file the scan read no tests from. */

package/dist/scan.js

@@ -3,32 +3,38 @@ import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { glob } from 'tinyglobby';
 import { ConfigDependencies } from "./config-dependencies.js";
-import { ConfigRuns, fileConfig } from "./config-runs.js";
-import { Configs } from "./config.js";
+import { ConfigRuns, fileConfig, importMap, mochaInterface, webdriverioFramework, webdriverioInterface, } from "./config-runs.js";
+import { Configs, settingAt } from "./config.js";
+import { atLeast } from "./frameworks/common.js";
 import { DependencyGraph } from "./dependency-hash.js";
 import { ExportedValues } from "./imported-values.js";
 import { fileDiagnostic } from "./diagnostics.js";
 import { findFiles, normalizePattern, readFailure } from "./files.js";
-import { detectFrameworkVersion, OLDEST } from "./framework-version.js";
+import { detectFramework, detectFrameworkVersion, FRAMEWORK_NAMES, OLDEST } from "./framework-version.js";
 import { createInventory } from "./inventory.js";
-import { checkComments, checkFlag, checkFramework, checkObject, checkStrings, checkVersion, invalid, majorMinor, toPosixPath, } from "./options.js";
+import { checkComments, checkFlag, checkFramework, checkObject, checkSignal, checkStrings, checkVersion, invalid, majorMinor, toPosixPath, } from "./options.js";
 import { moduleResolver } from "./resolve.js";
 import { noRecords, scanFile } from "./scan-file.js";
 import { globalsCheck } from "./vitest-config.js";
 function versionDiagnostics(framework, version, source, range) {
-    const name = framework === 'playwright' ? 'Playwright' : 'Vitest';
+    const name = FRAMEWORK_NAMES[framework];
     if (version === null) {
         return [
             fileDiagnostic('unknown-framework-version', source, `The ${name} version could not be read from the project, so the rules of the newest supported version apply.`),
         ];
     }
     const [major, minor] = majorMinor(version);
-    const [oldestMajor, oldestMinor] = OLDEST[framework];
+    const patch = Number(/^v?\d+\.\d+\.(\d+)/.exec(version)?.[1] ?? 0);
+    const [oldestMajor, oldestMinor, oldestPatch = 0] = OLDEST[framework];
+    const oldest = OLDEST[framework].join('.');
     // A range gets the newest rules of its major, so only its major has to be supported.
-    const tooOld = major < oldestMajor || (major === oldestMajor && minor < oldestMinor && range === null);
+    const tooOld = major < oldestMajor ||
+        (major === oldestMajor &&
+            range === null &&
+            (minor < oldestMinor || (minor === oldestMinor && patch < oldestPatch)));
     if (tooOld) {
         return [
-            fileDiagnostic('unsupported-framework-version', source, `${name} ${version} is older than ${oldestMajor}.${oldestMinor}, the oldest supported version; the results follow ${oldestMajor}.${oldestMinor}.`),
+            fileDiagnostic('unsupported-framework-version', source, `${name} ${version} is older than ${oldest}, the oldest supported version; the results follow ${oldest}.`),
         ];
     }
     if (range === null)
@@ -37,6 +43,29 @@ function versionDiagnostics(framework, version, source, range) {
         fileDiagnostic('approximate-framework-version', source, `Only the range "${range}" was found for ${name}, so the rules of the newest ${major}.x release apply.`),
     ];
 }
+/**
+ * The length Vitest shortens a value in a case title to: `test.taskTitleValueFormatTruncate` from Vitest 5,
+ * `test.chaiConfig.truncateThreshold` before, from the project that runs the file; 40, Vitest's default, when it sets
+ * none or the scan can't read it.
+ */
+function titleTruncate(placement, version) {
+    const key = atLeast(version, 5, 0)
+        ? ['test', 'taskTitleValueFormatTruncate']
+        : ['test', 'chaiConfig', 'truncateThreshold'];
+    const setting = placement.settings && settingAt(placement.settings, key);
+    return setting?.kind === 'value' && typeof setting.value === 'number' ? setting.value : 40;
+}
+/** Why Jest gives a file that uses its globals none: a project that runs it sets `injectGlobals` to false. */
+function jestGlobals(placement) {
+    const off = placement.projects?.find(({ settings }) => {
+        const setting = settingAt(settings, ['injectGlobals']);
+        return setting?.kind === 'value' && setting.value === false;
+    });
+    if (!off)
+        return null;
+    const config = off.config.record.relativeFilePath;
+    return `The file uses describe, it or test without importing them, but ${config} sets injectGlobals to false, so Jest doesn't define them; import them from '@jest/globals'.`;
+}
 /** For a pattern that names a folder, which matches no file, a pattern that matches the test files in it. */
 function folderHint(root, patterns, framework) {
     const folder = patterns.find((pattern) => {
@@ -100,7 +129,10 @@ function noFiles(root, patterns, framework, placements) {
     if ([...placements.values()].some((placement) => placement.config)) {
         return 'No test files were found from the configs in the root.';
     }
-    const name = framework === 'playwright' ? 'Playwright' : 'Vitest';
+    if (framework === 'node') {
+        return "No patterns were given, and no file in the root matches what node --test runs: Node.js's default patterns, or the files a package.json script gives it.";
+    }
+    const name = FRAMEWORK_NAMES[framework];
     return `No patterns were given, and no ${name} config is in the root or a folder below it, so there are no test files to find.`;
 }
 /**
@@ -112,19 +144,24 @@ function noFiles(root, patterns, framework, placements) {
 export async function scan(options) {
     const checked = checkObject(options, 'options');
     const patterns = checked.patterns === undefined ? null : checkStrings(checked.patterns, 'options.patterns', true);
-    const framework = checkFramework(checked.framework, 'options.framework');
     const ignore = checkStrings(checked.ignore, 'options.ignore', false);
     const comments = checkComments(checked.comments, 'options.comments');
     const expandCases = checkFlag(checked.expandCases, 'options.expandCases');
     const override = checkVersion(checked.frameworkVersion, 'options.frameworkVersion');
+    const signal = checkSignal(checked.signal, 'options.signal');
+    signal?.throwIfAborted();
     if (checked.root !== undefined && (typeof checked.root !== 'string' || checked.root === '')) {
         throw invalid('options.root', 'a non-empty string');
     }
     const root = path.resolve(checked.root ?? process.cwd());
     if (!existsSync(root) || !statSync(root).isDirectory())
         throw invalid('options.root', `a directory, and ${root} is not one`);
+    const framework = checked.framework === undefined
+        ? detectFramework(root, ignore)
+        : checkFramework(checked.framework, 'options.framework');
     // Without patterns, the configs choose among all JavaScript and TypeScript files.
     const found = await findFiles(root, patterns ?? [SCRIPT_FILES], ignore, framework);
+    signal?.throwIfAborted();
     const scanned = found.files.map((file) => file.relativeFilePath);
     const detected = override === null ? detectFrameworkVersion(root, framework, scanned) : null;
     const frameworkVersion = override ?? detected?.version ?? null;
@@ -173,6 +210,7 @@ export async function scan(options) {
     const results = [];
     const globalsFiles = [];
     for (const { absolutePath, relativeFilePath } of files) {
+        signal?.throwIfAborted();
         const placement = placements.get(absolutePath);
         if (placement.config)
             configs.use(placement.config);
@@ -198,10 +236,17 @@ export async function scan(options) {
             version: rules,
             comments,
             expandCases,
-            readModule: readerFor(absolutePath),
+            readModule: readerFor(absolutePath, importMap(placement, framework)),
             root,
             isBenchmarkFile: placement.runs === null ? null : placement.runs === 'benchmark',
             config: fileConfig(placement, framework, rules, absolutePath),
+            mochaInterface: framework === 'mocha'
+                ? mochaInterface(placement, configs)
+                : framework === 'webdriverio'
+                    ? webdriverioInterface(placement, configs)
+                    : undefined,
+            webdriverioFramework: framework === 'webdriverio' ? webdriverioFramework(placement, configs) : undefined,
+            titleTruncate: framework === 'vitest' ? titleTruncate(placement, rules) : undefined,
             graph,
             exports,
             runsWith,
@@ -216,7 +261,12 @@ export async function scan(options) {
         }
         results.push({ ...result, file: { ...result.file, config } });
     }
-    const missingGlobals = globalsCheck(root, configs, (file) => placements.get(file));
+    // Mocha, Jasmine, Cypress, WebdriverIO and Bun always set their globals, and Playwright and node:test have none.
+    const missingGlobals = framework === 'jest'
+        ? (file) => jestGlobals(placements.get(file))
+        : ['mocha', 'jasmine', 'cypress', 'webdriverio', 'node', 'bun'].includes(framework)
+            ? () => null
+            : globalsCheck(root, configs, (file) => placements.get(file));
     let globals = null;
     for (const { absolutePath, relativeFilePath } of globalsFiles) {
         const message = missingGlobals(absolutePath);

package/dist/toml.d.ts

@@ -0,0 +1,13 @@
+import type { Value } from './values.ts';
+/** A line of TOML the reader doesn't take, with its line number. */
+export declare class TomlError extends Error {
+    readonly line: number;
+    constructor(message: string, line: number);
+}
+type Table = Record<string, Value>;
+/**
+ * The part of TOML a `bunfig.toml` uses: tables and dotted keys, strings, numbers, booleans, arrays over several lines,
+ * inline tables and comments. Dates and arrays of tables are refused with a `TomlError`.
+ */
+export declare function readToml(text: string): Table;
+export {};

package/dist/toml.js

@@ -0,0 +1,172 @@
+/** A line of TOML the reader doesn't take, with its line number. */
+export class TomlError extends Error {
+    line;
+    constructor(message, line) {
+        super(message);
+        this.line = line;
+    }
+}
+/**
+ * The part of TOML a `bunfig.toml` uses: tables and dotted keys, strings, numbers, booleans, arrays over several lines,
+ * inline tables and comments. Dates and arrays of tables are refused with a `TomlError`.
+ */
+export function readToml(text) {
+    const root = {};
+    let table = root;
+    const reader = { text, at: 0, line: 1 };
+    for (;;) {
+        skipBlank(reader, true);
+        if (reader.at >= text.length)
+            return root;
+        if (text[reader.at] === '[') {
+            if (text[reader.at + 1] === '[')
+                throw new TomlError('Arrays of tables are not read', reader.line);
+            reader.at++;
+            const keys = readKeys(reader, ']');
+            reader.at++;
+            table = tableAt(root, keys, reader.line);
+        }
+        else {
+            const keys = readKeys(reader, '=');
+            reader.at++;
+            skipBlank(reader, false);
+            const value = readValue(reader);
+            const owner = tableAt(table, keys.slice(0, -1), reader.line);
+            owner[keys[keys.length - 1]] = value;
+        }
+        skipBlank(reader, false);
+        if (reader.at < text.length && text[reader.at] !== '\n') {
+            throw new TomlError(`Unexpected "${text[reader.at]}"`, reader.line);
+        }
+    }
+}
+/** Skips spaces and comments, and line breaks too when `lines` is set. */
+function skipBlank(reader, lines) {
+    const { text } = reader;
+    while (reader.at < text.length) {
+        const char = text[reader.at];
+        if (char === '#') {
+            while (reader.at < text.length && text[reader.at] !== '\n')
+                reader.at++;
+        }
+        else if (char === ' ' || char === '\t' || char === '\r') {
+            reader.at++;
+        }
+        else if (char === '\n' && lines) {
+            reader.line++;
+            reader.at++;
+        }
+        else {
+            return;
+        }
+    }
+}
+/** A dotted key, bare or quoted, up to `end`. */
+function readKeys(reader, end) {
+    const keys = [];
+    for (;;) {
+        skipBlank(reader, false);
+        const char = reader.text[reader.at];
+        if (char === '"' || char === "'")
+            keys.push(readString(reader));
+        else {
+            const bare = /^[A-Za-z0-9_-]+/.exec(reader.text.slice(reader.at));
+            if (!bare)
+                throw new TomlError('Expected a key', reader.line);
+            keys.push(bare[0]);
+            reader.at += bare[0].length;
+        }
+        skipBlank(reader, false);
+        if (reader.text[reader.at] === end)
+            return keys;
+        if (reader.text[reader.at] !== '.')
+            throw new TomlError(`Expected "${end}"`, reader.line);
+        reader.at++;
+    }
+}
+function tableAt(root, keys, line) {
+    let table = root;
+    for (const key of keys) {
+        table[key] ??= {};
+        const next = table[key];
+        if (typeof next !== 'object' || Array.isArray(next)) {
+            throw new TomlError(`${key} is not a table`, line);
+        }
+        table = next;
+    }
+    return table;
+}
+function readValue(reader) {
+    const { text } = reader;
+    const char = text[reader.at];
+    if (char === '"' || char === "'")
+        return readString(reader);
+    if (char === '[') {
+        reader.at++;
+        const items = [];
+        for (;;) {
+            skipBlank(reader, true);
+            if (text[reader.at] === ']')
+                break;
+            items.push(readValue(reader));
+            skipBlank(reader, true);
+            if (text[reader.at] === ',')
+                reader.at++;
+            else if (text[reader.at] !== ']')
+                throw new TomlError('Expected "," or "]"', reader.line);
+        }
+        reader.at++;
+        return items;
+    }
+    if (char === '{') {
+        reader.at++;
+        const table = {};
+        skipBlank(reader, false);
+        while (text[reader.at] !== '}') {
+            const keys = readKeys(reader, '=');
+            reader.at++;
+            skipBlank(reader, false);
+            tableAt(table, keys.slice(0, -1), reader.line)[keys[keys.length - 1]] = readValue(reader);
+            skipBlank(reader, false);
+            if (text[reader.at] === ',')
+                reader.at++;
+            skipBlank(reader, false);
+        }
+        reader.at++;
+        return table;
+    }
+    const word = /^[^\s,\]}#]+/.exec(text.slice(reader.at))?.[0] ?? '';
+    reader.at += word.length;
+    if (word === 'true' || word === 'false')
+        return word === 'true';
+    const number = word.replaceAll('_', '');
+    if (/^[+-]?(\d+(\.\d+)?([eE][+-]?\d+)?|inf|nan)$/.test(number)) {
+        return number.endsWith('inf') ? (number.startsWith('-') ? -Infinity : Infinity) : Number(number);
+    }
+    throw new TomlError(`Value ${word || text[reader.at]} is not read`, reader.line);
+}
+/** A basic string, with escapes, or a literal one; one line each. */
+function readString(reader) {
+    const { text } = reader;
+    const quote = text[reader.at++];
+    let value = '';
+    while (text[reader.at] !== quote) {
+        const char = text[reader.at];
+        if (reader.at >= text.length || char === '\n')
+            throw new TomlError('The string is not closed', reader.line);
+        if (char === '\\' && quote === '"') {
+            const escape = text[reader.at + 1];
+            const escapes = { n: '\n', t: '\t', r: '\r', '"': '"', '\\': '\\' };
+            if (!(escape in escapes))
+                throw new TomlError(`Escape \\${escape} is not read`, reader.line);
+            value += escapes[escape];
+            reader.at += 2;
+        }
+        else {
+            value += char;
+            reader.at++;
+        }
+    }
+    reader.at++;
+    return value;
+}