@adaptabletools/adaptable-mcp 0.1.0-canary.0 → 0.1.0-canary.2

package/dist/core/extract/ts-literal.js

@@ -0,0 +1,963 @@
+/**
+ * Locates the State / Options / `columnDefs` literal in a source file and evaluates
+ * it to a JSON value with a line map (plan §8.4 Input, §8.6 `options-shape`, §8.7).
+ *
+ * TypeScript compiler API, `createSourceFile` only — no program, no type-check.
+ * Whatever cannot be evaluated statically (functions, unresolvable spreads, calls,
+ * template literals with substitutions, computed keys, member accesses that do not
+ * land on a local literal or enum, identifiers imported from packages) is stubbed
+ * as `null` in the value and listed under `unverifiable` with its path and reason;
+ * it is never an error (plan §21, "every such path is listed").
+ */
+import { basename, extname } from 'node:path';
+import ts from 'typescript';
+import { LineIndex, ROOT_PATH, childPath, indexPath, mergeShiftedIndices, } from './line-map.js';
+export class SyntaxErrorInSource extends Error {
+    file;
+    line;
+    column;
+    detail;
+    constructor(file, line, column, detail) {
+        super(`${file}:${line}:${column}: ${detail}`);
+        this.file = file;
+        this.line = line;
+        this.column = column;
+        this.detail = detail;
+        this.name = 'SyntaxErrorInSource';
+    }
+}
+export const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.vue'];
+export function isSourceFile(file) {
+    return SOURCE_EXTENSIONS.includes(extname(file).toLowerCase());
+}
+function scriptKindFor(file) {
+    switch (extname(file).toLowerCase()) {
+        case '.tsx':
+            return ts.ScriptKind.TSX;
+        case '.js':
+        case '.mjs':
+        case '.cjs':
+            return ts.ScriptKind.JS;
+        case '.jsx':
+            return ts.ScriptKind.JSX;
+        default:
+            return ts.ScriptKind.TS;
+    }
+}
+const SCRIPT_BLOCK = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+/**
+ * A `.vue` SFC as parseable text: everything outside the `<script>` / `<script setup>`
+ * blocks is blanked (newlines kept), so every node offset is an offset into the
+ * original file and lines map back without arithmetic.
+ */
+function blankVueTemplate(text) {
+    let script = text.replace(/[^\n]/g, ' ');
+    let kind = ts.ScriptKind.JS;
+    for (const match of text.matchAll(SCRIPT_BLOCK)) {
+        const attrs = match[1];
+        const body = match[2];
+        // match[0] = `<script…>` + body + `</script>`
+        const start = match.index + match[0].length - '</script>'.length - body.length;
+        script = script.slice(0, start) + body + script.slice(start + body.length);
+        const lang = /\blang\s*=\s*["']?(\w+)/.exec(attrs)?.[1]?.toLowerCase();
+        if (lang === 'tsx') {
+            kind = ts.ScriptKind.TSX;
+        }
+        else if (lang === 'ts' && kind !== ts.ScriptKind.TSX) {
+            kind = ts.ScriptKind.TS;
+        }
+        else if (lang === 'jsx' && kind === ts.ScriptKind.JS) {
+            kind = ts.ScriptKind.JSX;
+        }
+    }
+    return { script, kind };
+}
+function parseDiagnostics(sf) {
+    // `parseDiagnostics` is the parser's own list; it is not in the public type but has
+    // been on SourceFile since TS 2.x and is the only way to see syntax errors without a program.
+    return sf.parseDiagnostics ?? [];
+}
+/** Parses a source file (or a JSON document as a JS expression when `asExpression`); throws `SyntaxErrorInSource`. */
+export function parseSource(text, file, options = {}) {
+    const clean = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+    let scriptText = clean;
+    let kind = scriptKindFor(file);
+    let delta = 0;
+    if (options.asExpression) {
+        scriptText = `(${clean})`;
+        kind = ts.ScriptKind.JS;
+        delta = 1;
+    }
+    else if (extname(file).toLowerCase() === '.vue') {
+        ({ script: scriptText, kind } = blankVueTemplate(clean));
+    }
+    const sf = ts.createSourceFile(file, scriptText, ts.ScriptTarget.Latest, true, kind);
+    const index = new LineIndex(clean);
+    const parsed = { file, text: clean, sf, delta, index, declarations: indexDeclarations(sf) };
+    const [first] = parseDiagnostics(sf);
+    if (first) {
+        const { line, column } = index.positionAt(Math.max(0, first.start - delta));
+        throw new SyntaxErrorInSource(file, line, column, ts.flattenDiagnosticMessageText(first.messageText, ' '));
+    }
+    return parsed;
+}
+function push(map, key, value) {
+    const list = map.get(key);
+    if (list) {
+        list.push(value);
+    }
+    else {
+        map.set(key, [value]);
+    }
+}
+function indexDeclarations(sf) {
+    const index = {
+        variables: new Map(),
+        classProperties: new Map(),
+        enums: new Map(),
+        functions: new Map(),
+        imports: new Map(),
+    };
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+            push(index.variables, node.name.text, node);
+        }
+        else if (ts.isPropertyDeclaration(node) && (ts.isIdentifier(node.name) || ts.isStringLiteral(node.name))) {
+            push(index.classProperties, node.name.text, node);
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            index.enums.set(node.name.text, node);
+        }
+        else if (ts.isFunctionDeclaration(node) && node.name) {
+            index.functions.set(node.name.text, node);
+        }
+        else if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+            const specifier = node.moduleSpecifier.text;
+            const clause = node.importClause;
+            if (clause?.name) {
+                index.imports.set(clause.name.text, { kind: 'default', local: clause.name.text, imported: 'default', specifier, node, localNode: clause.name });
+            }
+            if (clause?.namedBindings) {
+                if (ts.isNamespaceImport(clause.namedBindings)) {
+                    const local = clause.namedBindings.name.text;
+                    index.imports.set(local, { kind: 'namespace', local, imported: '*', specifier, node, localNode: clause.namedBindings.name });
+                }
+                else {
+                    for (const element of clause.namedBindings.elements) {
+                        const local = element.name.text;
+                        const imported = element.propertyName?.text ?? local;
+                        index.imports.set(local, { kind: 'named', local, imported, specifier, node, localNode: element.name });
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return index;
+}
+function scopeOf(node) {
+    let current = node;
+    while (!ts.isSourceFile(current) && !ts.isBlock(current) && !ts.isModuleBlock(current) && !ts.isCaseBlock(current)) {
+        current = current.parent;
+    }
+    return current;
+}
+/** The declaration of `name` whose scope encloses `pos` most tightly; a module-level one otherwise */
+function pickDeclaration(candidates, pos) {
+    if (!candidates?.length) {
+        return undefined;
+    }
+    let best;
+    if (pos !== undefined) {
+        for (const node of candidates) {
+            const scope = scopeOf(node);
+            if (scope.pos <= pos && pos < scope.end) {
+                const size = scope.end - scope.pos;
+                if (!best || size < best.size) {
+                    best = { node, size };
+                }
+            }
+        }
+    }
+    return best?.node ?? candidates.find((node) => ts.isSourceFile(scopeOf(node))) ?? candidates[0];
+}
+export function createContext(parsed, options = {}) {
+    return {
+        parsed,
+        imports: options.imports,
+        sink: options.sink ?? { lineMap: {}, unverifiable: [] },
+        stack: options.stack ?? new Set(),
+        hop: options.hop ?? 0,
+        ...(options.chain ? { chain: options.chain } : {}),
+    };
+}
+const OMIT = Symbol('omit');
+export function positionOf(ctx, node) {
+    const start = node.getStart(ctx.parsed.sf) - ctx.parsed.delta;
+    return { file: ctx.parsed.file, ...ctx.parsed.index.positionAt(Math.max(0, start)) };
+}
+function recordValue(ctx, path, node) {
+    const entry = ctx.sink.lineMap[path];
+    const value = positionOf(ctx, node);
+    ctx.sink.lineMap[path] = entry ? { ...entry, value } : { value };
+}
+function recordKey(ctx, path, node) {
+    const entry = ctx.sink.lineMap[path];
+    const key = positionOf(ctx, node);
+    ctx.sink.lineMap[path] = entry ? { ...entry, key } : { value: key, key };
+}
+function report(ctx, path, node, kind, reason) {
+    recordValue(ctx, path, node);
+    ctx.sink.unverifiable.push({ path, kind, reason, ...positionOf(ctx, node) });
+    return null;
+}
+export function snippet(node, max = 60) {
+    const text = node.getText(node.getSourceFile()).replace(/\s+/g, ' ');
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function describe(node) {
+    switch (node.kind) {
+        case ts.SyntaxKind.ObjectLiteralExpression:
+            return 'an object literal';
+        case ts.SyntaxKind.ArrayLiteralExpression:
+            return 'an array literal';
+        case ts.SyntaxKind.CallExpression:
+        case ts.SyntaxKind.NewExpression:
+        case ts.SyntaxKind.TaggedTemplateExpression:
+            return 'a call';
+        case ts.SyntaxKind.ArrowFunction:
+        case ts.SyntaxKind.FunctionExpression:
+        case ts.SyntaxKind.FunctionDeclaration:
+        case ts.SyntaxKind.MethodDeclaration:
+            return 'a function';
+        case ts.SyntaxKind.EnumDeclaration:
+            return 'an enum';
+        case ts.SyntaxKind.ClassDeclaration:
+        case ts.SyntaxKind.ClassExpression:
+            return 'a class';
+        case ts.SyntaxKind.TemplateExpression:
+            return 'a template literal with substitutions';
+        default:
+            return `a ${ts.SyntaxKind[node.kind].replace(/([a-z])([A-Z])/g, '$1 $2').toLowerCase()}`;
+    }
+}
+/** Strips parentheses and type-only wrappers */
+export function unwrap(node) {
+    let current = node;
+    for (;;) {
+        if (ts.isParenthesizedExpression(current) ||
+            ts.isAsExpression(current) ||
+            ts.isSatisfiesExpression(current) ||
+            ts.isNonNullExpression(current) ||
+            ts.isTypeAssertionExpression(current)) {
+            current = current.expression;
+        }
+        else {
+            return current;
+        }
+    }
+}
+function isReferenceLike(node) {
+    return (ts.isIdentifier(node) ||
+        ts.isPropertyAccessExpression(node) ||
+        (ts.isElementAccessExpression(node) && literalKey(node.argumentExpression) !== undefined) ||
+        node.kind === ts.SyntaxKind.ThisKeyword);
+}
+function literalKey(node) {
+    const inner = unwrap(node);
+    if (ts.isStringLiteral(inner) || ts.isNoSubstitutionTemplateLiteral(inner) || ts.isNumericLiteral(inner)) {
+        return inner.text;
+    }
+    return undefined;
+}
+const GLOBAL_NUMBERS = { NaN: Number.NaN, Infinity: Number.POSITIVE_INFINITY };
+function isRelativeSpecifier(specifier) {
+    return specifier.startsWith('./') || specifier.startsWith('../') || specifier === '.' || specifier === '..';
+}
+/** One resolution step for an identifier / member access; the chain is followed by `resolveReference` */
+function resolveOnce(node, ctx) {
+    const file = basename(ctx.parsed.file);
+    const { declarations } = ctx.parsed;
+    if (ts.isIdentifier(node)) {
+        const name = node.text;
+        const variable = pickDeclaration(declarations.variables.get(name), node.getStart(ctx.parsed.sf));
+        if (variable) {
+            if (!variable.initializer) {
+                return { ok: false, kind: 'unresolved-identifier', reason: `\`${name}\` is declared without an initializer in ${file}` };
+            }
+            return { ok: true, node: variable.initializer, ctx, decls: [], decl: variable };
+        }
+        const fn = declarations.functions.get(name);
+        if (fn) {
+            return { ok: true, node: fn, ctx, decls: [], decl: fn };
+        }
+        const enumDecl = declarations.enums.get(name);
+        if (enumDecl) {
+            return { ok: true, node: enumDecl, ctx, decls: [], decl: enumDecl };
+        }
+        const binding = declarations.imports.get(name);
+        if (binding) {
+            return resolveImport(binding, undefined, ctx);
+        }
+        return { ok: false, kind: 'unresolved-identifier', reason: `\`${name}\` has no visible literal initializer in ${file}` };
+    }
+    // this.x · a.b · a['b']
+    let base;
+    let member;
+    if (ts.isPropertyAccessExpression(node)) {
+        base = unwrap(node.expression);
+        member = node.name.text;
+    }
+    else if (ts.isElementAccessExpression(node)) {
+        base = unwrap(node.expression);
+        member = literalKey(node.argumentExpression);
+    }
+    else {
+        return { ok: false, kind: 'expression', reason: `\`${snippet(node)}\` is ${describe(node)}` };
+    }
+    const text = snippet(node);
+    if (base.kind === ts.SyntaxKind.ThisKeyword) {
+        const property = pickDeclaration(declarations.classProperties.get(member), node.getStart(ctx.parsed.sf));
+        if (!property) {
+            return { ok: false, kind: 'member-access', reason: `\`${text}\`: no class property \`${member}\` with an initializer in ${file}` };
+        }
+        if (!property.initializer) {
+            return { ok: false, kind: 'member-access', reason: `\`${text}\`: class property \`${member}\` has no initializer` };
+        }
+        return { ok: true, node: property.initializer, ctx, decls: [], decl: property };
+    }
+    if (ts.isIdentifier(base)) {
+        const binding = declarations.imports.get(base.text);
+        if (binding?.kind === 'namespace' && !declarations.variables.has(base.text)) {
+            return resolveImport(binding, member, ctx);
+        }
+    }
+    const baseRef = resolveReference(base, ctx);
+    if (!baseRef.ok) {
+        const kind = baseRef.kind === 'non-relative-import' || baseRef.kind === 'unresolved-import' ? baseRef.kind : 'member-access';
+        // a nested member access already carries its own `a.b`: prefix; keep the innermost cause once
+        const cause = baseRef.kind === 'member-access' ? baseRef.reason.replace(/^`[^`]*`: /, '') : baseRef.reason;
+        return { ok: false, kind, reason: `\`${text}\`: ${cause}` };
+    }
+    const target = unwrap(baseRef.node);
+    if (ts.isEnumDeclaration(target)) {
+        const value = enumMemberValue(target, member);
+        if (value === undefined) {
+            return { ok: false, kind: 'member-access', reason: `\`${text}\`: enum member \`${member}\` has no literal value` };
+        }
+        const memberNode = target.members.find((m) => propertyName(m.name) === member) ?? target;
+        return { ok: true, node: memberNode, ctx: baseRef.ctx, decls: baseRef.decls, constant: value };
+    }
+    if (ts.isObjectLiteralExpression(target)) {
+        const property = target.properties.find((p) => p.name && propertyName(p.name) === member);
+        if (!property) {
+            return { ok: false, kind: 'member-access', reason: `\`${text}\`: the literal has no property \`${member}\`` };
+        }
+        if (ts.isPropertyAssignment(property)) {
+            return { ok: true, node: property.initializer, ctx: baseRef.ctx, decls: baseRef.decls };
+        }
+        if (ts.isShorthandPropertyAssignment(property)) {
+            return { ok: true, node: property.name, ctx: baseRef.ctx, decls: baseRef.decls };
+        }
+        return { ok: true, node: property, ctx: baseRef.ctx, decls: baseRef.decls };
+    }
+    if (ts.isArrayLiteralExpression(target) && /^\d+$/.test(member)) {
+        const element = target.elements[Number(member)];
+        if (element && !ts.isSpreadElement(element) && !ts.isOmittedExpression(element)) {
+            return { ok: true, node: element, ctx: baseRef.ctx, decls: baseRef.decls };
+        }
+    }
+    return { ok: false, kind: 'member-access', reason: `\`${text}\`: \`${snippet(base)}\` is ${describe(target)}` };
+}
+function resolveImport(binding, member, ctx) {
+    const what = member ? `\`${binding.local}.${member}\`` : `\`${binding.local}\``;
+    if (!isRelativeSpecifier(binding.specifier)) {
+        return {
+            ok: false,
+            kind: 'non-relative-import',
+            reason: `${what} is imported from '${binding.specifier}', a package rather than a relative file`,
+        };
+    }
+    if (!ctx.imports) {
+        return {
+            ok: false,
+            kind: 'unresolved-import',
+            reason: `${what} is imported from '${binding.specifier}' in ${basename(ctx.parsed.file)}, a second hop; the extractor follows one hop of relative imports`,
+        };
+    }
+    return ctx.imports.resolve(binding, member, ctx);
+}
+function propertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name)) {
+        return name.text;
+    }
+    if (ts.isPrivateIdentifier(name)) {
+        return name.text;
+    }
+    if (ts.isComputedPropertyName(name)) {
+        return literalKey(name.expression);
+    }
+    return undefined;
+}
+function enumMemberValue(decl, member) {
+    let next = 0;
+    for (const m of decl.members) {
+        let value;
+        if (m.initializer) {
+            const init = unwrap(m.initializer);
+            if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
+                value = init.text;
+                next = undefined;
+            }
+            else if (ts.isNumericLiteral(init)) {
+                value = Number(init.text);
+                next = value + 1;
+            }
+            else if (ts.isPrefixUnaryExpression(init) && init.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(init.operand)) {
+                value = -Number(init.operand.text);
+                next = value + 1;
+            }
+            else {
+                next = undefined;
+            }
+        }
+        else if (next !== undefined) {
+            value = next;
+            next += 1;
+        }
+        if (propertyName(m.name) === member) {
+            return value;
+        }
+    }
+    return undefined;
+}
+/** Follows identifier / member chains to the node that is not itself a reference */
+export function resolveReference(expr, ctx) {
+    let node = unwrap(expr);
+    let current = ctx;
+    const decls = [];
+    while (isReferenceLike(node)) {
+        const step = resolveOnce(node, current);
+        if (!step.ok) {
+            return step;
+        }
+        if (step.decl) {
+            if (current.stack.has(step.decl) || decls.includes(step.decl)) {
+                return { ok: false, kind: 'unresolved-identifier', reason: `\`${snippet(node)}\` refers to itself (circular reference)` };
+            }
+            decls.push(step.decl);
+        }
+        decls.push(...step.decls);
+        if (step.constant !== undefined) {
+            return { ok: true, node: step.node, ctx: step.ctx, decls, constant: step.constant };
+        }
+        node = unwrap(step.node);
+        current = step.ctx;
+    }
+    return { ok: true, node, ctx: current, decls };
+}
+function withDecls(ctx, decls, fn) {
+    for (const decl of decls) {
+        ctx.stack.add(decl);
+    }
+    try {
+        return fn();
+    }
+    finally {
+        for (const decl of decls) {
+            ctx.stack.delete(decl);
+        }
+    }
+}
+/** Evaluates a node into a JSON value, recording positions and unverifiable paths in `ctx.sink` */
+export function evaluate(expr, path, ctx) {
+    const result = evaluateNode(expr, path, ctx);
+    return result === OMIT ? null : result;
+}
+function evaluateNode(expr, path, ctx) {
+    const node = unwrap(expr);
+    if (ts.isIdentifier(node) && node.text === 'undefined') {
+        return OMIT;
+    }
+    if (ts.isIdentifier(node) && node.text in GLOBAL_NUMBERS && !ctx.parsed.declarations.variables.has(node.text)) {
+        recordValue(ctx, path, node);
+        return GLOBAL_NUMBERS[node.text];
+    }
+    if (isReferenceLike(node)) {
+        const ref = resolveReference(node, ctx);
+        if (!ref.ok) {
+            return report(ctx, path, node, ref.kind, ref.reason);
+        }
+        if (ref.constant !== undefined) {
+            recordValue(ref.ctx, path, ref.node);
+            return ref.constant;
+        }
+        return withDecls(ctx, ref.decls, () => evaluateNode(ref.node, path, ref.ctx));
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        return evaluateObject(node, path, ctx);
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        return evaluateArray(node, path, ctx);
+    }
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        recordValue(ctx, path, node);
+        return node.text;
+    }
+    if (ts.isNumericLiteral(node)) {
+        recordValue(ctx, path, node);
+        return Number(node.text);
+    }
+    if (ts.isPrefixUnaryExpression(node) && (node.operator === ts.SyntaxKind.MinusToken || node.operator === ts.SyntaxKind.PlusToken)) {
+        const operand = unwrap(node.operand);
+        const sign = node.operator === ts.SyntaxKind.MinusToken ? -1 : 1;
+        if (ts.isNumericLiteral(operand)) {
+            recordValue(ctx, path, node);
+            return sign * Number(operand.text);
+        }
+        if (ts.isIdentifier(operand) && operand.text in GLOBAL_NUMBERS) {
+            recordValue(ctx, path, node);
+            return sign * GLOBAL_NUMBERS[operand.text];
+        }
+    }
+    switch (node.kind) {
+        case ts.SyntaxKind.TrueKeyword:
+            recordValue(ctx, path, node);
+            return true;
+        case ts.SyntaxKind.FalseKeyword:
+            recordValue(ctx, path, node);
+            return false;
+        case ts.SyntaxKind.NullKeyword:
+            recordValue(ctx, path, node);
+            return null;
+        case ts.SyntaxKind.TemplateExpression:
+            return report(ctx, path, node, 'template', `\`${snippet(node)}\` is a template literal with substitutions`);
+        case ts.SyntaxKind.ArrowFunction:
+        case ts.SyntaxKind.FunctionExpression:
+        case ts.SyntaxKind.FunctionDeclaration:
+        case ts.SyntaxKind.MethodDeclaration:
+        case ts.SyntaxKind.GetAccessor:
+        case ts.SyntaxKind.SetAccessor:
+            return report(ctx, path, node, 'function', `\`${snippet(node, 40)}\` is a function`);
+        case ts.SyntaxKind.CallExpression:
+        case ts.SyntaxKind.NewExpression:
+        case ts.SyntaxKind.TaggedTemplateExpression:
+            return report(ctx, path, node, 'call', `\`${snippet(node)}\` is a call; its result is not visible statically`);
+        default:
+            return report(ctx, path, node, 'expression', `\`${snippet(node)}\` is ${describe(node)}`);
+    }
+}
+function evaluateObject(node, path, ctx) {
+    const out = {};
+    for (const property of node.properties) {
+        if (ts.isSpreadAssignment(property)) {
+            const spread = evaluateSpread(property.expression, path, ctx, 'object');
+            if (spread) {
+                Object.assign(out, spread);
+            }
+            continue;
+        }
+        const key = property.name ? propertyName(property.name) : undefined;
+        if (key === undefined) {
+            const keyNode = property.name && ts.isComputedPropertyName(property.name) ? property.name.expression : property;
+            const resolved = resolveComputedKey(keyNode, ctx);
+            if (resolved === undefined) {
+                report(ctx, path, keyNode, 'computed-key', `computed key \`[${snippet(keyNode)}]\` cannot be resolved statically`);
+                continue;
+            }
+            assignProperty(out, resolved, property, path, ctx);
+            continue;
+        }
+        assignProperty(out, key, property, path, ctx);
+    }
+    recordValue(ctx, path, node);
+    return out;
+}
+function assignProperty(out, key, property, path, ctx) {
+    const child = childPath(path, key);
+    let value;
+    if (ts.isPropertyAssignment(property)) {
+        value = evaluateNode(property.initializer, child, ctx);
+    }
+    else if (ts.isShorthandPropertyAssignment(property)) {
+        value = evaluateNode(property.name, child, ctx);
+    }
+    else {
+        value = report(ctx, child, property, 'function', `\`${key}\` is a method`);
+    }
+    if (value === OMIT) {
+        // `key: undefined` — JSON has no such member; drop it and any position recorded for it
+        delete out[key];
+        delete ctx.sink.lineMap[child];
+        return;
+    }
+    if (property.name) {
+        recordKey(ctx, child, property.name);
+    }
+    out[key] = value;
+}
+function resolveComputedKey(keyNode, ctx) {
+    const inner = unwrap(keyNode);
+    if (!isReferenceLike(inner)) {
+        return undefined;
+    }
+    const ref = resolveReference(inner, ctx);
+    if (!ref.ok) {
+        return undefined;
+    }
+    if (ref.constant !== undefined) {
+        return typeof ref.constant === 'string' || typeof ref.constant === 'number' ? String(ref.constant) : undefined;
+    }
+    return literalKey(ref.node);
+}
+function evaluateArray(node, path, ctx) {
+    const out = [];
+    for (const element of node.elements) {
+        if (ts.isSpreadElement(element)) {
+            const spread = evaluateSpread(element.expression, path, ctx, 'array', out.length);
+            if (spread) {
+                out.push(...spread);
+            }
+            continue;
+        }
+        if (ts.isOmittedExpression(element)) {
+            out.push(null);
+            continue;
+        }
+        const value = evaluateNode(element, indexPath(path, out.length), ctx);
+        out.push(value === OMIT ? null : value);
+    }
+    recordValue(ctx, path, node);
+    return out;
+}
+function evaluateSpread(expr, path, ctx, expected, base = 0) {
+    const text = `...${snippet(expr)}`;
+    const ref = resolveReference(expr, ctx);
+    if (!ref.ok) {
+        report(ctx, path, expr, 'spread', `\`${text}\`: ${ref.reason}`);
+        return undefined;
+    }
+    const target = unwrap(ref.node);
+    const matches = expected === 'object' ? ts.isObjectLiteralExpression(target) : ts.isArrayLiteralExpression(target);
+    if (!matches || ref.constant !== undefined) {
+        report(ctx, path, expr, 'spread', `\`${text}\` is ${describe(target)}; its members are not visible statically`);
+        return undefined;
+    }
+    if (expected === 'object') {
+        return withDecls(ctx, ref.decls, () => evaluateObject(target, path, ref.ctx));
+    }
+    const sub = { lineMap: {}, unverifiable: [] };
+    const value = withDecls(ctx, ref.decls, () => evaluateArray(target, path, { ...ref.ctx, sink: sub }));
+    mergeShiftedIndices(ctx.sink.lineMap, sub.lineMap, path, base, ctx.sink.unverifiable, sub.unverifiable);
+    return value;
+}
+const TARGETS = {
+    state: {
+        typeNames: ['InitialState', 'AdaptablePersistentState', 'PredefinedConfig'],
+        variableNames: ['initialState', 'predefinedConfig'],
+        propertyNames: ['initialState', 'predefinedConfig'],
+        literal: 'object',
+    },
+    options: {
+        typeNames: ['AdaptableOptions'],
+        variableNames: ['adaptableOptions'],
+        propertyNames: ['adaptableOptions'],
+        wrapper: { argument: 0, attribute: 'adaptableOptions', vueAttributes: ['adaptable-options', 'adaptableOptions'] },
+        literal: 'object',
+    },
+    gridOptions: {
+        typeNames: ['GridOptions'],
+        variableNames: ['gridOptions'],
+        propertyNames: ['gridOptions'],
+        wrapper: { argument: 1, attribute: 'gridOptions', vueAttributes: ['grid-options', 'gridOptions'] },
+        literal: 'object',
+    },
+    columnDefs: {
+        typeNames: ['ColDef', 'ColGroupDef'],
+        variableNames: ['columnDefs'],
+        propertyNames: ['columnDefs'],
+        literal: 'array',
+    },
+};
+/** Rules tried per target, in order (what `tried` reports on a miss) */
+export const LOCATING_RULES = {
+    state: ['annotation', 'cast', 'variable', 'property'],
+    options: ['annotation', 'cast', 'variable', 'wrapper-argument', 'property'],
+    columnDefs: ['annotation', 'variable', 'gridOptions', 'property'],
+};
+function typeMentions(type, names) {
+    if (!type) {
+        return false;
+    }
+    // the type itself, possibly wrapped: `T`, `T<A>`, `T[]`, `Array<T>`, `T | undefined`, `(T)`, `import('…').T`;
+    // not a type that merely mentions it (`Record<string, T>`, `T['Dashboard']`, `typeof t`)
+    const rightmost = (name) => (ts.isIdentifier(name) ? name.text : name.right.text);
+    const matches = (node) => {
+        if (ts.isParenthesizedTypeNode(node) || ts.isArrayTypeNode(node)) {
+            return matches(ts.isArrayTypeNode(node) ? node.elementType : node.type);
+        }
+        if (ts.isUnionTypeNode(node) || ts.isIntersectionTypeNode(node)) {
+            return node.types.some(matches);
+        }
+        if (ts.isTypeReferenceNode(node)) {
+            const name = rightmost(node.typeName);
+            if (names.includes(name)) {
+                return true;
+            }
+            return (name === 'Array' || name === 'ReadonlyArray') && !!node.typeArguments?.some(matches);
+        }
+        if (ts.isImportTypeNode(node)) {
+            return !!node.qualifier && names.includes(rightmost(node.qualifier));
+        }
+        return false;
+    };
+    return matches(type);
+}
+/** The expressions a function returns: an arrow's expression body, or every `return` not nested in another function */
+function returnedExpressions(fn) {
+    if (!fn.body) {
+        return [];
+    }
+    if (!ts.isBlock(fn.body)) {
+        return [fn.body];
+    }
+    const out = [];
+    const visit = (node) => {
+        if (ts.isReturnStatement(node) && node.expression) {
+            out.push(node.expression);
+        }
+        if (ts.isFunctionLike(node) && node !== fn) {
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(fn.body);
+    return out;
+}
+/** `: T` on a declaration, or `/** @type {T} *\/` in JS */
+function declaredType(node) {
+    if (node.type) {
+        return node.type;
+    }
+    const tag = ts.getJSDocTypeTag(node) ?? (ts.isVariableDeclaration(node) ? ts.getJSDocTypeTag(node.parent.parent) : undefined);
+    return tag?.typeExpression?.type;
+}
+function walk(sf, visit) {
+    const inner = (node) => {
+        visit(node);
+        ts.forEachChild(node, inner);
+    };
+    inner(sf);
+}
+function isAdaptableWrapperCall(node) {
+    if (ts.isCallExpression(node)) {
+        const callee = unwrap(node.expression);
+        return ts.isPropertyAccessExpression(callee) && callee.name.text === 'init' && snippet(callee.expression).endsWith('Adaptable');
+    }
+    if (ts.isNewExpression(node)) {
+        return snippet(node.expression).endsWith('Adaptable');
+    }
+    return false;
+}
+function findNamedNode(ctx, name, pos) {
+    const { declarations } = ctx.parsed;
+    const variable = pickDeclaration(declarations.variables.get(name), pos);
+    if (variable?.initializer) {
+        return variable.initializer;
+    }
+    const property = pickDeclaration(declarations.classProperties.get(name), pos);
+    if (property?.initializer) {
+        return property.initializer;
+    }
+    let found;
+    walk(ctx.parsed.sf, (node) => {
+        if (!found && ts.isPropertyAssignment(node) && propertyName(node.name) === name) {
+            found = node.initializer;
+        }
+    });
+    return found;
+}
+/** The node a template-bound expression (`[x]="a.b"`, `:x="a"`) refers to in the script */
+function boundExpression(ctx, text) {
+    const parts = text.trim().split('.');
+    if (!parts.every((part) => /^[A-Za-z_$][\w$]*$/.test(part))) {
+        return undefined;
+    }
+    let node = findNamedNode(ctx, parts[0], 0);
+    for (const part of parts.slice(1)) {
+        if (!node) {
+            return undefined;
+        }
+        const ref = resolveReference(node, ctx);
+        const target = ref.ok ? unwrap(ref.node) : undefined;
+        if (!target || !ts.isObjectLiteralExpression(target)) {
+            return undefined;
+        }
+        const property = target.properties.find((p) => p.name && propertyName(p.name) === part);
+        node = property && ts.isPropertyAssignment(property) ? property.initializer : property && ts.isShorthandPropertyAssignment(property) ? property.name : undefined;
+    }
+    return node;
+}
+function templateBindings(ctx, spec, readTemplate) {
+    if (!spec.wrapper) {
+        return [];
+    }
+    const texts = [ctx.parsed.text];
+    for (const match of ctx.parsed.text.matchAll(/templateUrl\s*:\s*['"`]([^'"`]+)['"`]/g)) {
+        const template = readTemplate(match[1]);
+        if (template) {
+            texts.push(template);
+        }
+    }
+    const expressions = [];
+    const angular = new RegExp(`\\[${spec.wrapper.attribute}\\]\\s*=\\s*["']([^"']+)["']`, 'g');
+    const vue = new RegExp(`(?:^|\\s)(?::|v-bind:)(?:${spec.wrapper.vueAttributes.join('|')})\\s*=\\s*["']([^"']+)["']`, 'g');
+    for (const text of texts) {
+        for (const match of text.matchAll(angular)) {
+            expressions.push(match[1]);
+        }
+        for (const match of text.matchAll(vue)) {
+            expressions.push(match[1]);
+        }
+    }
+    return expressions;
+}
+function candidatesFor(spec, rule, ctx, options) {
+    const sf = ctx.parsed.sf;
+    const out = [];
+    const add = (node) => {
+        if (node) {
+            out.push({ node, locatedBy: rule, ctx });
+        }
+    };
+    switch (rule) {
+        case 'annotation':
+            walk(sf, (node) => {
+                if ((ts.isVariableDeclaration(node) || ts.isPropertyDeclaration(node)) && node.initializer && typeMentions(declaredType(node), spec.typeNames)) {
+                    add(node.initializer);
+                }
+                else if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) &&
+                    node.type &&
+                    typeMentions(node.type, spec.typeNames)) {
+                    // `(): AdaptableOptions => ({ … })` / `function build(): InitialState { return { … }; }`
+                    returnedExpressions(node).forEach(add);
+                }
+            });
+            break;
+        case 'cast':
+            walk(sf, (node) => {
+                if ((ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isTypeAssertionExpression(node)) && typeMentions(node.type, spec.typeNames)) {
+                    add(node.expression);
+                }
+            });
+            break;
+        case 'variable':
+            walk(sf, (node) => {
+                if ((ts.isVariableDeclaration(node) || ts.isPropertyDeclaration(node)) && node.initializer && spec.variableNames.includes(propertyName(node.name) ?? '')) {
+                    add(node.initializer);
+                }
+            });
+            // an identifier of that name imported from a relative file counts too (`import { columnDefs } from './columnDefs'`)
+            for (const name of spec.variableNames) {
+                const binding = ctx.parsed.declarations.imports.get(name);
+                if (binding && binding.kind !== 'namespace') {
+                    add(binding.localNode);
+                }
+            }
+            break;
+        case 'wrapper-argument':
+            if (spec.wrapper) {
+                const { argument, attribute } = spec.wrapper;
+                walk(sf, (node) => {
+                    if (isAdaptableWrapperCall(node)) {
+                        add(node.arguments?.[argument]);
+                    }
+                    else if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name) && node.name.text === attribute && node.initializer) {
+                        add(ts.isJsxExpression(node.initializer) ? node.initializer.expression : node.initializer);
+                    }
+                });
+                for (const expression of templateBindings(ctx, spec, options.readTemplate ?? (() => undefined))) {
+                    add(boundExpression(ctx, expression));
+                }
+            }
+            break;
+        case 'property':
+            walk(sf, (node) => {
+                if (ts.isPropertyAssignment(node) && spec.propertyNames.includes(propertyName(node.name) ?? '')) {
+                    add(node.initializer);
+                }
+                else if (ts.isShorthandPropertyAssignment(node) && spec.propertyNames.includes(node.name.text)) {
+                    add(node.name);
+                }
+            });
+            break;
+        case 'gridOptions': {
+            const grid = locateLiteral(TARGETS.gridOptions, ['annotation', 'cast', 'variable', 'wrapper-argument', 'property'], ctx, options);
+            if (grid) {
+                const ref = resolveReference(grid.node, grid.ctx);
+                const target = ref.ok ? unwrap(ref.node) : undefined;
+                if (target && ts.isObjectLiteralExpression(target)) {
+                    const property = target.properties.find((p) => p.name && propertyName(p.name) === 'columnDefs');
+                    if (property && ts.isPropertyAssignment(property)) {
+                        out.push({ node: property.initializer, locatedBy: rule, ctx: ref.ok ? ref.ctx : ctx });
+                    }
+                    else if (property && ts.isShorthandPropertyAssignment(property)) {
+                        out.push({ node: property.name, locatedBy: rule, ctx: ref.ok ? ref.ctx : ctx });
+                    }
+                }
+            }
+            break;
+        }
+        case 'json':
+            break;
+    }
+    return out;
+}
+function isLiteralOf(node, kind) {
+    return kind === 'object' ? ts.isObjectLiteralExpression(node) : ts.isArrayLiteralExpression(node);
+}
+/**
+ * The first candidate (in rule order) that resolves to a literal of the expected
+ * kind; failing that, the first candidate of any rule — so a State built by a call
+ * is still reported, as `unverifiable` at the root, rather than "not found".
+ */
+function locateLiteral(spec, rules, ctx, options) {
+    let fallback;
+    for (const rule of rules) {
+        for (const candidate of candidatesFor(spec, rule, ctx, options)) {
+            const ref = resolveReference(candidate.node, candidate.ctx);
+            if (ref.ok && ref.constant === undefined && isLiteralOf(unwrap(ref.node), spec.literal)) {
+                return candidate;
+            }
+            fallback ??= candidate;
+        }
+    }
+    return fallback;
+}
+/** Locates and evaluates the target literal in a parsed file */
+export function extractLiteral(parsed, target, ctx, options = {}) {
+    const rules = LOCATING_RULES[target];
+    const candidate = locateLiteral(TARGETS[target], rules, ctx, options);
+    if (!candidate) {
+        return { value: undefined, file: parsed.file, target, tried: rules };
+    }
+    const value = evaluate(candidate.node, ROOT_PATH, candidate.ctx);
+    const root = ctx.sink.lineMap[ROOT_PATH]?.value ?? positionOf(candidate.ctx, candidate.node);
+    return {
+        value,
+        lineMap: ctx.sink.lineMap,
+        unverifiable: ctx.sink.unverifiable,
+        source: { file: root.file, locatedBy: candidate.locatedBy, line: root.line, column: root.column },
+    };
+}
+/** Evaluates a parsed JSON document (already validated by JSON5) for its line map */
+export function jsonLineMap(parsed) {
+    const ctx = createContext(parsed);
+    const statement = parsed.sf.statements[0];
+    if (statement && ts.isExpressionStatement(statement)) {
+        evaluate(statement.expression, ROOT_PATH, ctx);
+    }
+    return ctx.sink;
+}
+//# sourceMappingURL=ts-literal.js.map