@intentius/chant-lexicon-sql 0.124.31 → 0.124.32

package/dist/clickhouse/expressions.js

@@ -0,0 +1,107 @@
+/**
+ * Small scanners over ClickHouse expression text as the parser keeps it
+ * (sort keys, engine arguments, column types), shared by the post-synth
+ * checks (`../lint/post-synth/clickhouse-helpers.ts`) and the public read API
+ * (`../read/clickhouse.ts`). They answer narrow questions ("is this a bare
+ * column name", "what family is this type"), not what an expression
+ * evaluates to.
+ */
+import { TABLE_ENGINES, TYPE_FAMILIES } from "../generated/clickhouse.js";
+/** The engine's catalog entry, when the pinned server has the engine. */
+export function engineSpec(engine) {
+    return engine ? TABLE_ENGINES[engine.name] : undefined;
+}
+/** A MergeTree family engine, replicated or not. */
+export function isMergeTree(engine) {
+    return engineSpec(engine)?.mergeTree === true;
+}
+/** The engine without its `Replicated` prefix: `ReplicatedReplacingMergeTree` is `ReplacingMergeTree`. */
+export function baseEngineName(engine) {
+    const spec = engineSpec(engine);
+    return spec?.replicates ?? engine.name;
+}
+/** Split on commas that are not inside parentheses, brackets or quotes. */
+export function splitTop(text, separator = ",") {
+    const parts = [];
+    let depth = 0;
+    let quote;
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (quote) {
+            if (c === "\\")
+                i++;
+            else if (c === quote)
+                quote = undefined;
+            continue;
+        }
+        if (c === "'" || c === '"' || c === "`")
+            quote = c;
+        else if (c === "(" || c === "[")
+            depth++;
+        else if (c === ")" || c === "]")
+            depth--;
+        else if (c === separator && depth === 0) {
+            parts.push(text.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    const last = text.slice(start).trim();
+    if (last !== "" || parts.length > 0)
+        parts.push(last);
+    return parts.filter((p) => p !== "");
+}
+/** `(a, b)` is the list `a`, `b`; `a, b` is the same; `tuple()` and `()` are empty. */
+export function keyElements(expr) {
+    let text = expr.trim();
+    if (/^tuple\s*\(\s*\)$/i.test(text) || text === "()")
+        return [];
+    if (text.startsWith("(") && closingParen(text, 0) === text.length - 1)
+        text = text.slice(1, -1);
+    return splitTop(text).map((e) => e.replace(/\s+(ASC|DESC)$/i, "").replace(/\s+/g, " ").trim());
+}
+function closingParen(text, open) {
+    let depth = 0;
+    let quote;
+    for (let i = open; i < text.length; i++) {
+        const c = text[i];
+        if (quote) {
+            if (c === "\\")
+                i++;
+            else if (c === quote)
+                quote = undefined;
+        }
+        else if (c === "'" || c === '"' || c === "`")
+            quote = c;
+        else if (c === "(")
+            depth++;
+        else if (c === ")" && --depth === 0)
+            return i;
+    }
+    return -1;
+}
+/** The column a bare name refers to: `a` or `` `a b` ``, else undefined. */
+export function bareName(element) {
+    const text = element.trim();
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(text))
+        return text;
+    const quoted = /^`((?:[^`]|``)*)`$/.exec(text) ?? /^"((?:[^"]|"")*)"$/.exec(text);
+    return quoted ? quoted[1].replace(/``|""/g, (m) => m[0]) : undefined;
+}
+/** A type with its `Nullable(...)` and `LowCardinality(...)` wrappers removed. */
+export function unwrapType(type) {
+    let t = (type ?? "").trim();
+    for (;;) {
+        const m = /^(Nullable|LowCardinality)\s*\(([\s\S]*)\)$/i.exec(t);
+        if (!m)
+            return t;
+        t = m[2].trim();
+    }
+}
+/** The canonical family of a column's type (`BIGINT UNSIGNED` is `UInt64`), or its leading word when unknown. */
+export function typeFamily(type) {
+    const head = /^[A-Za-z_][A-Za-z0-9_ ]*?(?=\s*\(|$)/.exec(unwrapType(type))?.[0]?.trim() ?? "";
+    const table = TYPE_FAMILIES;
+    return (table[head] ?? table[head.toUpperCase()])?.canonical ?? head;
+}
+export const isNullableType = (type) => /^Nullable\s*\(/i.test((type ?? "").trim());

package/dist/clickhouse/http.js

@@ -0,0 +1,55 @@
+/**
+ * The smallest ClickHouse client chant needs: one SQL statement over the HTTP
+ * interface, rows back as JSON objects.
+ *
+ * No driver dependency. ClickHouse's HTTP interface takes the statement as the
+ * request body and `default_format=JSONEachRow` returns one JSON object per
+ * line, which is all generation (and, later, observation and import) reads.
+ */
+/** A query the server refused, with the server's own message. */
+export class ClickHouseQueryError extends Error {
+    constructor(status, serverMessage, sql) {
+        super(`ClickHouse answered ${status}: ${serverMessage.trim().split("\n")[0]}`);
+        this.status = status;
+        this.serverMessage = serverMessage;
+        this.sql = sql;
+        this.name = "ClickHouseQueryError";
+    }
+}
+/** Run one statement and return its rows. A statement that returns nothing yields `[]`. */
+export async function clickhouseQuery(endpoint, sql, opts = {}) {
+    const headers = { "content-type": "text/plain; charset=utf-8" };
+    if (endpoint.user !== undefined)
+        headers["X-ClickHouse-User"] = endpoint.user;
+    const password = endpoint.token ? await endpoint.token.get() : endpoint.password;
+    if (password !== undefined)
+        headers["X-ClickHouse-Key"] = password;
+    const params = new URLSearchParams({ default_format: "JSONEachRow", ...(opts.queryId !== undefined ? { query_id: opts.queryId } : {}), ...opts.settings });
+    const res = await fetch(`${endpoint.url.replace(/\/$/, "")}/?${params.toString()}`, {
+        method: "POST",
+        headers,
+        body: sql,
+        ...(opts.signal ? { signal: opts.signal } : {}),
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        // A refused token is not reused: the next request mints another.
+        if (endpoint.token && (res.status === 401 || res.status === 403 || /AUTHENTICATION_FAILED|Code: 516/.test(text)))
+            endpoint.token.invalidate();
+        throw new ClickHouseQueryError(res.status, text, sql);
+    }
+    return text
+        .split("\n")
+        .filter((line) => line.length > 0)
+        .map((line) => JSON.parse(line));
+}
+/** True when the server answers `/ping`. */
+export async function clickhousePing(endpoint) {
+    try {
+        const res = await fetch(`${endpoint.url.replace(/\/$/, "")}/ping`);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/clickhouse/import/generator.js

@@ -0,0 +1,192 @@
+/**
+ * The import IR as TypeScript: one `schema.ts` holding every imported
+ * object as a `database`, `table` or `view` declaration, in dependency order,
+ * with references between them interpolated. One file because the references
+ * cross databases freely, and declarations in one file reference each other
+ * without import cycles.
+ */
+import { relationKey } from "../../core/typed.js";
+import { isTrivia, tokenizeText } from "../tokens.js";
+import { parseCreate, unquote } from "../parser.js";
+import { CLICKHOUSE_ENTITY_TYPES } from "../entities.js";
+export const CLICKHOUSE_TAG_OF = {
+    [CLICKHOUSE_ENTITY_TYPES.database]: "database",
+    [CLICKHOUSE_ENTITY_TYPES.table]: "table",
+    [CLICKHOUSE_ENTITY_TYPES.view]: "view",
+    [CLICKHOUSE_ENTITY_TYPES.materializedView]: "view",
+    [CLICKHOUSE_ENTITY_TYPES.dictionary]: "dictionary",
+    [CLICKHOUSE_ENTITY_TYPES.function]: "func",
+    // Read from `.sql` files (#3711).
+    [CLICKHOUSE_ENTITY_TYPES.user]: "user",
+    [CLICKHOUSE_ENTITY_TYPES.role]: "role",
+    [CLICKHOUSE_ENTITY_TYPES.rowPolicy]: "policy",
+    [CLICKHOUSE_ENTITY_TYPES.quota]: "quota",
+    [CLICKHOUSE_ENTITY_TYPES.settingsProfile]: "settingsProfile",
+    [CLICKHOUSE_ENTITY_TYPES.grant]: "grant",
+};
+/** A backquoted or double-quoted identifier, written bare when it can be and double-quoted otherwise. */
+function identifierText(t) {
+    if (t.kind !== "qident")
+        return t.text;
+    const name = unquote(t.text);
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `"${name.replace(/"/g, '""')}"`;
+}
+/** Text that sits inside a template literal: a backquote and `${` escaped. */
+const templateSafe = (s) => s.replace(/\\(?=`|\$\{)/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+/** Words after which a bare name is a relation: `FROM t`, `JOIN t`, a materialized view's `TO t`. */
+const RELATION_WORDS = new Set(["FROM", "JOIN", "TO"]);
+/**
+ * The template body for one statement, and the exports it references. A
+ * qualified name of another object becomes `${export}`, and so does a bare
+ * name after `FROM`, `JOIN` or `TO` that an unqualified object has; the
+ * database part of the statement's own name becomes the database's export.
+ */
+function templateBody(item, byQualified, dbExport) {
+    const tokens = tokenizeText(item.ddl, 0);
+    let node;
+    try {
+        node = parseCreate(tokens);
+    }
+    catch {
+        node = undefined;
+    }
+    const own = node ? { from: node.name.from, to: node.name.to } : undefined;
+    const sig = [];
+    tokens.forEach((t, i) => {
+        if (!isTrivia(t))
+            sig.push(i);
+    });
+    const isName = (t) => t !== undefined && (t.kind === "ident" || t.kind === "qident");
+    const isSelf = (target) => target === item || target.exportName === item.exportName;
+    const replace = new Map();
+    for (let k = 0; k < sig.length; k++) {
+        const a = tokens[sig[k]];
+        const dot = tokens[sig[k + 1] ?? -1];
+        const b = tokens[sig[k + 2] ?? -1];
+        const prev = tokens[sig[k - 1] ?? -1];
+        if (prev?.kind === "punct" && prev.text === ".")
+            continue;
+        if (!isName(a) || dot?.kind !== "punct" || dot.text !== "." || !isName(b)) {
+            const inOwnName = own !== undefined && sig[k] >= own.from && sig[k] < own.to;
+            const bare = isName(a) && !inOwnName && prev?.kind === "ident" && RELATION_WORDS.has(prev.text.toUpperCase());
+            const target = bare ? byQualified.get(unquote(a.text)) : undefined;
+            if (target && !isSelf(target))
+                replace.set(sig[k], { to: sig[k] + 1, ref: target.exportName });
+            continue;
+        }
+        const db = unquote(a.text);
+        const name = unquote(b.text);
+        const inOwnName = own !== undefined && sig[k] >= own.from && sig[k] < own.to;
+        const target = byQualified.get(`${db}.${name}`);
+        if (!inOwnName && target && !isSelf(target)) {
+            replace.set(sig[k], { to: sig[k + 2] + 1, ref: target.exportName });
+            k += 2;
+        }
+        else if (inOwnName && dbExport.has(db)) {
+            replace.set(sig[k], { to: sig[k] + 1, ref: dbExport.get(db) });
+            k += 2;
+        }
+    }
+    const parts = [""];
+    const refs = [];
+    for (let i = 0; i < tokens.length;) {
+        const r = replace.get(i);
+        if (r) {
+            refs.push(r.ref);
+            parts.push("");
+            i = r.to;
+            continue;
+        }
+        const t = tokens[i];
+        parts[parts.length - 1] += t.kind === "qident" ? templateSafe(identifierText(t)) : templateSafe(t.text);
+        i++;
+    }
+    return { parts, refs };
+}
+/** A template body as the text between the backquotes. */
+export const bodyText = (body) => body.parts.map((p, i) => (i === 0 ? p : `\${${body.refs[i - 1]}}${p}`)).join("");
+/**
+ * The template of each object in `items`, with the references to `targets`
+ * (the items themselves, and any object declared elsewhere that they may
+ * name) interpolated, and the items in the order a file declares them: each
+ * after what it references.
+ */
+/** The kinds a `FROM`, `JOIN` or `TO` never names. */
+const NOT_RELATIONS = new Set([
+    CLICKHOUSE_ENTITY_TYPES.function,
+    CLICKHOUSE_ENTITY_TYPES.user,
+    CLICKHOUSE_ENTITY_TYPES.role,
+    CLICKHOUSE_ENTITY_TYPES.rowPolicy,
+    CLICKHOUSE_ENTITY_TYPES.quota,
+    CLICKHOUSE_ENTITY_TYPES.settingsProfile,
+    CLICKHOUSE_ENTITY_TYPES.grant,
+]);
+export function clickhouseTemplates(items, targets = items) {
+    const byQualified = new Map();
+    const dbExport = new Map();
+    for (const it of targets) {
+        if (it.type === CLICKHOUSE_ENTITY_TYPES.database)
+            dbExport.set(it.name, it.exportName);
+        // A function is called, never named after FROM, JOIN or TO; access objects are never named so at all.
+        else if (!NOT_RELATIONS.has(it.type))
+            byQualified.set(it.database ? `${it.database}.${it.name}` : it.name, it);
+    }
+    const bodies = new Map(items.map((it) => [it.exportName, templateBody(it, byQualified, dbExport)]));
+    // Declarations reference each other in one file, so each comes after what it references.
+    const order = [];
+    const done = new Set();
+    const visiting = new Set();
+    const byExport = new Map(items.map((it) => [it.exportName, it]));
+    const visit = (it) => {
+        if (done.has(it.exportName) || visiting.has(it.exportName))
+            return;
+        visiting.add(it.exportName);
+        for (const ref of bodies.get(it.exportName).refs) {
+            const dep = byExport.get(ref);
+            if (dep)
+                visit(dep);
+        }
+        visiting.delete(it.exportName);
+        done.add(it.exportName);
+        order.push(it);
+    };
+    for (const it of items)
+        visit(it);
+    return { order, bodies };
+}
+function indent(body) {
+    const lines = body.split("\n");
+    return lines.map((l, i) => (i === 0 || l.length === 0 ? l : `  ${l}`)).join("\n");
+}
+const RELATIONS = new Set([CLICKHOUSE_ENTITY_TYPES.table, CLICKHOUSE_ENTITY_TYPES.view, CLICKHOUSE_ENTITY_TYPES.materializedView, CLICKHOUSE_ENTITY_TYPES.dictionary]);
+/** A table's, view's or dictionary's qualified name as its tag's type argument (#3751), so its columns are typed once `chant sql types` has run. */
+const typeArgument = (it) => (RELATIONS.has(it.type) ? `<${JSON.stringify(relationKey(it))}>` : "");
+export class ClickHouseGenerator {
+    constructor(header) {
+        this.header = header;
+        this.ownsLayout = true;
+    }
+    generate(ir) {
+        const items = ir.resources
+            .filter((r) => CLICKHOUSE_TAG_OF[r.type])
+            .map((r) => ({
+            exportName: r.logicalId,
+            type: r.type,
+            database: r.properties.database,
+            name: String(r.properties.name),
+            ddl: String(r.properties.ddl),
+        }));
+        if (items.length === 0)
+            return [];
+        const { order, bodies } = clickhouseTemplates(items);
+        const tags = [...new Set(order.map((it) => CLICKHOUSE_TAG_OF[it.type]))].sort();
+        const lines = [];
+        if (this.header)
+            lines.push(...this.header.split("\n").map((l) => `// ${l}`), "");
+        lines.push(`import { ${tags.join(", ")} } from "@intentius/chant-lexicon-sql/clickhouse";`, "");
+        for (const it of order) {
+            lines.push(`export const ${it.exportName} = ${CLICKHOUSE_TAG_OF[it.type]}${typeArgument(it)}\`\n  ${indent(bodyText(bodies.get(it.exportName)))}\`;`, "");
+        }
+        return [{ path: "schema.ts", content: `${lines.join("\n").trimEnd()}\n` }];
+    }
+}

package/dist/clickhouse/import/inlined.js

@@ -0,0 +1,207 @@
+/**
+ * Finding a SQL user-defined function in what ClickHouse stored (#3745).
+ *
+ * ClickHouse does not keep a call to a SQL function in a view's query or a
+ * column's DEFAULT: it writes the function's body in place of the call, with
+ * the arguments substituted, and a nested call expanded the same way.
+ * `CREATE FUNCTION tax AS x -> (x * 0.2)` used as `tax(amt)` reads back as
+ * `amt * 0.2`. So an import can't look for the name; it looks for the body.
+ *
+ * Each function's body is expanded (a call to another function becomes that
+ * function's body), its parameters become wildcards, and the result is
+ * matched against the stored statement's tokens. Parentheses that only
+ * group are dropped on both sides, since the server adds or leaves them by
+ * precedence where the body lands. A wildcard matches one balanced
+ * expression, and a parameter used twice must match the same text twice.
+ *
+ * A function whose body is just a parameter (`x -> x`) leaves nothing to
+ * look for, so it is never found this way.
+ */
+import { isTrivia, tokenizeText } from "../tokens.js";
+import { unquote } from "../parser.js";
+/** A function's parameters and body, from `CREATE FUNCTION name AS (x, y) -> body`; undefined when it doesn't read that way. */
+export function functionLambda(statement) {
+    let tokens;
+    try {
+        tokens = tokenizeText(statement, 0).filter((t) => !isTrivia(t));
+    }
+    catch {
+        return undefined;
+    }
+    const as = tokens.findIndex((t) => t.kind === "ident" && t.text.toUpperCase() === "AS");
+    const arrow = tokens.findIndex((t, i) => i > as && t.kind === "op" && t.text === "->");
+    if (as < 0 || arrow < 0)
+        return undefined;
+    const params = tokens
+        .slice(as + 1, arrow)
+        .filter((t) => t.kind === "ident" || t.kind === "qident")
+        .map(nameOf);
+    const body = tokens.slice(arrow + 1);
+    while (body.length > 0 && body[body.length - 1].kind === "punct" && body[body.length - 1].text === ";")
+        body.pop();
+    return { params, body };
+}
+const nameOf = (t) => (t.kind === "qident" ? unquote(t.text) : t.text);
+const isPunct = (t, text) => t?.kind === "punct" && t.text === text;
+const isName = (t) => t?.kind === "ident" || t?.kind === "qident";
+/** Words a `(` can follow that make it a grouping, not a call. */
+const GROUPING_AFTER = new Set(["AND", "OR", "NOT", "IS", "LIKE", "ILIKE", "BETWEEN", "WHEN", "THEN", "ELSE", "CASE", "SELECT", "WHERE", "PREWHERE", "HAVING", "FROM", "ON", "AS", "BY", "DEFAULT", "MATERIALIZED", "ALIAS", "EPHEMERAL", "TTL", "INTERVAL", "DISTINCT", "ALL"]);
+/** Words a wildcard never spans: they start the next clause or column attribute. */
+const CLAUSE = new Set(["SELECT", "FROM", "WHERE", "PREWHERE", "GROUP", "ORDER", "HAVING", "LIMIT", "AS", "ENGINE", "SETTINGS", "DEFAULT", "MATERIALIZED", "ALIAS", "EPHEMERAL", "CODEC", "TTL", "COMMENT", "JOIN", "ON", "USING", "UNION", "WITH"]);
+/** The tokens with grouping parentheses taken out; a call's parentheses stay. Trivia is assumed gone. */
+function ungroup(tokens) {
+    const out = [];
+    const grouping = [];
+    tokens.forEach((t, i) => {
+        if (isPunct(t, "(")) {
+            const prev = tokens[i - 1];
+            const call = (isName(prev) && !(prev.kind === "ident" && GROUPING_AFTER.has(prev.text.toUpperCase()))) || isPunct(prev, ")");
+            grouping.push(!call);
+            if (call)
+                out.push(t);
+        }
+        else if (isPunct(t, ")")) {
+            if (grouping.pop() === false)
+                out.push(t);
+        }
+        else
+            out.push(t);
+    });
+    return out;
+}
+/** The index past the `)` matching the `(` at `open`, and the arguments between, split at top-level commas. */
+function callArgs(tokens, open) {
+    const args = [[]];
+    let depth = 0;
+    for (let i = open + 1; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (isPunct(t, "("))
+            depth++;
+        else if (isPunct(t, ")")) {
+            if (depth === 0)
+                return { args: args.length === 1 && args[0].length === 0 ? [] : args, end: i + 1 };
+            depth--;
+        }
+        else if (depth === 0 && isPunct(t, ",")) {
+            args.push([]);
+            continue;
+        }
+        args[args.length - 1].push(t);
+    }
+    return undefined;
+}
+/** A placeholder token for parameter `n`, which can't collide with anything a statement holds. */
+const placeholder = (n) => ({ kind: "ident", text: `\u0000${n}`, part: 0, start: 0, end: 0 });
+/**
+ * `tokens` with `params` replaced by their arguments' tokens and each call to
+ * a function in `lambdas` replaced by that function's body, recursively.
+ */
+function expand(tokens, params, lambdas, seen) {
+    const out = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (isName(t)) {
+            const name = nameOf(t);
+            const callee = lambdas.get(name);
+            if (callee && isPunct(tokens[i + 1], "(") && !seen.has(name)) {
+                const call = callArgs(tokens, i + 1);
+                if (call && call.args.length === callee.params.length) {
+                    const bound = new Map(callee.params.map((p, n) => [p, expand(call.args[n], params, lambdas, seen)]));
+                    out.push(...expand(callee.body, bound, lambdas, new Set([...seen, name])));
+                    i = call.end - 1;
+                    continue;
+                }
+            }
+            const arg = params.get(name);
+            // A parameter is a bare name: `x`, not the `x` in `t.x` or a call `x(...)`.
+            if (arg && !isPunct(tokens[i - 1], ".") && !isPunct(tokens[i + 1], "(")) {
+                out.push(...arg);
+                continue;
+            }
+        }
+        out.push(t);
+    }
+    return out;
+}
+/** What to look for: the function's expanded body, with its parameters as wildcards. Undefined when nothing but a parameter is left to match. */
+export function inlinedPattern(name, lambdas) {
+    const own = lambdas.get(name);
+    if (!own)
+        return undefined;
+    const params = new Map(own.params.map((p, n) => [p, [placeholder(n)]]));
+    const tokens = ungroup(expand(own.body, params, lambdas, new Set([name])));
+    const items = tokens.map((t) => (t.text.startsWith("\u0000") ? { arg: Number(t.text.slice(1)) } : { lit: t.text }));
+    return items.some((i) => "lit" in i) ? items : undefined;
+}
+/** A budget on matching steps per statement, so a pathological statement can't stall an import. */
+const STEP_LIMIT = 200000;
+/** Whether `pattern` appears in `statement`'s tokens. */
+export function containsInlined(statement, pattern) {
+    let raw;
+    try {
+        raw = tokenizeText(statement, 0).filter((t) => !isTrivia(t));
+    }
+    catch {
+        return false;
+    }
+    const text = ungroup(raw).map((t) => t.text);
+    const lits = pattern.flatMap((i) => ("lit" in i ? [i.lit] : []));
+    const present = new Set(text);
+    if (!lits.every((l) => present.has(l)))
+        return false;
+    let steps = 0;
+    const match = (p, at, bound) => {
+        if (++steps > STEP_LIMIT)
+            return false;
+        if (p === pattern.length)
+            return true;
+        const item = pattern[p];
+        if ("lit" in item)
+            return text[at] === item.lit && match(p + 1, at + 1, bound);
+        const known = bound.get(item.arg);
+        if (known)
+            return known.every((s, k) => text[at + k] === s) && match(p + 1, at + known.length, bound);
+        // One balanced expression: never past a top-level comma, an unmatched `)`, or the next clause.
+        let depth = 0;
+        for (let end = at; end < text.length; end++) {
+            const s = text[end];
+            if (depth === 0 && (s === "," || s === ";" || s === ")" || CLAUSE.has(s.toUpperCase())))
+                return false;
+            if (s === "(")
+                depth++;
+            else if (s === ")")
+                depth--;
+            if (depth > 0)
+                continue;
+            bound.set(item.arg, text.slice(at, end + 1));
+            if (match(p + 1, end + 1, bound))
+                return true;
+            bound.delete(item.arg);
+        }
+        return false;
+    };
+    for (let at = 0; at < text.length; at++)
+        if (match(0, at, new Map()))
+            return true;
+    return false;
+}
+/**
+ * The functions among `functions` whose bodies appear inlined in any of
+ * `statements`. A function is matched with the others' bodies expanded into
+ * its own, as the server does.
+ */
+export function inlinedFunctions(statements, functions) {
+    const lambdas = new Map();
+    for (const f of functions) {
+        const l = functionLambda(f.statement);
+        if (l)
+            lambdas.set(f.name, l);
+    }
+    const out = [];
+    for (const f of functions) {
+        const pattern = inlinedPattern(f.name, lambdas);
+        if (pattern && statements.some((s) => containsInlined(s, pattern)))
+            out.push(f.name);
+    }
+    return out;
+}