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

package/dist/src/mdx-entries.js

@@ -0,0 +1,174 @@
+/**
+ * The files the import declarations of the target's Markdown and MDX documents load. A
+ * document is read as text: a line outside a fenced code block that starts with `import`
+ * is an import declaration, which an MDX compiler hoists into the module it builds.
+ */
+import { resolveRelativeSpecifier } from "./configuration-files.js";
+import { dirnamePath, joinPath, resolvePath } from "./paths.js";
+import { filesBelow } from "./fs/tree.js";
+/** The extensions of a document whose imports an MDX compiler reads. */
+const DOCUMENT = /\.mdx?$/u;
+/** A fence line, its marker run and what follows it captured. */
+const FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/u;
+/** A string literal in either quote, its escapes included. */
+const STRING = String.raw `"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'`;
+/** An import declaration at the start of a line, its clause and its specifier captured. */
+const IMPORT_LINE = new RegExp(String.raw `^import\s+(?:((?:[^"'\n]|${STRING})*?)\s+from\s*)?["']([^"'\n]+)["']`, "u");
+/** The braces of an import clause, what they hold captured. */
+const BRACES = new RegExp(String.raw `\{((?:[^}"']|${STRING})*)\}`, "u");
+/** One comma-separated part of a clause's braces. */
+const PART = new RegExp(String.raw `(?:[^,"']|${STRING})+`, "gu");
+/** A named import of a clause's braces: the exported name and an optional local alias. */
+const NAMED_IMPORT = new RegExp(String.raw `^([\w$]+|${STRING})(?:\s+as\s+[\w$]+)?$`, "u");
+/** The single-character escapes of a string literal and the character each stands for. */
+const SINGLE_ESCAPES = new Map([
+    ["b", "\b"],
+    ["f", "\f"],
+    ["n", "\n"],
+    ["r", "\r"],
+    ["t", "\t"],
+    ["v", "\v"],
+    ["0", "\0"],
+    ["'", "'"],
+    ['"', '"'],
+    ["\\", "\\"],
+]);
+/**
+ * One escape of a string literal: two hexadecimal digits, a code unit, a code point, or one
+ * character and the digit after it.
+ */
+const ESCAPE = /\\(?:x([\da-fA-F]{2})|u([\da-fA-F]{4})|u\{([\da-fA-F]+)\}|(.)(\d?))/gu;
+/** What one escape stands for, or undefined for one a module cannot hold. */
+function unescaped([, hex, unit, point, single, digit]) {
+    if (single === undefined) {
+        const code = Number.parseInt(hex ?? unit ?? point ?? "", 16);
+        return code <= 0x10ffff ? String.fromCodePoint(code) : undefined;
+    }
+    return /[1-9xu]/u.test(single) || (single === "0" && digit !== "")
+        ? undefined
+        : `${SINGLE_ESCAPES.get(single) ?? single}${digit ?? ""}`;
+}
+/**
+ * The value of a quoted export name, its escapes decoded, or undefined for an escape this
+ * reading does not decode. A module is strict code, so no legacy octal escape is valid.
+ */
+function quotedName(literal) {
+    const body = literal.slice(1, -1);
+    let value = "";
+    let from = 0;
+    for (const escape of body.matchAll(ESCAPE)) {
+        const decoded = unescaped(escape);
+        if (decoded === undefined) {
+            return undefined;
+        }
+        value += body.slice(from, escape.index) + decoded;
+        from = escape.index + escape[0].length;
+    }
+    return value + body.slice(from);
+}
+/**
+ * The export names one import clause reads: `default` for a default binding and each name
+ * its braces list, or undefined for a namespace import, which reads every export, and for
+ * a clause this reading does not parse, which may read any.
+ */
+function clauseNames(clause) {
+    const braces = BRACES.exec(clause);
+    const head = (braces === null ? clause : clause.slice(0, braces.index))
+        .replace(/,\s*$/u, "")
+        .trim();
+    if (head.includes("*")) {
+        return undefined;
+    }
+    const names = head === "" ? [] : ["default"];
+    if (head !== "" && !/^[\w$]+$/u.test(head)) {
+        return undefined;
+    }
+    for (const part of (braces?.[1]?.match(PART) ?? []).map((one) => one.trim())) {
+        const named = NAMED_IMPORT.exec(part);
+        if (part === "") {
+            continue;
+        }
+        if (named?.[1] === undefined) {
+            return undefined;
+        }
+        const name = /^["']/u.test(named[1]) ? quotedName(named[1]) : named[1];
+        if (name === undefined) {
+            return undefined;
+        }
+        names.push(name);
+    }
+    return names;
+}
+/** The relative specifiers one document's import lines name, its fenced code blocks skipped. */
+function importedBy(text) {
+    const found = [];
+    let open;
+    for (const line of text.split(/\r?\n/u)) {
+        const fence = FENCE.exec(line);
+        const marker = fence?.[1];
+        if (marker !== undefined && open === undefined) {
+            open = marker;
+            continue;
+        }
+        // https://spec.commonmark.org/0.31.2/#fenced-code-blocks: only a run of the opening
+        // character, at least as long and followed by nothing, closes a fence.
+        if (marker !== undefined &&
+            open !== undefined &&
+            marker.startsWith(open.slice(0, 1)) &&
+            marker.length >= open.length &&
+            fence?.[2]?.trim() === "") {
+            open = undefined;
+            continue;
+        }
+        const matched = open === undefined ? IMPORT_LINE.exec(line) : null;
+        const specifier = matched?.[2];
+        if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+            found.push({ specifier, names: clauseNames(matched?.[1] ?? "") });
+        }
+    }
+    return found;
+}
+/**
+ * The documents each host's target roots hold, which every project of a run reads alike,
+ * kept for the host's life as {@link Host} allows.
+ */
+const documentsOf = new WeakMap();
+/** Every readable document below `root` and the import lines it writes, read once per host. */
+function documentImports(host, root) {
+    const byRoot = documentsOf.get(host) ?? new Map();
+    documentsOf.set(host, byRoot);
+    const known = byRoot.get(root);
+    if (known !== undefined) {
+        return known;
+    }
+    const found = filesBelow(host, root, (name) => DOCUMENT.test(name)).flatMap((below) => {
+        const path = joinPath(root, below);
+        try {
+            return [{ path, imports: importedBy(host.readFile(path)) }];
+        }
+        catch {
+            return [];
+        }
+    });
+    byRoot.set(root, found);
+    return found;
+}
+/**
+ * Every own file one document below the target root imports by a relative specifier,
+ * read against the document's directory, on disk or through the emit mapping.
+ */
+export function documentEntries(host, targetRoot, files) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    const found = [];
+    for (const { path, imports } of documentImports(host, root)) {
+        const dir = dirnamePath(path);
+        for (const { specifier, names } of imports) {
+            const reached = resolveRelativeSpecifier(host, dir, specifier);
+            const held = reached === undefined ? undefined : files.byName.get(reached);
+            for (const file of held === undefined ? files.named(resolvePath(dir, specifier)) : [held]) {
+                found.push({ file, source: specifier, names });
+            }
+        }
+    }
+    return found;
+}

package/dist/src/module-declarations.js

@@ -103,7 +103,7 @@ function namedBy(held) {
             `${scope}#${aliasFragment(one, name)}`,
         ]));
         const members = (children.get(id) ?? []).filter((child) => wanted.has(child.ref));
-        return [{ id, members: members.map((child) => child.id) }];
+        return [{ id, members: members.map((child) => child.id), wildcard: name.includes("*") }];
     });
 }
 /**
@@ -149,26 +149,22 @@ export function moduleDeclarationReferences(project, held, root, testFiles) {
     imports.forEach((one, index) => {
         const resolved = moduleOf(declared.length + index);
         const position = renderPosition(one.file, root, one.specifier.getStart());
-        const read = (to, resolution) => {
-            found.push({
-                from: one.from,
-                to,
-                position,
-                use: "read",
-                resolution,
-                test: testFiles.has(position.path),
-            });
+        const read = (to, resolution, test) => {
+            found.push({ from: one.from, to, position, use: "read", resolution, test });
         };
+        const test = testFiles.has(position.path);
         const same = new Set(declared
             .filter((_, at) => resolved !== undefined && resolved === moduleOf(at))
             .map((declaration) => declaration.id));
         for (const id of same) {
-            read(id, "batch");
+            read(id, "batch", test);
         }
         for (const declaration of named(one.specifier.text, one.names)) {
-            if (!same.has(declaration.id)) {
+            // A wildcard declaration is how the compiler types the file a matching specifier
+            // names, so the import uses it whoever writes it, a test included.
+            if (declaration.wildcard || !same.has(declaration.id)) {
                 for (const to of [declaration.id, ...declaration.members]) {
-                    read(to, "syntax");
+                    read(to, "syntax", test && !declaration.wildcard);
                 }
             }
         }

package/dist/src/outside-tests.js

@@ -8,7 +8,7 @@
  */
 import { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { RESOLVED_EXTENSIONS } from "./configuration-files.js";
-import { emittedFrom } from "./emit-map.js";
+import { emittedFrom } from "./load/emit-map.js";
 import { namesImported } from "./module-declarations.js";
 import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.js";
 import { renderPosition } from "./position.js";

package/dist/src/overrides.js

@@ -1,10 +1,9 @@
 /**
- * The overrides of the target's class members. A call through the base class names the
- * base's member and runs the override of whichever subclass the value is, so the base
- * member's declaration references every override. A method, an accessor or a property,
- * static or not, overriding a member of a class declared outside the target, at any depth
- * of its `extends` chain, is used by outside code holding the instance or the class
- * through that class, so its own class references it.
+ * The overrides of the target's class members. A call through the base class runs the
+ * override of whichever subclass the value is, so the base member references every
+ * override. A member, static or not, overriding one of a class declared outside the target
+ * at any depth of its `extends` chain, a library's interface-and-variable class such as
+ * `Error` included, is used by outside code holding the value, so its own class references it.
  */
 import { isClassDeclaration, isClassExpression, isExpressionWithTypeArguments, isPropertyAccessExpression, isQualifiedName, SyntaxKind, } from "@typescript/native/ast";
 import { memberComponent } from "./class-members.js";
@@ -85,10 +84,12 @@ export function overrideReferences(project, held, chains, testFiles) {
             const declared = (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : project.queries.aliased(symbol);
             if (inTarget.length === 0 &&
                 declared !== UNANSWERED &&
-                (declared.flags & SymbolFlags.Class) !== 0 &&
-                // The target's augmentation of an outside class merges an interface into it,
-                // so only a class declaration says where the class is.
-                declared.declarations.some((handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path))) {
+                (((declared.flags & SymbolFlags.Class) !== 0 &&
+                    // The target's augmentation of an outside class merges an interface into it,
+                    // so only a class declaration says where the class is.
+                    declared.declarations.some((handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path))) ||
+                    ((declared.flags & SymbolFlags.Interface) !== 0 &&
+                        declared.declarations.some((handle) => handle.kind === SyntaxKind.VariableDeclaration && !own.has(handle.path))))) {
                 outsideBases.set(id, declared);
             }
         }
@@ -145,11 +146,13 @@ export function overrideReferences(project, held, chains, testFiles) {
  */
 function outsideMemberNames(project, bases, outsideBases) {
     const direct = new Map();
+    const error = errorType(project);
     for (const [classId, base] of outsideBases) {
         const instance = project.queries.declaredTypeOf(base);
         const statics = project.queries.typeOfSymbol(base);
         const components = [
             ...namesOf(project, instance === UNANSWERED ? undefined : instance).map(nameComponent),
+            ...(instance !== UNANSWERED && reaches(project, instance, error) ? ["toString"] : []),
             ...namesOf(project, statics === UNANSWERED ? undefined : statics).map((name) => `${nameComponent(name)}:static`),
         ];
         if (components.length > 0) {
@@ -175,6 +178,34 @@ function outsideMemberNames(project, bases, outsideBases) {
     }
     return names;
 }
+/** The global `Error` instance type's identifier, where the program's library declares one. */
+function errorType(project) {
+    const symbol = project.queries.resolveName("Error", SymbolFlags.Type, undefined, false);
+    if (symbol === UNANSWERED || symbol === undefined) {
+        return undefined;
+    }
+    const type = project.queries.declaredTypeOf(symbol);
+    return type === UNANSWERED ? undefined : type.id;
+}
+/**
+ * Whether one type is the `Error` instance type or extends it at any depth: the runtime
+ * prints an error through its `toString`, a member the library's `Error` interface omits.
+ */
+function reaches(project, type, target) {
+    const seen = new Set();
+    const pending = [type];
+    for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+        if (next.id === target) {
+            return true;
+        }
+        if (!seen.has(next.id)) {
+            seen.add(next.id);
+            const bases = project.queries.baseTypes(next);
+            pending.push(...(bases === UNANSWERED ? [] : bases));
+        }
+    }
+    return false;
+}
 /** The names of a type's properties; none where the type or its properties are unanswered. */
 function namesOf(project, type) {
     const properties = type === undefined ? UNANSWERED : project.queries.propertiesOf(type);

package/dist/src/partial.js

@@ -1,4 +1,5 @@
 import { relativePath } from "./paths.js";
+import { bytewise } from "./text/compare.js";
 /** A count with its noun, so a line reads for one as well as for several. */
 function counted(n, one, many) {
     return `${String(n)} ${n === 1 ? one : many}`;
@@ -10,7 +11,7 @@ function counted(n, one, many) {
  */
 export function partialNotes(partial) {
     const notes = [...partial.notBuilt]
-        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+        .sort((a, b) => bytewise(a.id, b.id))
         .map((one) => `the derived configuration ${one.id} was not built and is not analyzed: ${one.error}`);
     if (partial.unanswered.length > 0) {
         const byProject = new Map();

package/dist/src/paths.js

@@ -1,11 +1,7 @@
 /**
- * Filesystem paths, as the supported platform spells them: a solidus separates
- * segments and a leading solidus makes a path absolute.
- *
- * They are written here rather than taken from the platform's own library because
- * every module below the command line stays free of the platform, and because the
- * supported platform set is one, so a second spelling would be a rule nothing
- * exercises.
+ * Filesystem paths as the supported platform spells them: a solidus between segments, a
+ * leading one for an absolute path. They are written here rather than taken from the
+ * platform's library so every module below the command line stays free of the platform.
  */
 const SEPARATOR = "/";
 /** Whether one path names a place without a directory to resolve it against. */
@@ -61,6 +57,24 @@ export function dirnamePath(path) {
     }
     return cut === 0 ? SEPARATOR : normalized.slice(0, cut);
 }
+/**
+ * `dir` and every directory above it, nearest first, normalized. With `top`, the list ends
+ * at `top` and is empty where `dir` is neither `top` nor below it; without, it ends at the
+ * root of the path.
+ */
+export function ancestors(dir, top) {
+    const end = top === undefined ? undefined : normalizePath(top);
+    const found = [];
+    for (let at = normalizePath(dir);; at = dirnamePath(at)) {
+        if (end !== undefined && at !== end && relativePath(end, at) === undefined) {
+            return [];
+        }
+        found.push(at);
+        if (at === end || dirnamePath(at) === at) {
+            return found;
+        }
+    }
+}
 /**
  * The extension of one path's last segment, from its last full stop, or the empty string
  * where it has none. A segment that only starts with a full stop has none.
@@ -92,14 +106,11 @@ export function queriedModulePath(specifier) {
     return raw ? undefined : specifier.slice(0, query);
 }
 /**
- * One path as it reads below a root, or undefined when it is not below the root.
- * Both are normalized first, so a root written with a trailing separator or a `.`
- * segment reaches the same answer, and the comparison is then lexical, so a root
- * and a path spelled through different symbolic links name nothing in common. The
- * root itself is not below itself.
- *
- * The caller resolves both against the same directory before calling: a relative
- * root and an absolute path are two spellings this cannot reconcile.
+ * One path as it reads below a root, or undefined when it is not strictly below the root:
+ * the root itself is not below itself. Both are normalized, then compared lexically, so a
+ * root and a path spelled through different symbolic links name nothing in common. The
+ * caller resolves both against the same directory first: a relative root and an absolute
+ * path cannot be reconciled.
  */
 export function relativePath(root, path) {
     const at = normalizePath(root);

package/dist/src/position.js

@@ -1,4 +1,5 @@
 import { relativePath } from "./paths.js";
+import { bytewise } from "./text/compare.js";
 /**
  * A file the program holds whose path is not below the target root, which leaves
  * the analysis unable to name a declaration it found. It ends the run rather than
@@ -58,7 +59,7 @@ export function positionKey(position) {
  */
 export function byPosition(a, b) {
     if (a.path !== b.path) {
-        return a.path < b.path ? -1 : 1;
+        return bytewise(a.path, b.path);
     }
     if (a.line !== b.line) {
         return a.line - b.line;

package/dist/src/print.js

@@ -1,82 +1,15 @@
-import { renderOrigin, } from "./config.js";
-/** One declaration entry as a document writes it: the members of its shape alone. */
-function declarationOf(entry) {
-    switch (entry.shape) {
-        case "symbol":
-            return { symbol: entry.symbol };
-        case "module":
-            return { module: entry.module, name: entry.name };
-        case "global":
-            return { global: entry.global };
-    }
-}
-/** One provider entry as a document writes it: the members of its shape alone. */
-function providerOf(entry) {
-    const installed = { name: entry.name, languages: entry.languages, command: entry.command };
-    if (entry.shape === "installed") {
-        return installed;
-    }
-    return { ...installed, source: entry.source, version: entry.version, digest: entry.digest };
-}
+import { renderOrigin } from "./config.js";
+import { bytewise } from "./text/compare.js";
 /**
- * The resolved configuration and its provenance as one JSON object, indented,
- * ending in a newline.
- *
- * The output is an instance of the closed key list, so reading it back as a
- * repository configuration resolves to the same configuration: the provenance
- * object is a declared key resolution ignores. Keys are written in the schema's
- * order and the severity and provenance objects in ascending key order, so one
- * configuration renders to one string whatever order a source named its settings
- * in.
+ * The resolved configuration and its provenance as one JSON object, indented, ending
+ * in a newline: the configuration in the order resolution gives it, then the provenance
+ * object in ascending key order. Read back as a repository configuration it resolves to
+ * the same configuration, because resolution checks the provenance object and then
+ * ignores it.
  */
 export function printConfig(config, provenance) {
-    const document = {
-        contract_version: config.contractVersion,
-        target: { kind: config.targetKind },
-        analysis: {
-            languages: config.analysis.languages,
-            min_confidence: config.analysis.minConfidence,
-            generated_files: config.analysis.generatedFiles,
-            consumer_tests: config.analysis.consumerTests,
-            configurations: config.analysis.configurations.map((entry) => entry.shape === "project"
-                ? { id: entry.id, project: entry.project }
-                : { id: entry.id, os: entry.os, arch: entry.arch, tags: entry.tags }),
-            matrix: { complete: config.analysis.matrixComplete },
-            template_dirs: config.analysis.templateDirs,
-            template_delimiters: {
-                left: config.analysis.templateDelimiters.left,
-                right: config.analysis.templateDelimiters.right,
-            },
-        },
-        consumers: { complete: config.consumersComplete },
-        roots: { patterns: config.rootPatterns },
-        severity: Object.fromEntries([...config.severity].sort(([a], [b]) => (a < b ? -1 : 1))),
-        exemptions: { disabled: config.exemptionsDisabled },
-        reporters: {
-            formats: config.reporters.formats,
-            sort: config.reporters.sort,
-            cascade: config.reporters.cascade,
-            max_findings: config.reporters.maxFindings,
-            fail_on: config.reporters.failOn,
-        },
-        providers: { analyzers: config.providers.analyzers.map(providerOf) },
-        go: {},
-        ts: {
-            test_files: config.ts.testFiles,
-            entry_files: config.ts.entryFiles,
-            component_extensions: config.ts.componentExtensions,
-            disabled_conventions: config.ts.disabledConventions,
-            injection_registrations: config.ts.injectionRegistrations.map(declarationOf),
-            lifecycle_contracts: config.ts.lifecycleContracts.map((entry) => ({
-                components: entry.components.map(declarationOf),
-                bases: entry.bases.map(declarationOf),
-                members: entry.members,
-            })),
-            serializers: config.ts.serializers.map(declarationOf),
-        },
-        provenance: Object.fromEntries([...provenance]
-            .sort(([a], [b]) => (a < b ? -1 : 1))
-            .map(([path, origin]) => [path, renderOrigin(origin)])),
-    };
-    return `${JSON.stringify(document, undefined, 2)}\n`;
+    const origins = [...provenance]
+        .sort(([a], [b]) => bytewise(a, b))
+        .map(([path, origin]) => [path, renderOrigin(origin)]);
+    return `${JSON.stringify({ ...config, provenance: Object.fromEntries(origins) }, undefined, 2)}\n`;
 }

package/dist/src/product.js

@@ -0,0 +1,13 @@
+import { LANGUAGE_ROWS } from "./contract/contract.generated.js";
+/** The language this analyzer reads. */
+export const LANGUAGE = "ts";
+/** The analyzer's name: the one its language's row names, which every output spells it with. */
+export const PRODUCT = LANGUAGE_ROWS[LANGUAGE].analyzer;
+/** Writes one diagnostic line to the error stream, named for the analyzer. */
+export function diagnose(err, text) {
+    err.write(`${PRODUCT}: ${text}\n`);
+}
+/** The text one thrown value carries. */
+export function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/query.js

@@ -220,6 +220,7 @@ export function queriesOf(checker, configFile, batch, log, ask = ASK_DIRECTLY) {
         symbolOfType: (type) => one("getSymbol", () => typeLocation(type), () => type.getSymbol()),
         signaturesOf: (type, kind) => one("getSignaturesOfType", () => typeLocation(type), () => checker.getSignaturesOfType(type, kind)),
         resolvedSignature: (node) => one("getResolvedSignature", () => nodeLocation(node), () => checker.getResolvedSignature(node)),
+        resolvedSignatures: (nodes, cap = DEFAULT_BATCH_CAP) => each("getResolvedSignature", nodes, cap, nodeLocation, (node) => checker.getResolvedSignature.gen(node), (node) => checker.getResolvedSignature(node)),
         parameterType: (signature, index) => one("getParameterType", () => `signature ${String(signature.id)} parameter ${String(index)}`, () => checker.getParameterType(signature, index)),
         genericOf: (signature) => signature.target === undefined
             ? undefined

package/dist/src/ref.js

@@ -45,9 +45,12 @@ export const REF_EXPRESSIONS = [
     `^${SCOPE}#$`,
     `^${SCOPE}#${TS_HEAD}$`,
     `^${SCOPE}#(?:${TS_QUOTED}\\.)?${TS_HEAD}:alias$`,
+    `^${SCOPE}#${TS_HEAD}:import$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+:static$`,
+    `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+\\.${TS_QUOTED}:case$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?<${TS_IDENT}>$`,
+    `^${SCOPE}#(?:${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?)?\\(${TS_IDENT}\\)$`,
     `^${MANIFEST_SCOPE}#${TS_PACKAGE}:(?:dependency|dev-dependency|peer-dependency)$`,
 ];
 const REF_FORMS = REF_EXPRESSIONS.map((expression) => new RegExp(expression, "u"));
@@ -86,6 +89,14 @@ function quoted(name) {
 export function computedComponent(text) {
     return `[${text.replaceAll(ASCII_WHITESPACE, "")}]`;
 }
+/** The reference of an import binding, read against the reference of the module that holds it. */
+export function importRef(moduleRef, name) {
+    return `${moduleRef}${nameComponent(name)}:import`;
+}
+/** The reference of a parameter, read against the reference of the declaration that holds it. */
+export function parameterRef(holderRef, name) {
+    return `${holderRef}(${name})`;
+}
 /** The fragment of an export alias, inside the `declare module` block named, if one is. */
 export function aliasFragment(name, block) {
     const head = block === undefined ? "" : `${quoted(block)}.`;