@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/dist/src/sweep.js

@@ -70,22 +70,34 @@ export function sweep(graph, input) {
     });
     return { liveUnder: live, candidates };
 }
+/**
+ * The directory a test runner reads a manual mock from, whose exports it puts in place of
+ * the module's: https://jestjs.io/docs/manual-mocks
+ */
+const MANUAL_MOCKS = "__mocks__";
+/** Whether a test runner calls or reads one export of a test file: a function, or any export of a manual mock. */
+export function runnerCalls(symbol) {
+    return symbol.kind === "function" || symbol.position.path.split("/").includes(MANUAL_MOCKS);
+}
 /**
  * Per declaration of the graph, whether the run that counts test references reaches it.
- * That run's roots are the graph's own and each test file, being the file's top level
- * and every declaration it exports, which a test runner may call; `held` seeds it as a
- * mark or an exemption seeds a sweep.
+ * That run's roots are the graph's own and, of each test file, its top level and every
+ * function it exports, which a test runner may call, and every export of a manual mock,
+ * which the runner reads; any other export of a test file, and test-support code, which
+ * runs where a test imports it, are judged as any file's are. `held` seeds it as a mark
+ * seeds a sweep; with `namespaces` false a file read reaches none of the file's exports.
  */
-export function reachedWithTheTests(graph, held) {
+export function reachedWithTheTests(graph, held, namespaces = true) {
     const tests = graph.symbols.flatMap((symbol, at) => {
-        const top = symbol.kind === "file" || graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
-        return graph.test[at] === true && top && (symbol.kind === "file" || symbol.exported)
+        const exported = symbol.exported && graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
+        const called = exported && runnerCalls(symbol);
+        return graph.test[at] === true &&
+            graph.support[at] !== true &&
+            (symbol.kind === "file" || called)
             ? [{ at, kind: "test-runner" }]
             : [];
     });
-    return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), {
-        production: false,
-    });
+    return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), { production: false }, namespaces);
 }
 /**
  * The references a loaded consumer makes that the mode counts. A production mode counts
@@ -112,7 +124,7 @@ function flagged(graph, ids) {
  * included, while a root reaches through the references the mode counts. The held seed
  * runs first, so what it reaches is expanded under the wider rule.
  */
-function reachable(graph, held, mode) {
+function reachable(graph, held, mode, namespaces = true) {
     const reached = graph.symbols.map(() => false);
     const expanded = graph.symbols.map(() => false);
     const queue = [];
@@ -140,7 +152,7 @@ function reachable(graph, held, mode) {
                 if (!holding && mode.production && edge.test) {
                     continue;
                 }
-                enter(edge.to, !edge.evaluation);
+                enter(edge.to, namespaces && !edge.evaluation);
             }
         }
     };
@@ -155,17 +167,18 @@ function reachable(graph, held, mode) {
     }
     // A consumer's reference reaches what it names as one of the target's own does.
     for (const edge of callsOf(graph, mode)) {
-        enter(edge.to, !edge.evaluation);
+        enter(edge.to, namespaces && !edge.evaluation);
     }
     walk(false);
     return reached;
 }
 /**
  * Admits every test declaration whose set of referenced production declarations is
- * non-empty and wholly dead, and returns which it admitted. The set is read from every
- * reference the test makes, which a production sweep does not count. A test-support
- * declaration that a test referencing a live target also references is a live target of
- * every test referencing it. A marked or exempt test is never admitted.
+ * non-empty and wholly dead, and returns which it admitted. An ambient declaration describes
+ * code the target does not implement, so it is no production declaration here. The set is
+ * read from every reference the test makes, which a production sweep does not count. A
+ * test-support declaration a test referencing a live target also references is a live
+ * target of every test referencing it. A marked or exempt test is never admitted.
  */
 function admitTestsOfDeadCode(graph, dead, held) {
     const testCode = (at) => graph.test[at] === true || graph.support[at] === true;
@@ -174,7 +187,9 @@ function admitTestsOfDeadCode(graph, dead, held) {
         let live = 0;
         if (testCode(at) && graph.subject[at] === true && held[at] !== true) {
             for (const edge of graph.out[at] ?? []) {
-                if (testCode(edge.to) || graph.subject[edge.to] !== true) {
+                if (testCode(edge.to) ||
+                    graph.subject[edge.to] !== true ||
+                    graph.ambient[edge.to] === true) {
                     continue;
                 }
                 targets += 1;

package/dist/src/symbol-keys.js

@@ -2,16 +2,17 @@
  * The members a unique symbol keys, used through element accesses. `value[key]`, where
  * `key` is a constant of a `unique symbol` type, reads the member of the receiver's type
  * whose computed name is that same constant, and a store through the access writes it.
- * No name node resolves to such a member: the key's name resolves to the constant.
+ * No name node resolves to such a member: the key's name resolves to the constant. An
+ * iteration reads the member its well-known iteration symbol keys.
  */
-import { isComputedPropertyName, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/ast";
+import { isComputedPropertyName, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isPropertyAccessExpression, isSpreadElement, isStringLiteral, } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.js";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
 import { isAnswered } from "./query.js";
 /** The identifier an element access's argument names its key by, where it is a name. */
 export function keyNameOf(argument) {
-    let at = argument;
-    while (isParenthesizedExpression(at)) {
-        at = at.expression;
-    }
+    const at = parenthesesRemoved(argument);
     if (isIdentifier(at)) {
         return at;
     }
@@ -112,3 +113,101 @@ export function keyedUses(project, chains, resolved, properties, cap) {
         return ids.length === 0 ? [] : [{ access: one.access, ids: [...new Set(ids)] }];
     });
 }
+/** The member name `[Symbol.<name>]` spells, where a computed name spells one. */
+function wellKnownName(name) {
+    if (name === undefined || !isComputedPropertyName(name)) {
+        return undefined;
+    }
+    const key = name.expression;
+    return isPropertyAccessExpression(key) &&
+        isIdentifier(key.expression) &&
+        key.expression.text === "Symbol" &&
+        isIdentifier(key.name)
+        ? key.name.text
+        : undefined;
+}
+/**
+ * The references the iterations of one project's own files make to the iteration members
+ * of the values they iterate: a `for…of` statement and a spread element read
+ * `[Symbol.iterator]`, and a `for await…of` statement reads `[Symbol.asyncIterator]` and,
+ * which it falls back to, `[Symbol.iterator]`. Each is made by the declaration holding it.
+ */
+export function iterationReferences(project, held, chains, root, testFiles) {
+    const queries = project.queries;
+    const ownPaths = project.ownPaths();
+    const iterated = [];
+    for (const file of project.ownSourceFiles()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId === undefined) {
+            continue;
+        }
+        const visit = (node, from) => {
+            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+            if (isForOfStatement(node)) {
+                const protocols = node.awaitModifier === undefined ? ["iterator"] : ["asyncIterator", "iterator"];
+                iterated.push({ file, from: holder, operand: node.expression, protocols });
+            }
+            else if (isSpreadElement(node)) {
+                iterated.push({ file, from: holder, operand: node.expression, protocols: ["iterator"] });
+            }
+            node.forEachChild((child) => {
+                visit(child, holder);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, fileId);
+        });
+    }
+    if (iterated.length === 0) {
+        return [];
+    }
+    const types = queries.typesAt(iterated.map((one) => one.operand));
+    const members = new Map();
+    const membersOf = (type) => {
+        const known = members.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const keyed = [];
+        const properties = queries.propertiesOf(type);
+        for (const property of isAnswered(properties) ? properties : []) {
+            for (const handle of property.declarations) {
+                const node = ownPaths.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
+                const name = wellKnownName(node?.name);
+                if (name !== undefined) {
+                    keyed.push({ name, ids: chains.declarationsOf(property) });
+                    break;
+                }
+            }
+        }
+        members.set(type.id, keyed);
+        return keyed;
+    };
+    const found = [];
+    iterated.forEach((one, index) => {
+        const type = types[index];
+        if (type === undefined || !isAnswered(type)) {
+            return;
+        }
+        const parts = type.isUnionType() || type.isIntersectionType() ? queries.constituents(type) : [type];
+        const position = renderPosition(one.file, root, one.operand.getStart());
+        for (const part of isAnswered(parts) ? parts : []) {
+            for (const member of membersOf(part)) {
+                if (!one.protocols.includes(member.name)) {
+                    continue;
+                }
+                for (const to of member.ids) {
+                    found.push({
+                        from: one.from,
+                        to,
+                        position,
+                        use: "read",
+                        resolution: "keyed",
+                        test: testFiles.has(position.path),
+                    });
+                }
+            }
+        }
+    });
+    return found;
+}

package/dist/src/template-field.js

@@ -12,10 +12,12 @@
  * type, because nothing ties the name to a type.
  */
 import { readComponent } from "./component-files.js";
-import { ConfigError } from "./config.js";
 import { memberNames } from "./member-names.js";
 import { extensionOf, isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.js";
 import { isComponentFile } from "./position.js";
+import { bytewise } from "./text/compare.js";
+import { filesBelow } from "./fs/tree.js";
+import { UsageError } from "./usage.js";
 /** The kinds of declaration an action can name. */
 const READ_BY_A_TEMPLATE = new Set([
     "method",
@@ -30,13 +32,6 @@ const READ_BY_A_TEMPLATE = new Set([
 const READ_BY_MARKUP = new Set([...READ_BY_A_TEMPLATE, "enum-member"]);
 /** One identifier, as the grammar of the analyzed language spells one. */
 const IDENTIFIER = /[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*/uy;
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /**
  * Every template under the configured directories, read once for the run, in path
  * order and each file once. A directory is named relative to the target root, and
@@ -48,34 +43,29 @@ function compare(a, b) {
 export function readTemplates(host, targetRoot, analysis) {
     const files = new Map();
     const read = (dir) => {
-        const entries = [...host.readDirectory(joinPath(targetRoot, dir))].sort((a, b) => compare(a.name, b.name));
-        for (const entry of entries) {
-            const path = joinPath(dir, entry.name);
-            if (entry.directory) {
-                read(path);
-                continue;
-            }
+        for (const below of filesBelow(host, joinPath(targetRoot, dir), () => true)) {
+            const path = joinPath(dir, below);
             const absolute = joinPath(targetRoot, path);
             if (!files.has(path) && host.kindOf(absolute) === "file") {
                 files.set(path, host.readFile(absolute));
             }
         }
     };
-    for (const configured of analysis.templateDirs) {
+    for (const configured of analysis.template_dirs) {
         const dir = normalizePath(configured);
         if (isAbsolutePath(dir) ||
             dir === ".." ||
             dir.startsWith("../") ||
             host.kindOf(joinPath(targetRoot, dir)) !== "directory") {
-            throw new ConfigError("malformed", "analysis.template_dirs", `analysis.template_dirs: ${JSON.stringify(configured)} is not a directory below the target root`);
+            throw new UsageError(`analysis.template_dirs: ${JSON.stringify(configured)} is not a directory below the target root`);
         }
         read(dir);
     }
     return {
-        delimiters: analysis.templateDelimiters,
+        delimiters: analysis.template_delimiters,
         files: [...files]
             .map(([path, text]) => ({ path, text }))
-            .sort((a, b) => compare(a.path, b.path)),
+            .sort((a, b) => bytewise(a.path, b.path)),
     };
 }
 /** The end of the quoted string that opens at `from`, past its closing quote. */

package/dist/src/test-support.js

@@ -1,19 +1,113 @@
 /**
- * Test-support code: the files only tests reach. A test reaches each one through a chain
- * of references, and every reference to a declaration of one, an import for its effects
- * included, is written in a test file or in another such file, so it is judged with the
- * tests: what it references is referenced by test code.
+ * Test-support code: the files only tests reach that carry test evidence of their own. A
+ * test reaches each one through a chain of references, and every reference to a
+ * declaration of one, an import for its effects included, is written in a test file or in
+ * another such file, so it is judged with the tests: what it references is referenced by
+ * test code.
  */
+import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./convention-rows.js";
+import { packageOfSpecifier } from "./dependencies.js";
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
+/**
+ * The test runners and test libraries an import of which is test evidence: each runner a
+ * convention row reads test files for, and the convention table's test libraries.
+ */
+const TEST_PACKAGES = new Set([
+    ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined).map((row) => row.package),
+    ...TEST_LIBRARIES,
+]);
+/**
+ * The Node.js built-in modules a bare specifier names, which are no package. The set is
+ * closed: Node.js adds a new built-in under the `node:` scheme alone
+ * (https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix).
+ */
+const NODE_BUILTINS = new Set([
+    "assert",
+    "async_hooks",
+    "buffer",
+    "child_process",
+    "cluster",
+    "console",
+    "constants",
+    "crypto",
+    "dgram",
+    "diagnostics_channel",
+    "dns",
+    "domain",
+    "events",
+    "fs",
+    "http",
+    "http2",
+    "https",
+    "inspector",
+    "module",
+    "net",
+    "os",
+    "path",
+    "perf_hooks",
+    "process",
+    "punycode",
+    "querystring",
+    "readline",
+    "repl",
+    "stream",
+    "string_decoder",
+    "sys",
+    "timers",
+    "tls",
+    "trace_events",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "wasi",
+    "worker_threads",
+    "zlib",
+]);
+/** Whether a specifier names a test runner or a test library. */
+function namesTestPackage(specifier) {
+    const name = specifier.startsWith("node:") ? specifier : packageOfSpecifier(specifier);
+    return (name !== undefined &&
+        (TEST_PACKAGES.has(name) || TEST_LIBRARY_SCOPES.some((scope) => name.startsWith(scope))));
+}
+/**
+ * Whether a file carries test evidence: an import of a test runner or a test library, or
+ * package imports, Node built-ins aside, that are all devDependencies no file imports
+ * outside the test files and `onlyTests`, the files only tests reach.
+ */
+function evidenceReader(tests, evidence) {
+    const importers = new Map();
+    for (const [path, specifiers] of evidence.imports) {
+        for (const specifier of specifiers) {
+            const name = packageOfSpecifier(specifier);
+            if (name !== undefined) {
+                importers.set(name, [...(importers.get(name) ?? []), path]);
+            }
+        }
+    }
+    return (onlyTests, path) => {
+        const specifiers = evidence.imports.get(path) ?? [];
+        if (specifiers.some(namesTestPackage)) {
+            return true;
+        }
+        const names = specifiers.flatMap((one) => packageOfSpecifier(one) ?? []);
+        const packages = names.filter((name) => !NODE_BUILTINS.has(name));
+        return (packages.length > 0 &&
+            packages.every((name) => evidence.devDependency(path, name) &&
+                (importers.get(name) ?? []).every((one) => tests.has(one) || onlyTests.has(one))));
+    };
+}
 /**
  * The files of one project that are test-support code, below the target root: the
  * largest set of files a test file reaches, none of them a test file or holding a root,
- * whose every user outside the set is a test file. A root has a caller outside the
- * reference graph: a runtime, a tool, a configuration, or a consumer of a library's
- * published API. `testFiles` are the files the test-file rules classified.
+ * each carrying test evidence of its own, whose every user outside the set is a test
+ * file; and the files only tests reach that are not among them. A root has a caller
+ * outside the reference graph: a runtime, a tool, a configuration, or a consumer of a
+ * library's published API. `testFiles` are the files the test-file rules classified.
  */
-export function testSupportFiles(symbols, references, roots, testFiles) {
+export function testSupportFiles(symbols, references, roots, testFiles, evidence) {
     const fileOf = new Map(symbols.map((symbol) => [symbol.id, symbol.position.path]));
     const users = new Map();
     const uses = new Map();
@@ -47,18 +141,25 @@ export function testSupportFiles(symbols, references, roots, testFiles) {
             }
         }
     }
-    const support = new Set([...reached].filter((path) => !rooted.has(path)));
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const path of support) {
-            const from = users.get(path) ?? new Set();
-            if (![...from].every((one) => tests.has(one) || support.has(one))) {
-                support.delete(path);
-                changed = true;
+    const withoutOutsideUsers = (files) => {
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const path of files) {
+                const from = users.get(path) ?? new Set();
+                if (![...from].every((one) => tests.has(one) || files.has(one))) {
+                    files.delete(path);
+                    changed = true;
+                }
             }
         }
-    }
-    return support;
+        return files;
+    };
+    // Evidence reads the files only tests reach, evidence or none, so it is fixed before the
+    // files without evidence leave the set.
+    const onlyTests = withoutOutsideUsers(new Set([...reached].filter((path) => !rooted.has(path))));
+    const carries = evidenceReader(tests, evidence);
+    const support = withoutOutsideUsers(new Set([...onlyTests].filter((path) => carries(onlyTests, path))));
+    return { support, testUsed: new Set([...onlyTests].filter((path) => !support.has(path))) };
 }
 /** The references with every one a test-support file makes counted as a test reference. */
 export function supportReferences(references, support) {

package/dist/src/text/compare.js

@@ -0,0 +1,26 @@
+/**
+ * Two strings in the order of their UTF-8 bytes, the order every set of a run is read in.
+ * That is code point order, which UTF-16 code unit order (`<` on strings) breaks above
+ * U+FFFF: a surrogate unit is below U+E000 while the code point it encodes is above U+FFFF.
+ */
+export function bytewise(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    const length = Math.min(a.length, b.length);
+    for (let at = 0; at < length; at += 1) {
+        const x = a.charCodeAt(at);
+        const y = b.charCodeAt(at);
+        if (x !== y) {
+            return ranked(x) < ranked(y) ? -1 : 1;
+        }
+    }
+    return a.length < b.length ? -1 : 1;
+}
+/** One UTF-16 unit moved so that a surrogate ranks above every unit of U+E000 to U+FFFF. */
+function ranked(unit) {
+    if (unit >= 0xe000) {
+        return unit - 0x800;
+    }
+    return unit >= 0xd800 ? unit + 0x2000 : unit;
+}

package/dist/src/text/glob.js

@@ -0,0 +1,194 @@
+/**
+ * Glob patterns over paths in two forms. The configured form (the configuration, convention
+ * rows, bundler entries, workspace member patterns) has `*` and `?` within a segment, `**`
+ * across segments and brace lists. A `.gitignore` line has git's form: bracket expressions
+ * and backslash escapes, no brace lists (https://git-scm.com/docs/gitignore#_pattern_format).
+ * A configured root is not a glob: it names a symbol reference, and is read where it is used.
+ */
+/**
+ * One character of a pattern as the expression syntax reads it literally. The set escaped
+ * is closed: under the unicode flag an escape of any other character is refused outright.
+ */
+function quoted(character) {
+    return /[.*+?^${}()|[\]\\/]/u.test(character) ? `\\${character}` : character;
+}
+/**
+ * The ASCII ranges each POSIX class a bracket expression may name holds, as git's own
+ * character table reads them, each range written as its first and last character.
+ */
+const CLASSES = new Map([
+    ["alnum", "09AZaz"],
+    ["alpha", "AZaz"],
+    ["blank", "\t\t  "],
+    ["cntrl", "\0\x1f\x7f\x7f"],
+    ["digit", "09"],
+    ["graph", "!~"],
+    ["lower", "az"],
+    ["print", " ~"],
+    ["punct", "!/:@[`{~"],
+    ["space", "\t\n\r\r  "],
+    ["upper", "AZ"],
+    ["xdigit", "09AFaf"],
+]);
+/** What a pattern git cannot read matches: nothing, as git aborts the whole match. */
+const NOTHING = "(?!)";
+/** One code point as a member of an expression class. */
+function member(point) {
+    return `\\u{${point.toString(16)}}`;
+}
+/**
+ * The class a bracket expression opening at `open` denotes, and the index past its `]`,
+ * read as git's wildmatch reads it: a leading `!` or `^` negates it, a `]` first is a
+ * member, `\` escapes one character, `x-y` is a range (one whose `y` is below `x` holds
+ * `x` alone) and `[:name:]` a POSIX class. An unclosed bracket or an unknown class name
+ * matches nothing. Neither form matches the solidus.
+ */
+function bracket(pattern, open) {
+    let at = open + 1;
+    const negated = pattern[at] === "!" || pattern[at] === "^";
+    if (negated) {
+        at += 1;
+    }
+    const next = () => {
+        const point = pattern.codePointAt(at);
+        at += point !== undefined && point > 0xffff ? 2 : 1;
+        return point;
+    };
+    let members = "";
+    let low;
+    for (let first = true;; first = false) {
+        let point = next();
+        if (point === undefined) {
+            return { source: NOTHING, end: pattern.length };
+        }
+        if (point === 0x5d && !first) {
+            return { source: negated ? `[^/${members}]` : `(?!/)[${members}]`, end: at };
+        }
+        if (point === 0x2d && low !== undefined && at < pattern.length && pattern[at] !== "]") {
+            let high = next();
+            if (high === 0x5c) {
+                high = next();
+            }
+            if (high === undefined) {
+                return { source: NOTHING, end: pattern.length };
+            }
+            members += high >= low ? `${member(low)}-${member(high)}` : "";
+            low = undefined;
+            continue;
+        }
+        if (point === 0x5b && pattern[at] === ":") {
+            const close = pattern.indexOf("]", at + 1);
+            if (close < 0) {
+                return { source: NOTHING, end: pattern.length };
+            }
+            if (close > at + 1 && pattern[close - 1] === ":") {
+                const ranges = CLASSES.get(pattern.slice(at + 1, close - 1));
+                if (ranges === undefined) {
+                    return { source: NOTHING, end: pattern.length };
+                }
+                for (let one = 0; one < ranges.length; one += 2) {
+                    members += `${member(ranges.charCodeAt(one))}-${member(ranges.charCodeAt(one + 1))}`;
+                }
+                low = undefined;
+                at = close + 1;
+                continue;
+            }
+        }
+        if (point === 0x5c) {
+            point = next();
+            if (point === undefined) {
+                return { source: NOTHING, end: pattern.length };
+            }
+        }
+        members += member(point);
+        low = point;
+    }
+}
+/** The expression source of one pattern with no brace list. */
+function source(pattern, form) {
+    let text = "";
+    let at = 0;
+    while (at < pattern.length) {
+        if (pattern.startsWith("**/", at)) {
+            text += "(?:[^/]*/)*";
+            at += 3;
+            continue;
+        }
+        if (pattern.startsWith("**", at)) {
+            text += ".*";
+            at += 2;
+            continue;
+        }
+        const character = pattern[at] ?? "";
+        if (form === "gitignore" && character === "[") {
+            const read = bracket(pattern, at);
+            text += read.source;
+            at = read.end;
+            continue;
+        }
+        if (form === "gitignore" && character === "\\" && at + 1 < pattern.length) {
+            text += quoted(pattern[at + 1] ?? "");
+            at += 2;
+            continue;
+        }
+        at += 1;
+        text += character === "*" ? "[^/]*" : character === "?" ? "[^/]" : quoted(character);
+    }
+    return text;
+}
+/** A pattern with every brace list expanded into its alternatives; a lone `{` stands for itself. */
+export function braceExpanded(pattern) {
+    const open = pattern.indexOf("{");
+    const close = open < 0 ? -1 : pattern.indexOf("}", open);
+    if (close < 0) {
+        return [pattern];
+    }
+    const before = pattern.slice(0, open);
+    const after = pattern.slice(close + 1);
+    return pattern
+        .slice(open + 1, close)
+        .split(",")
+        .flatMap((member) => braceExpanded(before + member + after));
+}
+/** The expression one whole-path pattern of the configured form denotes. */
+export function globExpression(pattern) {
+    const alternatives = braceExpanded(pattern).map((one) => source(one, "configured"));
+    return new RegExp(`^(?:${alternatives.join("|")})$`, "u");
+}
+/** The expression one `.gitignore` pattern denotes over a path below its file's directory. */
+export function gitignoreExpression(pattern) {
+    return new RegExp(`^${source(pattern, "gitignore")}$`, "u");
+}
+const SEGMENTS = new Map();
+/**
+ * Whether one directory name matches one segment of a workspace's member pattern, its brace
+ * lists already expanded. Neither `*` nor `?` matches a leading dot, as npm's workspaces read
+ * them: https://docs.npmjs.com/cli/using-npm/workspaces
+ */
+export function segmentMatches(segment, name) {
+    if (name.startsWith(".") && !segment.startsWith(".")) {
+        return false;
+    }
+    let expression = SEGMENTS.get(segment);
+    if (expression === undefined) {
+        expression = globExpression(segment);
+        SEGMENTS.set(segment, expression);
+    }
+    return expression.test(name);
+}
+/**
+ * Whether one path's segments match a member pattern's, `**` standing for any run of segments
+ * that starts with no dot.
+ */
+export function pathMatches(pattern, path) {
+    const [head, ...rest] = pattern;
+    if (head === undefined) {
+        return path.length === 0;
+    }
+    if (head === "**") {
+        return (pathMatches(rest, path) ||
+            (path.length > 0 && !(path[0] ?? "").startsWith(".") && pathMatches(pattern, path.slice(1))));
+    }
+    const [name, ...below] = path;
+    return name !== undefined && segmentMatches(head, name) && pathMatches(rest, below);
+}