@jbrowse/jexl 5.0.0 → 5.0.2

package/README.md

@@ -347,8 +347,10 @@ A name the expression assigns reads the assignment once it has run, and goes thr
 its functions registered:
 
 ```javascript
-const expr = jexl.compile("get(feature, 'score') > 10 ? feature.name : 'n/a'")
-expr.analyze({ accessors: { get: [] }, row: 'feature' })
+import { analyze } from '@jbrowse/jexl'
+
+const ast = jexl.parse("get(feature, 'score') > 10 ? feature.name : 'n/a'")
+analyze(ast, { accessors: { get: [] }, row: 'feature' })
 // {
 //   variables: ['feature'],
 //   fields: [{ path: ['score'] }, { path: ['name'] }],

package/dist/Expression.d.ts

@@ -1,6 +1,4 @@
 import Lexer from './Lexer.ts';
-import type { AnalyzeOptions } from './analyze.ts';
-import type { CheckOptions } from './check.ts';
 import type { CompiledNode } from './evaluator/compile.ts';
 import type { Grammar } from './grammar.ts';
 import type { AstNode } from './types.ts';
@@ -42,15 +40,5 @@ declare class Expression {
     get source(): string;
     /** The parsed tree, or null for an expression with no tokens. */
     get ast(): AstNode | null;
-    /**
-     * Lists what the expression reads from its context, without evaluating it.
-     * See {@link analyze}.
-     */
-    analyze(options?: AnalyzeOptions): import("./analyze.ts").Analysis;
-    /**
-     * Checks the expression against a host's fields and functions, without
-     * evaluating it. See {@link check}.
-     */
-    check(options?: CheckOptions): import("./check.ts").CheckResult;
 }
 export default Expression;

package/dist/Expression.js

@@ -8,8 +8,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const Lexer_ts_1 = __importDefault(require("./Lexer.js"));
-const analyze_ts_1 = require("./analyze.js");
-const check_ts_1 = require("./check.js");
 const compile_ts_1 = require("./evaluator/compile.js");
 const Parser_ts_1 = __importDefault(require("./parser/Parser.js"));
 class Expression {
@@ -78,20 +76,6 @@ class Expression {
         }
         return this._ast;
     }
-    /**
-     * Lists what the expression reads from its context, without evaluating it.
-     * See {@link analyze}.
-     */
-    analyze(options) {
-        return (0, analyze_ts_1.analyze)(this.ast, options);
-    }
-    /**
-     * Checks the expression against a host's fields and functions, without
-     * evaluating it. See {@link check}.
-     */
-    check(options) {
-        return (0, check_ts_1.check)(this.ast, options);
-    }
 }
 exports.default = Expression;
 //# sourceMappingURL=Expression.js.map

package/dist/Expression.js.map

@@ -1 +1 @@
-{"version":3,"file":"Expression.js","sourceRoot":"","sources":["../src/Expression.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;AAEH,0DAA8B;AAC9B,6CAAsC;AACtC,yCAAkC;AAClC,uDAAmD;AACnD,mEAAuC;AAQvC,MAAM,UAAU;IACd,QAAQ,CAAS;IACjB,QAAQ,CAAQ;IAChB;;oDAEgD;IAChD,IAAI,CAAgB;IACpB,MAAM,CAAO;IACb,SAAS,GAAG,KAAK,CAAA;IACjB,2EAA2E;IAC3E,GAAG,GAAwB,IAAI,CAAA;IAE/B;;;;;;;OAOG;IACH,YAAY,OAAgB,EAAE,OAAe,EAAE,KAAa;QAC1D,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;QACvB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,MAAM,GAAG,KAAK,IAAI,IAAI,kBAAK,CAAC,OAAO,CAAC,CAAA;IAC3C,CAAC;IAED;;;;;OAKG;IACH,OAAO;QACL,IAAI,CAAC,IAAI,GAAG,IAAI,mBAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACvE,uEAAuE;QACvE,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAA,uBAAU,EAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;QAClE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAA;QACrB,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;;;OAMG;IACH,IAAI,CAAC,OAAO,GAAG,EAAE;QACf,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,IAAI,CAAC,OAAO,EAAE,CAAA;QAChB,CAAC;QACD,qEAAqE;QACrE,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACd,OAAO,SAAS,CAAA;QAClB,CAAC;QACD,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;IAC1B,CAAC;IAED,yDAAyD;IACzD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,QAAQ,CAAA;IACtB,CAAC;IAED,iEAAiE;IACjE,IAAI,GAAG;QACL,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,IAAI,CAAC,OAAO,EAAE,CAAA;QAChB,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,OAAwB;QAC9B,OAAO,IAAA,oBAAO,EAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;IACnC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAsB;QAC1B,OAAO,IAAA,gBAAK,EAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;IACjC,CAAC;CACF;AAED,kBAAe,UAAU,CAAA"}
+{"version":3,"file":"Expression.js","sourceRoot":"","sources":["../src/Expression.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;AAEH,0DAA8B;AAC9B,uDAAmD;AACnD,mEAAuC;AAMvC,MAAM,UAAU;IACd,QAAQ,CAAS;IACjB,QAAQ,CAAQ;IAChB;;oDAEgD;IAChD,IAAI,CAAgB;IACpB,MAAM,CAAO;IACb,SAAS,GAAG,KAAK,CAAA;IACjB,2EAA2E;IAC3E,GAAG,GAAwB,IAAI,CAAA;IAE/B;;;;;;;OAOG;IACH,YAAY,OAAgB,EAAE,OAAe,EAAE,KAAa;QAC1D,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;QACvB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,MAAM,GAAG,KAAK,IAAI,IAAI,kBAAK,CAAC,OAAO,CAAC,CAAA;IAC3C,CAAC;IAED;;;;;OAKG;IACH,OAAO;QACL,IAAI,CAAC,IAAI,GAAG,IAAI,mBAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACvE,uEAAuE;QACvE,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAA,uBAAU,EAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;QAClE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAA;QACrB,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;;;OAMG;IACH,IAAI,CAAC,OAAO,GAAG,EAAE;QACf,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,IAAI,CAAC,OAAO,EAAE,CAAA;QAChB,CAAC;QACD,qEAAqE;QACrE,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACd,OAAO,SAAS,CAAA;QAClB,CAAC;QACD,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;IAC1B,CAAC;IAED,yDAAyD;IACzD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,QAAQ,CAAA;IACtB,CAAC;IAED,iEAAiE;IACjE,IAAI,GAAG;QACL,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,IAAI,CAAC,OAAO,EAAE,CAAA;QAChB,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;CACF;AAED,kBAAe,UAAU,CAAA"}

package/dist/check.d.ts

@@ -93,11 +93,6 @@ export interface CheckResult {
     type: Type;
 }
 export declare const UNKNOWN: Type;
-/**
- * Renders a tree back to expression text, for messages and suggestions. The
- * text parses back to the same tree.
- */
-export declare function print(ast: AstNode): string;
 /** The type of a row whose fields `schema` declares. */
 export declare function recordOf(schema: readonly FieldSchema[]): Type;
 export declare function union(a: Type, b: Type): Type;

package/dist/check.js

@@ -5,10 +5,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UNKNOWN = void 0;
-exports.print = print;
 exports.recordOf = recordOf;
 exports.union = union;
 exports.check = check;
+const print_ts_1 = require("./print.js");
 exports.UNKNOWN = { kind: 'unknown' };
 const UNDEFINED = { kind: 'undefined' };
 const BOOLEAN = { kind: 'boolean' };
@@ -18,184 +18,6 @@ const MAX_VALUES = 64;
 const ARITHMETIC = new Set(['-', '*', '/', '//', '%', '^']);
 const ORDER = new Set(['<', '<=', '>', '>=']);
 const EQUALITY = new Set(['==', '!=']);
-const PRECEDENCE = {
-    '=': 2,
-    '||': 10,
-    '??': 10,
-    '&&': 11,
-    '==': 20,
-    '!=': 20,
-    '~': 20,
-    '!~': 20,
-    '<': 20,
-    '<=': 20,
-    '>': 20,
-    '>=': 20,
-    in: 20,
-    '+': 30,
-    '-': 30,
-    '*': 40,
-    '/': 40,
-    '//': 40,
-    '%': 50,
-    '^': 50
-};
-const RIGHT_ASSOCIATIVE = new Set(['^']);
-const LOGICAL = new Set(['||', '&&']);
-// how tightly each form binds, mirroring the Parser's levels: `;`, then `=`
-// and lambdas, then `?:`, then binary operators, then prefix operators
-const SEQUENCE = 0;
-const ASSIGNMENT = 1;
-const CONDITIONAL = 2;
-const CUSTOM_BINARY = 3;
-const UNARY = 100;
-const letter = String.raw `a-zA-Zа-яА-Я_À-ÖØ-öø-ÿ$`;
-const IDENTIFIER = new RegExp(`^[${letter}][${letter}0-9]*$`);
-const WORDS = new Set(['in', 'true', 'false', 'null']);
-function isName(text) {
-    return IDENTIFIER.test(text) && !WORDS.has(text);
-}
-function key(name) {
-    return isName(name) ? `.${name}` : `[${quote(name)}]`;
-}
-function quote(text) {
-    return `'${text.replaceAll('\\', '\\\\').replaceAll("'", String.raw `\'`)}'`;
-}
-function precedenceOf(node) {
-    switch (node.type) {
-        case 'SequenceExpression': {
-            return SEQUENCE;
-        }
-        case 'AssignmentExpression':
-        case 'Lambda': {
-            return ASSIGNMENT;
-        }
-        case 'ConditionalExpression': {
-            // with no alternate, it ends only before `)`, `]`, `}`, `,`, `;` or the end
-            return node.alternate ? CONDITIONAL : SEQUENCE;
-        }
-        case 'BinaryExpression': {
-            return PRECEDENCE[node.operator] ?? CUSTOM_BINARY;
-        }
-        case 'UnaryExpression': {
-            return UNARY;
-        }
-        default: {
-            return Infinity;
-        }
-    }
-}
-function within(ast, least) {
-    const text = print(ast);
-    return precedenceOf(ast) < least ? `(${text})` : text;
-}
-function binaryOperand(parent, ast, left) {
-    const own = PRECEDENCE[parent.operator];
-    if (own === undefined) {
-        return within(ast, UNARY);
-    }
-    const child = ast;
-    const theirs = precedenceOf(child);
-    const chained = child.type === 'BinaryExpression' &&
-        RIGHT_ASSOCIATIVE.has(parent.operator) &&
-        RIGHT_ASSOCIATIVE.has(child.operator);
-    const mixesNullish = child.type === 'BinaryExpression' &&
-        ((parent.operator === '??' && LOGICAL.has(child.operator)) ||
-            (child.operator === '??' && LOGICAL.has(parent.operator)));
-    const text = print(ast);
-    return theirs < own || (theirs === own && left === chained) || mixesNullish
-        ? `(${text})`
-        : text;
-}
-/**
- * Renders a tree back to expression text, for messages and suggestions. The
- * text parses back to the same tree.
- */
-function print(ast) {
-    const node = ast;
-    switch (node.type) {
-        case 'Literal': {
-            const { value } = node;
-            return typeof value === 'string'
-                ? quote(value)
-                : Object.is(value, -0)
-                    ? '-0'
-                    : String(value);
-        }
-        case 'Identifier': {
-            return node.from
-                ? within(node.from, Infinity) + key(node.value)
-                : node.value;
-        }
-        case 'FilterExpression': {
-            return `${within(node.subject, Infinity)}[${within(node.expr, ASSIGNMENT)}]`;
-        }
-        case 'BinaryExpression': {
-            return `${binaryOperand(node, node.left, true)} ${node.operator} ${binaryOperand(node, node.right, false)}`;
-        }
-        case 'UnaryExpression': {
-            const { operator } = node;
-            const right = within(node.right, UNARY);
-            // the Lexer folds a minus before a digit into the number
-            if (operator === '-' && /^\d/.test(right)) {
-                return `-(${right})`;
-            }
-            return IDENTIFIER.test(operator)
-                ? `${operator} ${right}`
-                : operator + right;
-        }
-        case 'ConditionalExpression': {
-            const test = within(node.test, CUSTOM_BINARY);
-            const consequent = node.consequent
-                ? ` ${within(node.consequent, ASSIGNMENT)} `
-                : '';
-            const alternate = node.alternate
-                ? ` ${within(node.alternate, ASSIGNMENT)}`
-                : '';
-            return `${test} ?${consequent}:${alternate}`;
-        }
-        case 'FunctionCall': {
-            const args = node.args.map((arg) => within(arg, ASSIGNMENT));
-            return `${node.name}(${args.join(', ')})`;
-        }
-        case 'ArrayLiteral': {
-            const items = node.value.map((item) => within(item, ASSIGNMENT));
-            return `[${items.join(', ')}]`;
-        }
-        case 'ObjectLiteral': {
-            const entries = Object.entries(node.value).map(([name, value]) => `${isName(name) ? name : quote(name)}: ${within(value, ASSIGNMENT)}`);
-            return `{${entries.join(', ')}}`;
-        }
-        case 'TemplateLiteral': {
-            const parts = node.parts.map((part) => part.type === 'static'
-                ? part.value
-                    .replaceAll('\\', '\\\\')
-                    .replaceAll('`', '\\`')
-                    .replaceAll('${', '\\${')
-                : `\${${print(part.value)}}`);
-            return `\`${parts.join('')}\``;
-        }
-        case 'SequenceExpression': {
-            const { expressions } = node;
-            const text = expressions
-                .map((expr) => within(expr, ASSIGNMENT))
-                .join('; ');
-            return expressions.length === 1 ? `${text};` : text;
-        }
-        case 'AssignmentExpression': {
-            return `${node.left.value} = ${within(node.right, ASSIGNMENT)}`;
-        }
-        case 'Lambda': {
-            const params = node.params.length === 1
-                ? node.params[0]
-                : `(${node.params.join(', ')})`;
-            return `${params} => ${within(node.body, ASSIGNMENT)}`;
-        }
-        default: {
-            return '?';
-        }
-    }
-}
 function distance(a, b) {
     let before = [];
     let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
@@ -574,8 +396,8 @@ function paramName(subject, context) {
     const base = node.type === 'Identifier'
         ? node.value.toLowerCase().replaceAll(/\W/g, '')
         : '';
-    const name = isName(base) ? base : 'x';
-    const text = print(context);
+    const name = (0, print_ts_1.isName)(base) ? base : 'x';
+    const text = (0, print_ts_1.print)(context);
     let candidate = name;
     for (let i = 2; new RegExp(String.raw `\b${candidate}\b`).test(text); i++) {
         candidate = `${name}${i}`;
@@ -597,7 +419,7 @@ function describe(type) {
             return type.values?.length === 1 ? String(type.values[0]) : 'a number';
         }
         case 'string': {
-            return type.values?.length === 1 ? quote(type.values[0]) : 'text';
+            return type.values?.length === 1 ? (0, print_ts_1.quote)(type.values[0]) : 'text';
         }
         case 'boolean': {
             return type.field?.type === 'flag' ? 'a flag' : 'a boolean';
@@ -671,10 +493,10 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
         });
     }
     function text(node, name) {
-        return node ? print(node) + key(name) : name;
+        return node ? (0, print_ts_1.print)(node) + (0, print_ts_1.key)(name) : name;
     }
     function field(subject, name, node, subjectNode, spell = (candidate) => text(subjectNode, candidate)) {
-        const where = subjectNode ? print(subjectNode) : 'the row';
+        const where = subjectNode ? (0, print_ts_1.print)(subjectNode) : 'the row';
         switch (subject.kind) {
             case 'record': {
                 const found = subject.fields.get(name) ?? subject.each;
@@ -698,16 +520,16 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
                         (item.open || !!item.each || item.fields.has(name)));
                 const suggestions = [];
                 if (entriesHave && subjectNode && node.type === 'Identifier') {
-                    const list = print(subjectNode);
+                    const list = (0, print_ts_1.print)(subjectNode);
                     const param = paramName(subjectNode, node);
-                    suggestions.push(`${list}[0]${key(name)}`);
+                    suggestions.push(`${list}[0]${(0, print_ts_1.key)(name)}`);
                     if (functions?.map) {
-                        suggestions.push(`map(${list}, ${param} => ${param}${key(name)})`);
+                        suggestions.push(`map(${list}, ${param} => ${param}${(0, print_ts_1.key)(name)})`);
                     }
                 }
-                report('dot-through-list', 'warning', node, `${where} is a list, so ${key(name)} is undefined` +
+                report('dot-through-list', 'warning', node, `${where} is a list, so ${(0, print_ts_1.key)(name)} is undefined` +
                     (entriesHave
-                        ? `; [0]${key(name)} reads the first entry's` +
+                        ? `; [0]${(0, print_ts_1.key)(name)} reads the first entry's` +
                             (functions?.any ? ', and any() tests each' : '')
                         : ''), suggestions);
                 return UNDEFINED;
@@ -730,7 +552,7 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
         return exports.UNKNOWN;
     }
     function index(subject, at, node, subjectNode) {
-        const where = print(subjectNode);
+        const where = (0, print_ts_1.print)(subjectNode);
         switch (subject.kind) {
             case 'list': {
                 const absent = firstAbsentIndex(subject.cardinality);
@@ -791,8 +613,8 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
                 const stepReaches = step?.kind === 'record' &&
                     (step.fields.has(names[i + 1]) || !!step.each);
                 if (record.fields.has(whole) && !stepReaches) {
-                    const fixed = print(subjectNode) + key(whole);
-                    report('dotted-key', 'warning', node, `${whole} is one field of ${print(subjectNode)}; jexl reads ${names.slice(i, j).join(' then ')}`, [[fixed, ...names.slice(j).map((name) => key(name))].join('')]);
+                    const fixed = (0, print_ts_1.print)(subjectNode) + (0, print_ts_1.key)(whole);
+                    report('dotted-key', 'warning', node, `${whole} is one field of ${(0, print_ts_1.print)(subjectNode)}; jexl reads ${names.slice(i, j).join(' then ')}`, [[fixed, ...names.slice(j).map((name) => (0, print_ts_1.key)(name))].join('')]);
                     let resolved = record.fields.get(whole);
                     for (const name of names.slice(j)) {
                         resolved = field(resolved, name, node, undefined);
@@ -865,7 +687,7 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
         if (!found) {
             return undefined;
         }
-        report('unknown-field', 'warning', node, `${print(node)} subtracts; ${whole} is one field`, [text(left.from, whole)]);
+        report('unknown-field', 'warning', node, `${(0, print_ts_1.print)(node)} subtracts; ${whole} is one field`, [text(left.from, whole)]);
         return found;
     }
     function memberFor(element, value, valueNode, listNode, node) {
@@ -878,10 +700,10 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
                 const scalar = type.kind === 'list' ? type.of : type;
                 return scalar.kind === 'string' && scalar.values?.includes(literal);
             });
-            report('never-equal', 'warning', node, `${print(listNode)} holds records, so no entry equals ${quote(literal)}` +
+            report('never-equal', 'warning', node, `${(0, print_ts_1.print)(listNode)} holds records, so no entry equals ${(0, print_ts_1.quote)(literal)}` +
                 (holder ? `; it is a value of their ${holder[0]} field` : ''), holder && functions?.any
                 ? [
-                    `any(${print(listNode)}, ${paramName(listNode, node)} => ${print(valueNode)} in ${paramName(listNode, node)}${key(holder[0])})`
+                    `any(${(0, print_ts_1.print)(listNode)}, ${paramName(listNode, node)} => ${(0, print_ts_1.print)(valueNode)} in ${paramName(listNode, node)}${(0, print_ts_1.key)(holder[0])})`
                 ]
                 : []);
             return;
@@ -892,21 +714,21 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
         if (type.kind === 'number' &&
             typeof literal === 'string' &&
             Number.isNaN(Number(literal))) {
-            report('never-equal', 'warning', node, `${quote(literal)} is not a number, so it never equals ${describe(type)}`);
+            report('never-equal', 'warning', node, `${(0, print_ts_1.quote)(literal)} is not a number, so it never equals ${describe(type)}`);
         }
         else if (type.kind === 'boolean' && typeof literal === 'string') {
-            report('never-equal', 'warning', node, `${describe(type)} never equals the text ${quote(literal)}`, literal === 'true' || literal === 'false' ? [literal] : []);
+            report('never-equal', 'warning', node, `${describe(type)} never equals the text ${(0, print_ts_1.quote)(literal)}`, literal === 'true' || literal === 'false' ? [literal] : []);
         }
         else if (type.kind === 'string' &&
             type.field?.categories &&
             typeof literal === 'string' &&
             !type.field.categories.includes(literal)) {
             const near = nearest(literal, type.field.categories);
-            report('unknown-category', 'warning', node, `${quote(literal)} is not one of the values the header declares for ${type.field.path.join('.')}` +
-                (near.length ? `; did you mean ${near.map(quote).join(', ')}?` : ''), near.map(quote));
+            report('unknown-category', 'warning', node, `${(0, print_ts_1.quote)(literal)} is not one of the values the header declares for ${type.field.path.join('.')}` +
+                (near.length ? `; did you mean ${near.map(print_ts_1.quote).join(', ')}?` : ''), near.map(print_ts_1.quote));
         }
         else if (type.kind === 'record') {
-            report('never-equal', 'warning', node, `a record never equals ${quote(String(literal))}`);
+            report('never-equal', 'warning', node, `a record never equals ${(0, print_ts_1.quote)(String(literal))}`);
         }
     }
     function binary(node) {
@@ -929,7 +751,7 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
         if (operator === '~' || operator === '!~') {
             const pattern = literalOf(right);
             if (typeof pattern === 'string' && !isPattern(pattern)) {
-                report('invalid-pattern', 'error', node, `${quote(pattern)} is not a valid regular expression`);
+                report('invalid-pattern', 'error', node, `${(0, print_ts_1.quote)(pattern)} is not a valid regular expression`);
             }
             return BOOLEAN;
         }
@@ -945,7 +767,7 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
             second &&
             (ARITHMETIC.has(operator) || operator === '+') &&
             !pairs(first.cardinality, second.cardinality)) {
-            report('list-lengths', 'warning', node, `${print(node.left)} ${holding(first)} and ${print(rightNode)} ${holding(second)}, so ${operator} pairs them only where both hold one value`);
+            report('list-lengths', 'warning', node, `${(0, print_ts_1.print)(node.left)} ${holding(first)} and ${(0, print_ts_1.print)(rightNode)} ${holding(second)}, so ${operator} pairs them only where both hold one value`);
         }
         const eachOf = (item) => first ? { kind: 'list', of: item, cardinality: first.cardinality } : item;
         if (operator === '+') {
@@ -960,9 +782,9 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
             ]) {
                 const numericOther = ARITHMETIC.has(operator) || isNumberish(other);
                 if (type.kind === 'string' && type.field && numericOther) {
-                    report('string-numeric', 'warning', node, `${print(typeNode)} is text, so ${operator} converts it to a number, ${ORDER.has(operator) ? 'answering false' : 'giving NaN'} wherever it is not one`, functions?.parseFloat
+                    report('string-numeric', 'warning', node, `${(0, print_ts_1.print)(typeNode)} is text, so ${operator} converts it to a number, ${ORDER.has(operator) ? 'answering false' : 'giving NaN'} wherever it is not one`, functions?.parseFloat
                         ? [
-                            print(node).replace(print(typeNode), `parseFloat(${print(typeNode)})`)
+                            (0, print_ts_1.print)(node).replace((0, print_ts_1.print)(typeNode), `parseFloat(${(0, print_ts_1.print)(typeNode)})`)
                         ]
                         : []);
                 }
@@ -987,7 +809,7 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
                 memberFor(right.of, leftItem, node.left, rightNode, node);
             }
             else if (right.kind === 'number' || right.kind === 'boolean') {
-                report('never-equal', 'warning', node, `in tests a list, text, a Set, a Map or an object's keys, and ${print(rightNode)} is ${describe(right)}`);
+                report('never-equal', 'warning', node, `in tests a list, text, a Set, a Map or an object's keys, and ${(0, print_ts_1.print)(rightNode)} is ${describe(right)}`);
             }
             return BOOLEAN;
         }
@@ -1066,7 +888,7 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
                     keyArgs.forEach(infer);
                     return exports.UNKNOWN;
                 }
-                step(String(name), arg, quote);
+                step(String(name), arg, print_ts_1.quote);
             }
             return type;
         }
@@ -1076,7 +898,7 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
             if (functions) {
                 const near = nearest(name, Object.keys(functions));
                 report('unknown-function', 'error', node, `no function ${name}` +
-                    (near.length ? `; did you mean ${near.join(', ')}?` : ''), near.map((candidate) => print({ ...node, name: candidate })));
+                    (near.length ? `; did you mean ${near.join(', ')}?` : ''), near.map((candidate) => (0, print_ts_1.print)({ ...node, name: candidate })));
             }
             return exports.UNKNOWN;
         }
@@ -1104,7 +926,7 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
             const type = infer(arg);
             types.push(type);
             if (accepted.includes('lambda')) {
-                report('argument-type', 'error', arg, `${name} expects a function such as x => …, not ${print(arg)}`);
+                report('argument-type', 'error', arg, `${name} expects a function such as x => …, not ${(0, print_ts_1.print)(arg)}`);
                 continue;
             }
             if (accepted.includes('member') && lastCollection && lastCollectionNode) {
@@ -1119,7 +941,7 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
                     ? 'list-operand'
                     : type.kind === 'string'
                         ? 'string-numeric'
-                        : 'argument-type', 'warning', arg, `${name} expects ${accepted.join(' or ')} as argument ${i + 1}, but ${print(arg)} ${problems[0]}`);
+                        : 'argument-type', 'warning', arg, `${name} expects ${accepted.join(' or ')} as argument ${i + 1}, but ${(0, print_ts_1.print)(arg)} ${problems[0]}`);
             }
             if (accepted.includes('list')) {
                 lastCollection = type;
@@ -1166,14 +988,14 @@ function check(ast, { schema, functions, accessors = {}, row, env } = {}) {
                 }
                 if (typeof at === 'string') {
                     if (subject.kind === 'list' && at !== 'length') {
-                        report('unknown-field', 'warning', node, `${print(node.subject)} is ${describe(subject)}, so [${quote(at)}] reads nothing`);
+                        report('unknown-field', 'warning', node, `${(0, print_ts_1.print)(node.subject)} is ${describe(subject)}, so [${(0, print_ts_1.quote)(at)}] reads nothing`);
                         return UNDEFINED;
                     }
                     return field(subject, at, node, node.subject);
                 }
                 const by = infer(node.expr);
                 if (isMulti(by)) {
-                    report('list-operand', 'warning', node, `${print(node.expr)} ${holding(by)}, so indexing by it finds an entry only when there is exactly one`);
+                    report('list-operand', 'warning', node, `${(0, print_ts_1.print)(node.expr)} ${holding(by)}, so indexing by it finds an entry only when there is exactly one`);
                 }
                 if (subject.kind === 'record') {
                     return unionAll([