@cplieger/deadset-ts 8.0.0-dev.14 → 8.0.0-dev.16

package/dist/src/entries/static-module.js

@@ -0,0 +1,669 @@
+/**
+ * What a module or a configuration document writes out, read without running it, as one
+ * value model every entry source reads: a default export in each of its forms, the options
+ * a call of one module's export passes, and the top-level values names stand for. A value
+ * the text does not state is opaque, so no reader guesses it.
+ */
+import { isArrayLiteralExpression, isBindingElement, isExternalModuleReference, isImportClause, isImportEqualsDeclaration, isImportSpecifier, isStringLiteralLikeNode, isCallExpression, isClassDeclaration, isClassExpression, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableDeclaration, isVariableStatement, isSourceFile, isBlock, isModuleBlock, isCaseBlock, isCatchClause, isForStatement, isForInStatement, isForOfStatement, isVariableDeclarationList, isMetaProperty, isAssignmentOperator, isBinaryExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isShorthandPropertyAssignment, isSpreadElement, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { commonJSModuleValue } from "../inventory/commonjs.js";
+import { callsPlatformBy, lexicalBinding, writtenName } from "../platform-calls.js";
+import { unwrapped } from "../unwrap.js";
+/** A JSON or YAML document's value, which carries no positions. */
+export function documentValue(value) {
+    if (typeof value === "string") {
+        return { kind: "text", text: value, at: undefined };
+    }
+    if (typeof value === "boolean") {
+        return { kind: "boolean", value, at: undefined };
+    }
+    if (Array.isArray(value)) {
+        return { kind: "array", elements: value.map(documentValue), at: undefined };
+    }
+    if (typeof value === "object" && value !== null) {
+        return {
+            kind: "object",
+            members: Object.entries(value).map(([key, held]) => ({
+                key,
+                value: documentValue(held),
+                at: undefined,
+            })),
+            at: undefined,
+        };
+    }
+    return { kind: "opaque", at: undefined };
+}
+/**
+ * The node that declares a name through one binding: the holder itself for a name, or the
+ * binding element of an object or array pattern that binds it.
+ */
+function boundAt(holder, name, text) {
+    if (name === undefined) {
+        return undefined;
+    }
+    if (isIdentifier(name)) {
+        return name.text === text ? holder : undefined;
+    }
+    let found;
+    name.forEachChild((element) => {
+        found ??= boundAt(element, element.name, text);
+    });
+    return found;
+}
+/** The declaration of a name one statement makes in the block it is written in. */
+function blockDeclaration(statement, name) {
+    if ((isFunctionDeclaration(statement) || isClassDeclaration(statement)) &&
+        statement.name?.text === name) {
+        return statement;
+    }
+    if (isVariableStatement(statement) &&
+        (statement.declarationList.flags & NodeFlags.BlockScoped) !== 0) {
+        return statement.declarationList.declarations
+            .map((one) => boundAt(one, one.name, name))
+            .find((one) => one !== undefined);
+    }
+    if (isImportEqualsDeclaration(statement)) {
+        return statement.name.text === name ? statement : undefined;
+    }
+    if (isImportDeclaration(statement)) {
+        const clause = statement.importClause;
+        if (clause?.name?.text === name) {
+            return clause;
+        }
+        const bindings = clause?.namedBindings;
+        if (bindings !== undefined && isNamespaceImport(bindings)) {
+            return bindings.name.text === name ? bindings : undefined;
+        }
+        return bindings?.elements.find((one) => one.name.text === name);
+    }
+    return undefined;
+}
+/** The `var` declaration of a name anywhere below one scope, outside every function nested in it. */
+function varDeclaration(scope, name) {
+    let found;
+    const visit = (node) => {
+        if (found !== undefined || isFunctionLikeDeclaration(node) || isClassLike(node)) {
+            return;
+        }
+        if (isVariableDeclaration(node) && (node.parent.flags & NodeFlags.BlockScoped) === 0) {
+            found = boundAt(node, node.name, name);
+            if (found !== undefined) {
+                return;
+            }
+        }
+        node.forEachChild(visit);
+    };
+    scope.forEachChild(visit);
+    return found;
+}
+function isClassLike(node) {
+    return isClassDeclaration(node) || isClassExpression(node);
+}
+/** The statements a scope holds directly, for a block, a case block or a file. */
+function statementsOf(scope) {
+    if (isSourceFile(scope) || isBlock(scope) || isModuleBlock(scope)) {
+        return scope.statements;
+    }
+    if (isCaseBlock(scope)) {
+        return scope.clauses.flatMap((clause) => [...clause.statements]);
+    }
+    return [];
+}
+/** The declaration one scope makes of a name, ECMAScript's lexical and variable environments read from the syntax. */
+function scopeDeclaration(scope, name) {
+    if (isFunctionLikeDeclaration(scope)) {
+        const own = (isFunctionExpression(scope) || isFunctionDeclaration(scope)) && scope.name?.text === name
+            ? isFunctionExpression(scope)
+                ? scope
+                : undefined
+            : undefined;
+        const parameter = scope.parameters
+            .map((one) => boundAt(one, one.name, name))
+            .find((one) => one !== undefined);
+        const body = scope.body;
+        return (parameter ??
+            (body === undefined
+                ? undefined
+                : (statementsOf(body)
+                    .map((one) => blockDeclaration(one, name))
+                    .find(Boolean) ?? varDeclaration(body, name))) ??
+            own);
+    }
+    if (isClassExpression(scope) && scope.name?.text === name) {
+        return scope;
+    }
+    if (isCatchClause(scope)) {
+        const caught = scope.variableDeclaration;
+        return caught === undefined ? undefined : boundAt(caught, caught.name, name);
+    }
+    if (isForStatement(scope) || isForInStatement(scope) || isForOfStatement(scope)) {
+        const list = scope.initializer;
+        return list !== undefined &&
+            isVariableDeclarationList(list) &&
+            (list.flags & NodeFlags.BlockScoped) !== 0
+            ? list.declarations
+                .map((one) => boundAt(one, one.name, name))
+                .find((one) => one !== undefined)
+            : undefined;
+    }
+    const declared = statementsOf(scope)
+        .map((one) => blockDeclaration(one, name))
+        .find(Boolean);
+    return declared ?? (isSourceFile(scope) ? varDeclaration(scope, name) : undefined);
+}
+/**
+ * The declaration an identifier written in a module resolves to by the scopes that enclose
+ * it, nearest first, or undefined where none of them, the file included, declares it, as
+ * for a global. A module read outside every program has no checker to ask.
+ */
+export function declarationOf(occurrence) {
+    for (let scope = occurrence.parent;; scope = scope.parent) {
+        const found = scopeDeclaration(scope, occurrence.text);
+        if (found !== undefined || isSourceFile(scope)) {
+            return found;
+        }
+    }
+}
+/** The text a property name writes: a name, a literal, or a computed literal; undefined where it computes one. */
+function keyOf(name) {
+    if (isIdentifier(name) ||
+        isStringLiteral(name) ||
+        isNoSubstitutionTemplateLiteral(name) ||
+        isNumericLiteral(name)) {
+        return name.text;
+    }
+    if (isComputedPropertyName(name)) {
+        const key = unwrapped(name.expression);
+        if (isStringLiteral(key) || isNoSubstitutionTemplateLiteral(key) || isNumericLiteral(key)) {
+            return key.text;
+        }
+    }
+    return undefined;
+}
+/** Whether one expression is the module's own directory: a free `__dirname`, or `import.meta.dirname`. */
+function isOwnDirectory(node) {
+    const held = unwrapped(node);
+    if (isIdentifier(held)) {
+        return held.text === "__dirname" && declarationOf(held) === undefined;
+    }
+    return (isPropertyAccessExpression(held) &&
+        isMetaProperty(held.expression) &&
+        held.expression.keywordToken === SyntaxKind.ImportKeyword &&
+        held.name.text === "dirname");
+}
+/** The literal segments a `resolve` or `join` call of the module's own directory writes, or undefined. */
+function directorySegments(node) {
+    if (!isCallExpression(node)) {
+        return undefined;
+    }
+    const callee = unwrapped(node.expression);
+    const name = isPropertyAccessExpression(callee) ? callee.name : callee;
+    const [first, ...rest] = node.arguments;
+    if (!isIdentifier(name) ||
+        (name.text !== "resolve" && name.text !== "join") ||
+        first === undefined ||
+        !isOwnDirectory(first)) {
+        return undefined;
+    }
+    const segments = rest.map((one) => {
+        const part = unwrapped(one);
+        return isStringLiteral(part) || isNoSubstitutionTemplateLiteral(part) ? part.text : undefined;
+    });
+    return segments.every((one) => one !== undefined) ? segments : undefined;
+}
+/** The value one expression writes out, parentheses, `as`, `satisfies` and `!` read through. */
+export function writtenValue(node) {
+    const held = unwrapped(node);
+    const at = held.getStart();
+    const segments = directorySegments(held);
+    if (segments !== undefined) {
+        return { kind: "directory", segments, at };
+    }
+    if (isStringLiteral(held) || isNoSubstitutionTemplateLiteral(held)) {
+        return { kind: "text", text: held.text, at };
+    }
+    if (held.kind === SyntaxKind.TrueKeyword || held.kind === SyntaxKind.FalseKeyword) {
+        return { kind: "boolean", value: held.kind === SyntaxKind.TrueKeyword, at };
+    }
+    if (isArrayLiteralExpression(held)) {
+        return {
+            kind: "array",
+            elements: held.elements.map((element) => element.kind === SyntaxKind.SpreadElement
+                ? { kind: "opaque", at: element.getStart() }
+                : writtenValue(element)),
+            at,
+        };
+    }
+    if (isObjectLiteralExpression(held)) {
+        return {
+            kind: "object",
+            members: held.properties.map((member) => {
+                const start = member.getStart();
+                if (isSpreadAssignment(member)) {
+                    return { key: undefined, value: { kind: "opaque", at: start }, at: start };
+                }
+                const key = keyOf(member.name);
+                return {
+                    key,
+                    value: isPropertyAssignment(member)
+                        ? writtenValue(member.initializer)
+                        : { kind: "opaque", at: start },
+                    at: start,
+                };
+            }),
+            at,
+        };
+    }
+    return { kind: "opaque", at };
+}
+/**
+ * The initializer of a top-level `const`, `let` or `var` declaration of the file that
+ * declares a name and that the file assigns nowhere else, so the initializer is the value
+ * the name holds.
+ */
+function topLevelValue(declaration, file) {
+    if (declaration === undefined ||
+        !isVariableDeclaration(declaration) ||
+        !isIdentifier(declaration.name) ||
+        declaration.initializer === undefined) {
+        return undefined;
+    }
+    const statement = declaration.parent.parent;
+    if (!isVariableStatement(statement) || statement.parent !== file) {
+        return undefined;
+    }
+    const constant = (declaration.parent.flags & NodeFlags.Const) !== 0;
+    return constant || !assigned(file, declaration, declaration.name.text)
+        ? declaration.initializer
+        : undefined;
+}
+/** Whether the file writes a name that resolves to one declaration anywhere but its initializer. */
+function assigned(file, declaration, name) {
+    let found = false;
+    const visit = (node) => {
+        if (found) {
+            return;
+        }
+        if (isIdentifier(node)) {
+            found = node.text === name && isWriteTarget(node) && declarationOf(node) === declaration;
+            return;
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/**
+ * Whether one identifier is written: the target of an assignment, a destructuring
+ * assignment's element included, the operand of `++` or `--`, or a `for`-`in` or
+ * `for`-`of` target.
+ */
+function isWriteTarget(node) {
+    let at = node;
+    for (let parent = at.parent;; at = parent, parent = parent.parent) {
+        if (isParenthesizedExpression(parent) || isSpreadElement(parent)) {
+            continue;
+        }
+        if (isShorthandPropertyAssignment(parent) && parent.name === at) {
+            continue;
+        }
+        if ((isPropertyAssignment(parent) && parent.initializer === at) ||
+            isArrayLiteralExpression(parent) ||
+            isObjectLiteralExpression(parent)) {
+            continue;
+        }
+        break;
+    }
+    const parent = at.parent;
+    if (isBinaryExpression(parent)) {
+        return parent.left === at && isAssignmentOperator(parent.operatorToken.kind);
+    }
+    if (isPrefixUnaryExpression(parent) || isPostfixUnaryExpression(parent)) {
+        return (at === node &&
+            (parent.operator === SyntaxKind.PlusPlusToken ||
+                parent.operator === SyntaxKind.MinusMinusToken));
+    }
+    return (isForInStatement(parent) || isForOfStatement(parent)) && parent.initializer === at;
+}
+/**
+ * The values one expression stands for: a name of a top-level binding read through to its
+ * initializer, and, where `throughCalls`, a call read through to every argument it passes.
+ * A `require` call's argument names a module, which is no value the call returns.
+ */
+function readThrough(node, file, throughCalls, seen = new Set()) {
+    const held = unwrapped(node);
+    if (isIdentifier(held)) {
+        const value = topLevelValue(declarationOf(held), file);
+        if (value !== undefined && !seen.has(value)) {
+            return readThrough(value, file, throughCalls, new Set([...seen, value]));
+        }
+    }
+    else if (throughCalls && isCallExpression(held) && !isRequireCall(held)) {
+        return held.arguments.flatMap((argument) => readThrough(argument, file, throughCalls, seen));
+    }
+    return [writtenValue(held)];
+}
+/** A written name's binding by the scopes that enclose it, {@link declarationOf} answering. */
+const scopeBinding = lexicalBinding(declarationOf);
+/** Whether one call is a `require()` call, read through `bindingOf`, the file's own scopes where no checker answers. */
+function isRequireCall(call, bindingOf = scopeBinding) {
+    const callee = writtenName(call.expression);
+    return callee !== undefined && callsPlatformBy("require", callee, bindingOf);
+}
+/** The literal one call's one argument writes, where it is a string literal or a template literal with no substitution. */
+function loadedSpecifier(call) {
+    const [argument, ...rest] = call.arguments;
+    return argument !== undefined &&
+        rest.length === 0 &&
+        (isStringLiteral(argument) || isNoSubstitutionTemplateLiteral(argument))
+        ? argument.text
+        : undefined;
+}
+/** Whether one expression is a `require()` call of a module `isModule` accepts, its specifier the one literal argument. */
+function requires(node, isModule, bindingOf = scopeBinding) {
+    const held = unwrapped(node);
+    if (!isCallExpression(held)) {
+        return false;
+    }
+    const specifier = loadedSpecifier(held);
+    return specifier !== undefined && isModule(specifier) && isRequireCall(held, bindingOf);
+}
+/** What {@link boundExports} lists for a name bound to the module itself. */
+export const NAMESPACE = "*";
+/** Whether one import or re-export names a module `isModule` accepts. */
+function fromModule(declaration, isModule) {
+    return (isImportDeclaration(declaration) &&
+        isStringLiteral(declaration.moduleSpecifier) &&
+        isModule(declaration.moduleSpecifier.text));
+}
+/**
+ * What one declaration binds of a module `isModule` accepts: the export each name names,
+ * `default` for the module's value, and {@link NAMESPACE} for the module itself. A default
+ * import, an import assignment and a name a `require()` call initializes bind the value and
+ * the module both, as interop reads them; an object binding pattern of such a call binds each
+ * export it lists, and a member read of one binds that member.
+ */
+export function boundExports(declaration, isModule, bindingOf = scopeBinding) {
+    if (isImportClause(declaration)) {
+        return declaration.name !== undefined && fromModule(declaration.parent, isModule)
+            ? ["default", NAMESPACE]
+            : [];
+    }
+    if (isNamespaceImport(declaration)) {
+        return fromModule(declaration.parent.parent, isModule) ? [NAMESPACE] : [];
+    }
+    if (isImportSpecifier(declaration)) {
+        return fromModule(declaration.parent.parent.parent, isModule)
+            ? [(declaration.propertyName ?? declaration.name).text]
+            : [];
+    }
+    if (isImportEqualsDeclaration(declaration)) {
+        const reference = declaration.moduleReference;
+        return isExternalModuleReference(reference) &&
+            isStringLiteralLikeNode(reference.expression) &&
+            isModule(reference.expression.text)
+            ? ["default", NAMESPACE]
+            : [];
+    }
+    if (isBindingElement(declaration) && isObjectBindingPattern(declaration.parent)) {
+        const holder = declaration.parent.parent;
+        const exported = declaration.propertyName ?? declaration.name;
+        const key = exported === undefined ? undefined : keyOf(exported);
+        return declaration.dotDotDotToken === undefined &&
+            declaration.name !== undefined &&
+            isIdentifier(declaration.name) &&
+            key !== undefined &&
+            isVariableDeclaration(holder) &&
+            holder.initializer !== undefined &&
+            requires(holder.initializer, isModule, bindingOf)
+            ? [key]
+            : [];
+    }
+    if (!isVariableDeclaration(declaration) || declaration.initializer === undefined) {
+        return [];
+    }
+    const value = unwrapped(declaration.initializer);
+    if (isIdentifier(declaration.name) && requires(value, isModule, bindingOf)) {
+        return ["default", NAMESPACE];
+    }
+    return isIdentifier(declaration.name) &&
+        isPropertyAccessExpression(value) &&
+        requires(value.expression, isModule, bindingOf)
+        ? [value.name.text]
+        : [];
+}
+/**
+ * The relative specifiers one module's imports and re-exports name, and those its
+ * `require()` calls and `import()` calls name by a literal, in the order the file writes
+ * them. A module read outside every program answers it so, with no checker to ask.
+ */
+export function relativeSpecifiers(file) {
+    const known = specifiersOf.get(file);
+    if (known !== undefined) {
+        return known;
+    }
+    const found = [];
+    const named = (specifier) => {
+        if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+            found.push(specifier);
+        }
+    };
+    const visit = (node) => {
+        if ((isImportDeclaration(node) || isExportDeclaration(node)) &&
+            node.moduleSpecifier !== undefined &&
+            isStringLiteral(node.moduleSpecifier)) {
+            named(node.moduleSpecifier.text);
+        }
+        else if (isCallExpression(node) &&
+            (node.expression.kind === SyntaxKind.ImportKeyword || isRequireCall(node))) {
+            named(loadedSpecifier(node));
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    specifiersOf.set(file, found);
+    return found;
+}
+/** What {@link relativeSpecifiers} found in each file, which every project of a run reads alike. */
+const specifiersOf = new WeakMap();
+/** The declarations one top-level statement makes that may bind another module. */
+function bindingDeclarations(statement) {
+    if (isImportDeclaration(statement)) {
+        const clause = statement.importClause;
+        const bindings = clause?.namedBindings;
+        return [
+            ...(clause === undefined ? [] : [clause]),
+            ...(bindings === undefined
+                ? []
+                : isNamespaceImport(bindings)
+                    ? [bindings]
+                    : bindings.elements),
+        ];
+    }
+    if (isImportEqualsDeclaration(statement)) {
+        return [statement];
+    }
+    if (!isVariableStatement(statement)) {
+        return [];
+    }
+    return statement.declarationList.declarations.flatMap((declaration) => isObjectBindingPattern(declaration.name)
+        ? [declaration, ...declaration.name.elements]
+        : [declaration]);
+}
+/** The top-level bindings one file makes of a module, as {@link boundExports} reads each. */
+function bindingsOf(file, module) {
+    const named = new Map();
+    const namespaces = new Set();
+    const isModule = (specifier) => specifier === module;
+    for (const declaration of file.statements.flatMap(bindingDeclarations)) {
+        for (const exported of boundExports(declaration, isModule)) {
+            if (exported === NAMESPACE) {
+                namespaces.add(declaration);
+            }
+            else {
+                named.set(declaration, exported);
+            }
+        }
+    }
+    return { named, namespaces };
+}
+/**
+ * Every call one file makes of one module's exports: through a name an import or a
+ * `require` binding gives it, a namespace's member, a member of a `require` of the
+ * module, or that `require`'s value called itself, each where no scope enclosing the
+ * call declares the name otherwise.
+ */
+function callsOf(file, module) {
+    const { named, namespaces } = bindingsOf(file, module);
+    const found = [];
+    const visit = (node) => {
+        if (isCallExpression(node)) {
+            const callee = unwrapped(node.expression);
+            if (isIdentifier(callee)) {
+                const declaration = declarationOf(callee);
+                const exported = declaration === undefined ? undefined : named.get(declaration);
+                if (exported !== undefined) {
+                    found.push({ call: node, export: exported });
+                }
+            }
+            else if (requires(callee, (specifier) => specifier === module)) {
+                found.push({ call: node, export: "default" });
+            }
+            else if (isPropertyAccessExpression(callee)) {
+                const holder = unwrapped(callee.expression);
+                const declaration = isIdentifier(holder) ? declarationOf(holder) : undefined;
+                if ((declaration !== undefined && namespaces.has(declaration)) ||
+                    requires(holder, (specifier) => specifier === module)) {
+                    found.push({ call: node, export: callee.name.text });
+                }
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/** One parsed module, or a JSON document parsed as one, read as {@link StaticModule}. */
+export function staticModule(file) {
+    const argument = (call) => {
+        const [first] = call.arguments;
+        return first === undefined ? [] : readThrough(first, file, false);
+    };
+    return {
+        defaultExport: defaultExportOf(file),
+        options: (module, exported) => callsOf(file, module).flatMap((one) => (one.export === exported ? argument(one.call) : [])),
+        calls: (module) => callsOf(file, module),
+        argument,
+    };
+}
+/** A YAML document's value read as {@link StaticModule}: its default export, and no call. */
+export function documentModule(value) {
+    return {
+        defaultExport: [documentValue(value)],
+        options: () => [],
+        calls: () => [],
+        argument: () => [],
+    };
+}
+/** The value a CommonJS module leaves, its later member writes and any hidden member on it. */
+function moduleValueOf(written, file) {
+    const members = written.members.map((member) => {
+        const at = member.node.getStart();
+        return {
+            key: member.key,
+            value: member.value === undefined ? { kind: "opaque", at } : writtenValue(member.value),
+            at,
+        };
+    });
+    if (written.open) {
+        members.push({ key: undefined, value: { kind: "opaque", at: undefined }, at: undefined });
+    }
+    if (written.whole === undefined) {
+        return members.length === 0 ? [] : [{ kind: "object", members, at: members[0]?.at }];
+    }
+    return readThrough(written.whole, file, true).map((value) => value.kind === "object" ? { ...value, members: [...value.members, ...members] } : value);
+}
+/**
+ * The values a module's default export forms write: `export default`, `export =`, a
+ * `default` specifier, a JSON document, and, in a file Node runs as CommonJS, the module
+ * value as Node leaves it. A default function or class writes no value to read.
+ */
+function defaultExportOf(file) {
+    if (file.fileName.endsWith(".json")) {
+        return file.statements.flatMap((statement) => isExpressionStatement(statement) ? [writtenValue(statement.expression)] : []);
+    }
+    const commonJS = commonJSModuleValue(file, declarationOf);
+    if (commonJS !== undefined) {
+        return moduleValueOf(commonJS, file);
+    }
+    const found = [];
+    for (const statement of file.statements) {
+        if (isExportAssignment(statement)) {
+            found.push(...readThrough(statement.expression, file, true));
+        }
+        else if ((isFunctionDeclaration(statement) || isClassDeclaration(statement)) &&
+            statement.modifiers?.some((one) => one.kind === SyntaxKind.DefaultKeyword) === true) {
+            found.push({ kind: "opaque", at: statement.getStart() });
+        }
+        else if (isExportDeclaration(statement) &&
+            statement.moduleSpecifier === undefined &&
+            statement.exportClause !== undefined &&
+            isNamedExports(statement.exportClause)) {
+            for (const element of statement.exportClause.elements) {
+                if (element.name.text === "default") {
+                    found.push(...readThrough(element.propertyName ?? element.name, file, true));
+                }
+            }
+        }
+    }
+    return found;
+}
+/**
+ * The values one object writes for a key after its last spread or computed key, the last
+ * written last, or undefined where none follows one, which may write the key unseen. A
+ * value that is no object writes none.
+ */
+export function membersNamed(value, key) {
+    if (value.kind !== "object") {
+        return [];
+    }
+    const hidden = value.members.findLastIndex((member) => member.key === undefined);
+    const after = value.members.slice(hidden + 1).filter((member) => member.key === key);
+    return hidden >= 0 && after.length === 0 ? undefined : after.map((member) => member.value);
+}
+/**
+ * The texts one value writes: itself where it is text, or, where `elements`, each element
+ * of an array of texts. Undefined for any other value.
+ */
+export function textsOf(value, elements) {
+    if (value.kind === "text") {
+        return [value.text];
+    }
+    if (!elements || value.kind !== "array") {
+        return undefined;
+    }
+    const texts = value.elements.map((element) => element.kind === "text" ? element.text : undefined);
+    return texts.every((text) => text !== undefined) ? texts : undefined;
+}
+/**
+ * The values at one path of keys below each value, whatever else the path holds: a key
+ * reads an object's members of that name, and `*` every element of an array and every
+ * member of an object.
+ */
+export function valuesAt(values, path) {
+    const [key, ...rest] = path;
+    if (key === undefined) {
+        return values;
+    }
+    const next = values.flatMap((value) => {
+        if (key === "*" && value.kind === "array") {
+            return value.elements;
+        }
+        if (value.kind !== "object") {
+            return [];
+        }
+        return value.members
+            .filter((member) => key === "*" || member.key === key)
+            .map((member) => member.value);
+    });
+    return valuesAt(next, rest);
+}