@cplieger/deadset-ts 8.0.0-dev.6 → 8.0.0-dev.7

package/dist/src/schema.js

@@ -1,4 +1,5 @@
 import { ConfigError } from "./config.js";
+import { bytewise } from "./text/compare.js";
 const leaf = { kind: "leaf" };
 const integer = { kind: "leaf", integer: true };
 /** A list of declarations, each entry in one of the three shapes the `ts` section states. */
@@ -128,7 +129,7 @@ function collect(node, at, keys, settingsOnly) {
 export function declaredKeys() {
     const keys = [];
     collect(SCHEMA_ROOT, "", keys, false);
-    return keys.sort();
+    return keys.sort(bytewise);
 }
 /**
  * The dotted path of every setting that holds one value, in ascending order. A
@@ -139,7 +140,7 @@ export function declaredKeys() {
 export function settingPaths() {
     const paths = [];
     collect(SCHEMA_ROOT, "", paths, true);
-    return paths.sort();
+    return paths.sort(bytewise);
 }
 /**
  * Whether one dotted path names a setting a source may supply: a setting of the
@@ -373,7 +374,7 @@ export function checkDocument(text, node, label) {
  */
 export function nestFlags(flat, label) {
     const nested = {};
-    for (const path of Object.keys(flat).sort()) {
+    for (const path of Object.keys(flat).sort(bytewise)) {
         if (!declaresSetting(path)) {
             throw unimplementedKey(label, path);
         }

package/dist/src/scope.js

@@ -1,6 +1,8 @@
 import { ConfigError } from "./config.js";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.js";
 import { checkDocument } from "./schema.js";
+import { isRecord } from "./json-document.js";
+import { message } from "./product.js";
 /** The roles a scope document declares for a module. */
 const ROLE_TARGET = "target";
 const ROLE_CONSUMER = "consumer";
@@ -32,9 +34,6 @@ const SCOPE_ROOT = {
         consumers: { kind: "list", members: MODULE.members ?? {} },
     },
 };
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 /**
  * One string member, or undefined where the document omits it. A member the
  * document writes is a string holding at least one character, so `null` and `""`
@@ -107,7 +106,7 @@ export function readScope(host, file) {
         text = host.readFile(absolute);
     }
     catch (error) {
-        throw new ScopeError(`scope: ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        throw new ScopeError(`scope: ${file}: ${message(error)}`);
     }
     if (text.length > MAX_DOCUMENT_LENGTH) {
         throw new ScopeError(`scope: ${file} is longer than ${String(MAX_DOCUMENT_LENGTH)} characters`);
@@ -117,7 +116,7 @@ export function readScope(host, file) {
         value = JSON.parse(text);
     }
     catch (error) {
-        throw new ScopeError(`scope: ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        throw new ScopeError(`scope: ${file}: ${message(error)}`);
     }
     if (!isRecord(value)) {
         throw new ScopeError(`scope: ${file} is not one JSON object`);

package/dist/src/serialization-contract.js

@@ -7,6 +7,7 @@
  * function invoked through `call`, `apply` or `bind` is the callee.
  */
 import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isAwaitExpression, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isElementAccessExpression, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isNonNullExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isForInStatement, isPropertyAccessExpression, isPropertyDeclaration, isReturnStatement, isSatisfiesExpression, isSetAccessorDeclaration, isSourceFile, isSpreadAssignment, isSpreadElement, isStringLiteral, isTypeAssertion, isTypeLiteralNode, isVariableDeclaration, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.js";
 import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
@@ -88,11 +89,6 @@ const FUNCTION_INTERFACES = new Set([
     "CallableFunction",
     "NewableFunction",
 ]);
-function unparenthesized(expression) {
-    return isParenthesizedExpression(expression)
-        ? unparenthesized(expression.expression)
-        : expression;
-}
 /**
  * The invocation a call writes through a method of `Function.prototype`, read from
  * the syntax alone: `f.call(self, a)`, `f.apply(self, [a])`, `f.bind(self, a)`, which
@@ -101,12 +97,12 @@ function unparenthesized(expression) {
  * carries. Whether the method is the prototype's is resolution's to say.
  */
 function throughMethod(call) {
-    const expression = unparenthesized(call.expression);
+    const expression = parenthesesRemoved(call.expression);
     if (isPropertyAccessExpression(expression) && FUNCTION_METHODS.has(expression.name.text)) {
         const [, ...rest] = call.arguments;
         let passed = rest;
         if (expression.name.text === "apply") {
-            const list = rest[0] === undefined ? undefined : unparenthesized(rest[0]);
+            const list = rest[0] === undefined ? undefined : parenthesesRemoved(rest[0]);
             passed = list === undefined ? [] : isArrayLiteralExpression(list) ? list.elements : [list];
         }
         return {
@@ -115,7 +111,7 @@ function throughMethod(call) {
         };
     }
     if (isCallExpression(expression)) {
-        const bound = unparenthesized(expression.expression);
+        const bound = parenthesesRemoved(expression.expression);
         if (isPropertyAccessExpression(bound) && bound.name.text === "bind") {
             return {
                 method: bound.name,

package/dist/src/session.js

@@ -3,6 +3,7 @@ import { componentLayer, mapperManifest } from "./component-layer.js";
 import { DiscoveryError } from "./discover.js";
 import { joinPath } from "./paths.js";
 import { queriesOf, UnansweredLog, } from "./query.js";
+import { MANIFEST } from "./fs/manifest.js";
 /**
  * Opens the compiler client the analysis reads through.
  *
@@ -16,7 +17,7 @@ export function openEngine(options) {
     if (components !== undefined && components.extensions.length > 0) {
         const made = components.host.temporaryDirectory();
         try {
-            components.host.writeDocument(joinPath(made.path, "package.json"), [
+            components.host.writeDocument(joinPath(made.path, MANIFEST), [
                 mapperManifest(components.host.componentMapperCommand()),
             ]);
         }

package/dist/src/suppress-file.js

@@ -7,9 +7,10 @@
 import { CODE } from "./contract/contract.generated.js";
 import { jsonChunks } from "./json-chunks.js";
 import { joinPath } from "./paths.js";
-import { positionAt, walkDocument } from "./json-document.js";
+import { isRecord, positionAt, walkDocument } from "./json-document.js";
 import { declarationKey } from "./ref.js";
 import { CODE_FORM, SuppressionError, blankReason, isEntryPath, isPartKind, isSymbolRef, siteText, } from "./suppress.js";
+import { message } from "./product.js";
 /** The name and the location the grammar fixes for the ignore file. */
 export const IGNORE_FILE = "deadset-ignore.json";
 /** The name and the location the grammar fixes for the baseline. */
@@ -43,9 +44,6 @@ const PATH_WANT = "a path relative to the target root, with the solidus as separ
 function documentSite(shape) {
     return { path: shape.file, line: 0, column: 0 };
 }
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 /**
  * Reads one entry or row: the records it binds, the refusals it carries, or the
  * malformed value that ends the run.
@@ -54,7 +52,7 @@ function readRecord(value, site, byReference, shape) {
     const refuse = (text, want) => {
         throw new SuppressionError(shape.mechanism, siteText(site), text, want);
     };
-    if (!isObject(value)) {
+    if (!isRecord(value)) {
         return refuse(JSON.stringify(value), shape.recordWant);
     }
     for (const [key, held] of Object.entries(value)) {
@@ -145,9 +143,9 @@ function readDocument(host, targetRoot, symbols, shape) {
         parsed = JSON.parse(text);
     }
     catch (error) {
-        return malformed(`${shape.file}: ${error instanceof Error ? error.message : String(error)}`);
+        return malformed(`${shape.file}: ${message(error)}`);
     }
-    if (!isObject(parsed)) {
+    if (!isRecord(parsed)) {
         return malformed(shape.file);
     }
     const walk = walkDocument(text, shape.array);
@@ -228,9 +226,9 @@ export function otherSchemeRows(text, own = OWN_SCHEME) {
         parsed = JSON.parse(text);
     }
     catch (error) {
-        return refuse(error instanceof Error ? error.message : String(error));
+        return refuse(message(error));
     }
-    const held = isObject(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
+    const held = isRecord(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
     if (!Array.isArray(held)) {
         return refuse(BASELINE_SHAPE.documentWant);
     }
@@ -239,7 +237,7 @@ export function otherSchemeRows(text, own = OWN_SCHEME) {
             readRecord(value, documentSite(BASELINE_SHAPE), new Map(), BASELINE_SHAPE);
         }
         catch (error) {
-            return refuse(error instanceof Error ? error.message : String(error));
+            return refuse(message(error));
         }
         // readRecord has checked every member is a string and the code and symbol are present.
         const { code, symbol, path, reason } = value;

package/dist/src/symbol-keys.js

@@ -5,16 +5,14 @@
  * 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, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPropertyAccessExpression, isSpreadElement, 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;
     }

package/dist/src/template-field.js

@@ -16,6 +16,8 @@ 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";
 /** 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,13 +43,8 @@ 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));
@@ -75,7 +65,7 @@ export function readTemplates(host, targetRoot, analysis) {
         delimiters: analysis.templateDelimiters,
         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-globals.js

@@ -7,9 +7,11 @@
  * written for the runner, as one that imports it is.
  */
 import { isAsExpression, isBinaryExpression, isCallExpression, isExportAssignment, isExpressionStatement, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, SyntaxKind, } from "@typescript/native/ast";
-import { dirnamePath, joinPath } from "./paths.js";
+import { ancestors, dirnamePath, joinPath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 import { writtenPath } from "./workspace-programs.js";
+import { filesIn } from "./fs/tree.js";
+import { holdsManifest, INSTALLED_PACKAGES } from "./fs/manifest.js";
 /** The test runner whose configuration injects the globals, and the `types` entry declaring them. */
 export const GLOBALS_RUNNER = "vitest";
 const GLOBALS_TYPES = "vitest/globals";
@@ -93,17 +95,7 @@ function setsGlobals(file) {
 }
 /** Whether the runner's configuration in one manifest's directory injects the globals. */
 function injectsGlobals(host, parse, dir) {
-    let names;
-    try {
-        names = host
-            .readDirectory(dir)
-            .filter((entry) => !entry.directory && RUNNER_CONFIG.test(entry.name))
-            .map((entry) => entry.name);
-    }
-    catch {
-        return false;
-    }
-    return names.some((name) => {
+    return filesIn(host, dir, (name) => RUNNER_CONFIG.test(name)).some((name) => {
         const path = joinPath(dir, name);
         try {
             return setsGlobals(parse(path, host.readFile(path)));
@@ -115,25 +107,11 @@ function injectsGlobals(host, parse, dir) {
 }
 /** Whether a file declaring the globals is installed where the configuration resolves packages from. */
 function globalsInstalled(host, configFile) {
-    for (let dir = dirnamePath(configFile);; dir = dirnamePath(dir)) {
-        if (host.kindOf(joinPath(dir, "node_modules", GLOBALS_RUNNER, "globals.d.ts")) === "file") {
-            return true;
-        }
-        if (dirnamePath(dir) === dir) {
-            return false;
-        }
-    }
+    return ancestors(dirnamePath(configFile)).some((dir) => host.kindOf(joinPath(dir, INSTALLED_PACKAGES, GLOBALS_RUNNER, "globals.d.ts")) === "file");
 }
 /** The directory of the manifest nearest one configuration file, at or above its own. */
 function manifestDir(host, configFile) {
-    for (let dir = dirnamePath(configFile);; dir = dirnamePath(dir)) {
-        if (host.kindOf(joinPath(dir, "package.json")) === "file") {
-            return dir;
-        }
-        if (dirnamePath(dir) === dir) {
-            return undefined;
-        }
-    }
+    return ancestors(dirnamePath(configFile)).find((dir) => holdsManifest(host, dir));
 }
 function typesOf(value) {
     return Array.isArray(value) && value.every((one) => typeof one === "string") ? value : undefined;

package/dist/src/test-joins.js

@@ -6,14 +6,16 @@
  * file another package's, which its own test runner compiles.
  */
 import { sourcePaths } from "./file-facts.js";
-import { dirnamePath, joinPath, relativePath } from "./paths.js";
+import { ancestors, dirnamePath, joinPath } from "./paths.js";
 import { writtenPath } from "./workspace-programs.js";
+import { bytewise } from "./text/compare.js";
+import { holdsManifest } from "./fs/manifest.js";
 const PREFERRED = "/tsconfig.json";
 /** The configurations of one directory in the order a file joins them: `tsconfig.json` first. */
 function byPreference(a, b) {
     const first = a.endsWith(PREFERRED) ? 0 : 1;
     const second = b.endsWith(PREFERRED) ? 0 : 1;
-    return first - second || (a < b ? -1 : a > b ? 1 : 0);
+    return first - second || bytewise(a, b);
 }
 /**
  * Per configuration of `configFiles`, the absolute paths of the test files that join it:
@@ -43,15 +45,13 @@ export function joinedTestFiles(engine, host, root, configFiles, patterns) {
         if (listed.has(file) || !patterns.some((pattern) => pattern.test(path))) {
             continue;
         }
-        for (let dir = dirnamePath(file);; dir = dirnamePath(dir)) {
+        for (const dir of ancestors(dirnamePath(file), root)) {
             const [nearest] = byDir.get(dir) ?? [];
             if (nearest !== undefined) {
                 joins.set(nearest, [...(joins.get(nearest) ?? []), file]);
                 break;
             }
-            if (host.kindOf(joinPath(dir, "package.json")) === "file" ||
-                dir === root ||
-                relativePath(root, dir) === undefined) {
+            if (holdsManifest(host, dir)) {
                 break;
             }
         }

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);
+}