openalgo-script 0.1.0-alpha.0

package/dist/core/ast/children.js

@@ -0,0 +1,103 @@
+const NO_CHILDREN = [];
+/** The nodes among these that are there, keeping the order they were given in. */
+function present(...nodes) {
+    return nodes.filter((node) => node !== undefined);
+}
+/**
+ * The children of a node, in source order.
+ *
+ * This is the only place the shape of the tree is written down twice, and it is
+ * deliberately the only one. Everything that walks the tree walks it through
+ * here, so a field added to a node is connected once and every pass sees it,
+ * rather than being connected in the checker, forgotten in the code generator,
+ * and found by a user whose script compiled to something with a hole in it.
+ *
+ * The switch has no default arm on purpose: a new node kind stops the build
+ * here, at the one place that has to know about it.
+ */
+export function childrenOf(node) {
+    switch (node.kind) {
+        // The file and what only the file holds.
+        case 'script':
+            return node.items;
+        case 'functionDeclaration':
+            return [node.name, ...node.parameters, node.body];
+        case 'parameter':
+            return present(node.name, node.annotation, node.defaultValue);
+        // The header lines, which are statements wherever they are written.
+        case 'versionLine':
+            return [node.version];
+        case 'scriptDeclaration':
+            return node.args;
+        case 'limitsLine':
+            return node.args;
+        // Statements.
+        case 'expressionStatement':
+            return [node.expression];
+        case 'assignment':
+            return [node.target, node.value];
+        case 'varDeclaration':
+            return present(node.name, node.annotation, node.initialiser);
+        case 'ifStatement':
+            return present(...node.branches, node.elseBranch);
+        case 'ifBranch':
+            return [node.condition, node.body];
+        case 'elseBranch':
+            return [node.body];
+        case 'forRangeStatement':
+            return present(node.variable, node.from, node.to, node.step, node.body);
+        case 'forInStatement':
+            return [node.variable, node.iterable, node.body];
+        case 'whileStatement':
+            return [node.condition, node.body];
+        case 'switchStatement':
+            return present(node.subject, ...node.cases, node.defaultCase);
+        case 'switchCase':
+            return [...node.values, node.body];
+        case 'switchDefault':
+            return [node.body];
+        case 'breakStatement':
+        case 'continueStatement':
+            return NO_CHILDREN;
+        case 'returnStatement':
+            return present(node.value);
+        case 'block':
+            return node.statements;
+        // Expressions.
+        case 'numberLiteral':
+        case 'stringLiteral':
+        case 'booleanLiteral':
+        case 'colorLiteral':
+        case 'noneLiteral':
+        case 'nameReference':
+        case 'missingExpression':
+            return NO_CHILDREN;
+        case 'arrayLiteral':
+            return node.elements;
+        case 'grouping':
+            return [node.expression];
+        case 'unary':
+            return [node.operand];
+        case 'binary':
+            return [node.left, node.right];
+        case 'ternary':
+            return [node.condition, node.whenTrue, node.whenFalse];
+        case 'call':
+            return [node.callee, ...node.args];
+        case 'argument':
+            return present(node.label, node.value);
+        case 'index':
+            return [node.target, node.index];
+        case 'member':
+            return [node.object, node.member];
+        // Type annotations, and a name where one is written.
+        case 'namedType':
+            return NO_CHILDREN;
+        case 'seriesType':
+        case 'arrayType':
+            return [node.element];
+        case 'name':
+            return NO_CHILDREN;
+    }
+}
+//# sourceMappingURL=children.js.map

package/dist/core/ast/children.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"children.js","sourceRoot":"","sources":["../../../src/core/ast/children.ts"],"names":[],"mappings":"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"}

package/dist/core/ast/expressions.d.ts

@@ -0,0 +1,178 @@
+import type { Positioned } from '../span/index.js';
+import type { Name } from './name.js';
+/**
+ * Every expression form of language.md section 9.
+ *
+ * Precedence is not a field anywhere below. It is in the shape of the tree: the
+ * parser reads the levels of 9.1 and the result is already grouped, so a later
+ * pass never has to know that `*` binds tighter than `+`. The one thing the
+ * tree does keep is the brackets a script wrote, because they are the
+ * difference between a caret under `(a < b)` and a caret under a whole line.
+ */
+export declare const ARITHMETIC_OPERATORS: readonly ["+", "-", "*", "/", "%"];
+export type ArithmeticOperator = (typeof ARITHMETIC_OPERATORS)[number];
+export declare const COMPARISON_OPERATORS: readonly ["<", "<=", ">", ">="];
+export type ComparisonOperator = (typeof COMPARISON_OPERATORS)[number];
+export declare const EQUALITY_OPERATORS: readonly ["==", "!="];
+export type EqualityOperator = (typeof EQUALITY_OPERATORS)[number];
+export declare const LOGICAL_OPERATORS: readonly ["and", "or"];
+export type LogicalOperator = (typeof LOGICAL_OPERATORS)[number];
+export type BinaryOperator = ArithmeticOperator | ComparisonOperator | EqualityOperator | LogicalOperator;
+export declare const UNARY_OPERATORS: readonly ["-", "+", "not"];
+export type UnaryOperator = (typeof UNARY_OPERATORS)[number];
+export declare function binaryPrecedence(operator: BinaryOperator): number;
+/**
+ * The value a number literal denotes, already read.
+ *
+ * The digit group underscores and the hexadecimal form of language.md 3.5 are
+ * resolved by the lexer, so nothing downstream reads the text a second time and
+ * nothing downstream can disagree with the lexer about what it meant.
+ */
+export interface NumberLiteral extends Positioned {
+    readonly kind: 'numberLiteral';
+    readonly value: number;
+}
+/** A string literal with its escape sequences already resolved. */
+export interface StringLiteral extends Positioned {
+    readonly kind: 'stringLiteral';
+    readonly value: string;
+}
+export interface BooleanLiteral extends Positioned {
+    readonly kind: 'booleanLiteral';
+    readonly value: boolean;
+}
+/**
+ * The `#rrggbb` and `#rrggbbaa` forms of language.md 3.8, text and all.
+ *
+ * A named colour is not one of these. The nineteen names are ordinary globals
+ * so the standard library can add more without a grammar change, so `aqua` is a
+ * `nameReference` and the checker resolves it like any other name.
+ *
+ * The text is kept rather than four channel numbers, because the channels are
+ * the checker's reading of it and a diagnostic about a malformed colour has to
+ * quote what was written.
+ */
+export interface ColorLiteral extends Positioned {
+    readonly kind: 'colorLiteral';
+    readonly text: string;
+}
+/** `none`, the absent value of language.md section 6. */
+export interface NoneLiteral extends Positioned {
+    readonly kind: 'noneLiteral';
+}
+/**
+ * `[1, 2, 3]`, and `[]`.
+ *
+ * An empty literal is legal here. Its element type is unknown until the checker
+ * finds an annotation or a first use, and OS2015 when it finds neither.
+ */
+export interface ArrayLiteral extends Positioned {
+    readonly kind: 'arrayLiteral';
+    readonly elements: readonly Expression[];
+}
+/** A name used as a value. Its span is the name, so it carries no child. */
+export interface NameReference extends Positioned {
+    readonly kind: 'nameReference';
+    readonly name: string;
+}
+/**
+ * `(expression)`.
+ *
+ * Kept rather than folded away, because both passes that point back at source
+ * need it: a diagnostic about a grouped expression underlines the brackets a
+ * reader can see, and a formatter that dropped them would turn `(a + b) * c`
+ * into something else on its first reprint. A pass that wants the value inside
+ * calls `withoutGrouping`.
+ */
+export interface Grouping extends Positioned {
+    readonly kind: 'grouping';
+    readonly expression: Expression;
+}
+export interface Unary extends Positioned {
+    readonly kind: 'unary';
+    readonly operator: UnaryOperator;
+    readonly operand: Expression;
+}
+export interface Binary extends Positioned {
+    readonly kind: 'binary';
+    readonly operator: BinaryOperator;
+    readonly left: Expression;
+    readonly right: Expression;
+}
+/** `condition ? whenTrue : whenFalse`, language.md 9.5. */
+export interface Ternary extends Positioned {
+    readonly kind: 'ternary';
+    readonly condition: Expression;
+    readonly whenTrue: Expression;
+    readonly whenFalse: Expression;
+}
+/**
+ * One argument of a call, of `study()`, of `strategy()` or of `limits()`.
+ *
+ * A label is a `Name` and not a `nameReference` because it is never resolved.
+ * It is matched against the callee's parameter list, which is what lets a
+ * reserved word stand as one (language.md 3.4).
+ */
+export interface Argument extends Positioned {
+    readonly kind: 'argument';
+    readonly label: Name | undefined;
+    readonly value: Expression;
+}
+/**
+ * A call, with its arguments in the order they were written.
+ *
+ * Positional after named is OS3005, a check rather than a shape, so nothing is
+ * sorted on the way in and the tree keeps the order that error has to quote.
+ * The callee is an expression because `draw.box(...)` is an argument list
+ * applied to a member access, and because `f(1)(2)` has to parse before it can
+ * be told that it is not a thing OpenScript does.
+ */
+export interface Call extends Positioned {
+    readonly kind: 'call';
+    readonly callee: Expression;
+    readonly args: readonly Argument[];
+}
+/**
+ * `target[index]`: history when the target is a series, element access when it
+ * is an array, and the checker decides which from the target's type
+ * (language.md 9.6). There is no run-time dispatch and no third meaning.
+ *
+ * The explicit forms `history(expr, n)` and `element(arr, i)` are ordinary
+ * calls and are not this node.
+ */
+export interface Index extends Positioned {
+    readonly kind: 'index';
+    readonly target: Expression;
+    readonly index: Expression;
+}
+/**
+ * `object.member`.
+ *
+ * A namespace read such as `bar.index` and a field of a runtime object are one
+ * shape here. Which of the two it is, and whether the member exists at all
+ * (OS2009), is the checker's answer.
+ */
+export interface Member extends Positioned {
+    readonly kind: 'member';
+    readonly object: Expression;
+    readonly member: Name;
+}
+/**
+ * A hole where an expression was required and none was written.
+ *
+ * The parser puts one here after reporting OS1022, OS1011 or OS1015, so a file
+ * with a mistake in it still produces a tree. Everything downstream runs on
+ * broken files by definition: an editor asks for completions inside a half
+ * typed line, and a checker that stopped at the first syntax error would report
+ * one mistake per compile.
+ *
+ * The span is where the expression should have been, and is usually empty, so
+ * it never takes a caret meant for its neighbour.
+ */
+export interface MissingExpression extends Positioned {
+    readonly kind: 'missingExpression';
+}
+export type Expression = NumberLiteral | StringLiteral | BooleanLiteral | ColorLiteral | NoneLiteral | ArrayLiteral | NameReference | Grouping | Unary | Binary | Ternary | Call | Index | Member | MissingExpression;
+/** The expression inside however many brackets were written around it. */
+export declare function withoutGrouping(expression: Expression): Expression;
+//# sourceMappingURL=expressions.d.ts.map

package/dist/core/ast/expressions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../../src/core/ast/expressions.ts"],"names":[],"mappings":"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"}

package/dist/core/ast/expressions.js

@@ -0,0 +1,50 @@
+/**
+ * Every expression form of language.md section 9.
+ *
+ * Precedence is not a field anywhere below. It is in the shape of the tree: the
+ * parser reads the levels of 9.1 and the result is already grouped, so a later
+ * pass never has to know that `*` binds tighter than `+`. The one thing the
+ * tree does keep is the brackets a script wrote, because they are the
+ * difference between a caret under `(a < b)` and a caret under a whole line.
+ */
+export const ARITHMETIC_OPERATORS = ['+', '-', '*', '/', '%'];
+export const COMPARISON_OPERATORS = ['<', '<=', '>', '>='];
+export const EQUALITY_OPERATORS = ['==', '!='];
+export const LOGICAL_OPERATORS = ['and', 'or'];
+export const UNARY_OPERATORS = ['-', '+', 'not'];
+/**
+ * The level each binary operator sits at in language.md 9.1, where a lower
+ * number binds more tightly.
+ *
+ * The numbers are the specification's own rather than a private scale that runs
+ * the other way, so a reader can check this table against language.md 9.1
+ * without translating it as they read. It sits next to the operators because a
+ * parser and a formatter that each kept a copy would disagree about one
+ * operator eventually, and that disagreement reaches a chart as a wrong number.
+ */
+const BINARY_PRECEDENCE = {
+    '*': 3,
+    '/': 3,
+    '%': 3,
+    '+': 4,
+    '-': 4,
+    '<': 5,
+    '<=': 5,
+    '>': 5,
+    '>=': 5,
+    '==': 6,
+    '!=': 6,
+    and: 7,
+    or: 8,
+};
+export function binaryPrecedence(operator) {
+    return BINARY_PRECEDENCE[operator];
+}
+/** The expression inside however many brackets were written around it. */
+export function withoutGrouping(expression) {
+    let inner = expression;
+    while (inner.kind === 'grouping')
+        inner = inner.expression;
+    return inner;
+}
+//# sourceMappingURL=expressions.js.map

package/dist/core/ast/expressions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressions.js","sourceRoot":"","sources":["../../../src/core/ast/expressions.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAU,CAAC;AAGvE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAU,CAAC;AAGpE,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,IAAI,EAAE,IAAI,CAAU,CAAC;AAGxD,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,IAAI,CAAU,CAAC;AASxD,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,CAAU,CAAC;AAG1D;;;;;;;;;GASG;AACH,MAAM,iBAAiB,GAA6C;IAClE,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,IAAI,EAAE,CAAC;IACP,GAAG,EAAE,CAAC;IACN,IAAI,EAAE,CAAC;IACP,IAAI,EAAE,CAAC;IACP,IAAI,EAAE,CAAC;IACP,GAAG,EAAE,CAAC;IACN,EAAE,EAAE,CAAC;CACN,CAAC;AAEF,MAAM,UAAU,gBAAgB,CAAC,QAAwB;IACvD,OAAO,iBAAiB,CAAC,QAAQ,CAAC,CAAC;AACrC,CAAC;AA0LD,0EAA0E;AAC1E,MAAM,UAAU,eAAe,CAAC,UAAsB;IACpD,IAAI,KAAK,GAAG,UAAU,CAAC;IACvB,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU;QAAE,KAAK,GAAG,KAAK,CAAC,UAAU,CAAC;IAC3D,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/core/ast/header.d.ts

@@ -0,0 +1,50 @@
+import type { Positioned } from '../span/index.js';
+import type { Argument, NumberLiteral } from './expressions.js';
+/**
+ * The three lines that describe the file rather than compute anything: the
+ * version line, the study or strategy declaration, and the limits line.
+ *
+ * All three are statements, and the tree lets them appear anywhere a statement
+ * appears. The specification calls each one a statement (4, 13.1 and 10.7), and
+ * more to the point the errors for putting one in the wrong place are OS1021,
+ * OS2007 and OS2008, which name a line and suggest a move. A tree with one slot
+ * for the declaration could not hold the second one long enough for OS2008 to
+ * say where it was, and a tree that refused a file with no declaration at all
+ * would turn OS2007 into a parse failure with nothing else checked.
+ */
+/**
+ * `version 1`.
+ *
+ * `version` is not a reserved word: it is an ordinary identifier to the lexer,
+ * recognised here by its position, so that a script written before the word
+ * existed keeps compiling (language.md 3.4 and 4.1).
+ */
+export interface VersionLine extends Positioned {
+    readonly kind: 'versionLine';
+    readonly version: NumberLiteral;
+}
+/**
+ * `study("Name", ...)` or `strategy("Name", ...)`, language.md 13.1.
+ *
+ * The form is kept as the word that was written rather than as a boolean,
+ * because it is what OS2008 and OS7001 quote back to the reader, and because a
+ * later version that adds a third form adds a member here rather than a second
+ * flag.
+ */
+export interface ScriptDeclaration extends Positioned {
+    readonly kind: 'scriptDeclaration';
+    readonly form: 'study' | 'strategy';
+    readonly args: readonly Argument[];
+}
+/**
+ * `limits(loops = 50_000_000)`, language.md 10.7.
+ *
+ * Which options exist, that the values are literal numbers, and that the host
+ * is willing to run them (OS5003) are all decided later. The tree carries the
+ * arguments as written.
+ */
+export interface LimitsLine extends Positioned {
+    readonly kind: 'limitsLine';
+    readonly args: readonly Argument[];
+}
+//# sourceMappingURL=header.d.ts.map

package/dist/core/ast/header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../../src/core/ast/header.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEhE;;;;;;;;;;;GAWG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,WAAY,SAAQ,UAAU;IAC7C,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;CACpC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAW,SAAQ,UAAU;IAC5C,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;CACpC"}

package/dist/core/ast/header.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=header.js.map

package/dist/core/ast/header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.js","sourceRoot":"","sources":["../../../src/core/ast/header.ts"],"names":[],"mappings":""}

package/dist/core/ast/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The syntax tree of language.md, and the one traversal over it.
+ *
+ * Types and constructors, and no parsing: the tree is what the parser produces
+ * and what the checker, the code generator and the editor's intelligence all
+ * read, so it is defined on its own and none of the four owns it.
+ *
+ * Two things here are worth knowing before reading the rest. Every node carries
+ * a `Span`, so anything the compiler says about a node has a caret. And every
+ * node is a member of one discriminated union, `AstNode`, so a pass that
+ * switches on `kind` without a default arm is told at compile time about the
+ * kinds it has not handled.
+ */
+export type { Name } from './name.js';
+export type { ArrayType, NamedType, ObjectTypeName, SeriesType, TypeAnnotation, ValueTypeName, } from './annotations.js';
+export { OBJECT_TYPE_NAMES, VALUE_TYPE_NAMES, isObjectTypeName, isValueTypeName, } from './annotations.js';
+export type { ArithmeticOperator, Argument, ArrayLiteral, Binary, BinaryOperator, BooleanLiteral, Call, ColorLiteral, ComparisonOperator, EqualityOperator, Expression, Grouping, Index, LogicalOperator, Member, MissingExpression, NameReference, NoneLiteral, NumberLiteral, StringLiteral, Ternary, Unary, UnaryOperator, } from './expressions.js';
+export { ARITHMETIC_OPERATORS, COMPARISON_OPERATORS, EQUALITY_OPERATORS, LOGICAL_OPERATORS, UNARY_OPERATORS, binaryPrecedence, withoutGrouping, } from './expressions.js';
+export type { LimitsLine, ScriptDeclaration, VersionLine } from './header.js';
+export type { Assignment, AssignmentOperator, Block, BreakStatement, ContinueStatement, ElseBranch, ExpressionStatement, ForInStatement, ForRangeStatement, IfBranch, IfStatement, ReturnStatement, Statement, SwitchCase, SwitchDefault, SwitchStatement, VarDeclaration, WhileStatement, } from './statements.js';
+export { ASSIGNMENT_OPERATORS } from './statements.js';
+export type { FunctionDeclaration, Parameter, Script, TopLevelItem } from './script.js';
+export type { AstNode, NodeKind, NodeOfKind } from './node.js';
+export { isExpression, isStatement, isTypeAnnotation, typeAnnotationText } from './node.js';
+export type { NodeFields } from './build.js';
+export { makeNode } from './build.js';
+export { childrenOf } from './children.js';
+export type { Visit, Visitor } from './walk.js';
+export { nodeAtOffset, pathAtOffset, walk } from './walk.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/ast/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/ast/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,YAAY,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC,YAAY,EACV,SAAS,EACT,SAAS,EACT,cAAc,EACd,UAAU,EACV,cAAc,EACd,aAAa,GACd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EACV,kBAAkB,EAClB,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,cAAc,EACd,cAAc,EACd,IAAI,EACJ,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,EAChB,UAAU,EACV,QAAQ,EACR,KAAK,EACL,eAAe,EACf,MAAM,EACN,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,aAAa,EACb,aAAa,EACb,OAAO,EACP,KAAK,EACL,aAAa,GACd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE9E,YAAY,EACV,UAAU,EACV,kBAAkB,EAClB,KAAK,EACL,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,QAAQ,EACR,WAAW,EACX,eAAe,EACf,SAAS,EACT,UAAU,EACV,aAAa,EACb,eAAe,EACf,cAAc,EACd,cAAc,GACf,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEvD,YAAY,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAExF,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE5F,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC"}

package/dist/core/ast/index.js

@@ -0,0 +1,21 @@
+/**
+ * The syntax tree of language.md, and the one traversal over it.
+ *
+ * Types and constructors, and no parsing: the tree is what the parser produces
+ * and what the checker, the code generator and the editor's intelligence all
+ * read, so it is defined on its own and none of the four owns it.
+ *
+ * Two things here are worth knowing before reading the rest. Every node carries
+ * a `Span`, so anything the compiler says about a node has a caret. And every
+ * node is a member of one discriminated union, `AstNode`, so a pass that
+ * switches on `kind` without a default arm is told at compile time about the
+ * kinds it has not handled.
+ */
+export { OBJECT_TYPE_NAMES, VALUE_TYPE_NAMES, isObjectTypeName, isValueTypeName, } from './annotations.js';
+export { ARITHMETIC_OPERATORS, COMPARISON_OPERATORS, EQUALITY_OPERATORS, LOGICAL_OPERATORS, UNARY_OPERATORS, binaryPrecedence, withoutGrouping, } from './expressions.js';
+export { ASSIGNMENT_OPERATORS } from './statements.js';
+export { isExpression, isStatement, isTypeAnnotation, typeAnnotationText } from './node.js';
+export { makeNode } from './build.js';
+export { childrenOf } from './children.js';
+export { nodeAtOffset, pathAtOffset, walk } from './walk.js';
+//# sourceMappingURL=index.js.map

package/dist/core/ast/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/ast/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAYH,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,GAChB,MAAM,kBAAkB,CAAC;AA2B1B,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAwB1B,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAKvD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAG5F,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC"}

package/dist/core/ast/name.d.ts

@@ -0,0 +1,24 @@
+import type { Positioned } from '../span/index.js';
+/**
+ * A name at the place it is written rather than the place it is read.
+ *
+ * A name used as a value is a `nameReference`, which the checker resolves
+ * against a scope. Every other name in the language is this node instead: the
+ * left side of an assignment, the name a `var` introduces, a loop variable, a
+ * function's name, a parameter's name, the word after a dot, and the label of a
+ * named argument.
+ *
+ * The two are separate kinds because a pass that walks the tree collecting uses
+ * of a name must not collect the places that introduce one. With a single kind
+ * every such pass has to ask the parent what it is holding, and the pass that
+ * forgets reports OS2001 on the very name being declared.
+ *
+ * The text is not always a legal identifier: a named argument's label may be a
+ * reserved word, because a label is matched against a parameter list and is
+ * never looked up in a scope (language.md 3.4).
+ */
+export interface Name extends Positioned {
+    readonly kind: 'name';
+    readonly text: string;
+}
+//# sourceMappingURL=name.d.ts.map

package/dist/core/ast/name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"name.d.ts","sourceRoot":"","sources":["../../../src/core/ast/name.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,IAAK,SAAQ,UAAU;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB"}

package/dist/core/ast/name.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=name.js.map

package/dist/core/ast/name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"name.js","sourceRoot":"","sources":["../../../src/core/ast/name.ts"],"names":[],"mappings":""}

package/dist/core/ast/node.d.ts

@@ -0,0 +1,34 @@
+import type { TypeAnnotation } from './annotations.js';
+import type { Argument, Expression } from './expressions.js';
+import type { Name } from './name.js';
+import type { FunctionDeclaration, Parameter, Script } from './script.js';
+import type { Block, ElseBranch, IfBranch, Statement, SwitchCase, SwitchDefault } from './statements.js';
+/**
+ * Every node of the tree, as one discriminated union.
+ *
+ * A pass switches on `kind` with no default arm, and the compiler names the
+ * kinds it has not handled. Three passes walk this tree, each of them added
+ * months apart, and each of them will otherwise forget a case: the shape of the
+ * union is the only thing that tells them before a user does.
+ *
+ * The union is `AstNode` rather than `Node` because an adapter that draws into
+ * a page has a `Node` of its own, and a file holding both would be one import
+ * away from a mistake that type checks.
+ */
+export type AstNode = Script | FunctionDeclaration | Parameter | Statement | Block | IfBranch | ElseBranch | SwitchCase | SwitchDefault | Expression | Argument | TypeAnnotation | Name;
+export type NodeKind = AstNode['kind'];
+/** The node type behind one kind, for a pass that indexes by kind. */
+export type NodeOfKind<K extends NodeKind> = Extract<AstNode, {
+    readonly kind: K;
+}>;
+export declare function isExpression(node: AstNode): node is Expression;
+export declare function isStatement(node: AstNode): node is Statement;
+export declare function isTypeAnnotation(node: AstNode): node is TypeAnnotation;
+/**
+ * The name a type annotation carries, for a diagnostic that has to quote it.
+ *
+ * OS2016 and OS2019 both put the annotation into their message, and the reader
+ * expects to see what was written rather than the outermost word of it.
+ */
+export declare function typeAnnotationText(annotation: TypeAnnotation): string;
+//# sourceMappingURL=node.d.ts.map

package/dist/core/ast/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/core/ast/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,KAAK,EACV,KAAK,EACL,UAAU,EACV,QAAQ,EACR,SAAS,EACT,UAAU,EACV,aAAa,EACd,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,OAAO,GACf,MAAM,GACN,mBAAmB,GACnB,SAAS,GACT,SAAS,GACT,KAAK,GACL,QAAQ,GACR,UAAU,GACV,UAAU,GACV,aAAa,GACb,UAAU,GACV,QAAQ,GACR,cAAc,GACd,IAAI,CAAC;AAET,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAEvC,sEAAsE;AACtE,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,QAAQ,IAAI,OAAO,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,CAAC;AAiDpF,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,UAAU,CAE9D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,SAAS,CAE5D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CAEtE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,cAAc,GAAG,MAAM,CASrE"}

package/dist/core/ast/node.js

@@ -0,0 +1,70 @@
+/**
+ * The three tables below are written as a record over the kinds of each group,
+ * so a node kind added to a group without being added here does not compile.
+ * A set built from an array would accept the omission and the guard would
+ * quietly answer false for the new kind.
+ */
+const EXPRESSION_KINDS = {
+    numberLiteral: true,
+    stringLiteral: true,
+    booleanLiteral: true,
+    colorLiteral: true,
+    noneLiteral: true,
+    arrayLiteral: true,
+    nameReference: true,
+    grouping: true,
+    unary: true,
+    binary: true,
+    ternary: true,
+    call: true,
+    index: true,
+    member: true,
+    missingExpression: true,
+};
+const STATEMENT_KINDS = {
+    expressionStatement: true,
+    assignment: true,
+    varDeclaration: true,
+    ifStatement: true,
+    forRangeStatement: true,
+    forInStatement: true,
+    whileStatement: true,
+    switchStatement: true,
+    breakStatement: true,
+    continueStatement: true,
+    returnStatement: true,
+    versionLine: true,
+    scriptDeclaration: true,
+    limitsLine: true,
+};
+const TYPE_ANNOTATION_KINDS = {
+    namedType: true,
+    seriesType: true,
+    arrayType: true,
+};
+export function isExpression(node) {
+    return Object.hasOwn(EXPRESSION_KINDS, node.kind);
+}
+export function isStatement(node) {
+    return Object.hasOwn(STATEMENT_KINDS, node.kind);
+}
+export function isTypeAnnotation(node) {
+    return Object.hasOwn(TYPE_ANNOTATION_KINDS, node.kind);
+}
+/**
+ * The name a type annotation carries, for a diagnostic that has to quote it.
+ *
+ * OS2016 and OS2019 both put the annotation into their message, and the reader
+ * expects to see what was written rather than the outermost word of it.
+ */
+export function typeAnnotationText(annotation) {
+    switch (annotation.kind) {
+        case 'namedType':
+            return annotation.name;
+        case 'seriesType':
+            return `series ${typeAnnotationText(annotation.element)}`;
+        case 'arrayType':
+            return `array<${typeAnnotationText(annotation.element)}>`;
+    }
+}
+//# sourceMappingURL=node.js.map

package/dist/core/ast/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../src/core/ast/node.ts"],"names":[],"mappings":"AA6CA;;;;;GAKG;AACH,MAAM,gBAAgB,GAA+C;IACnE,aAAa,EAAE,IAAI;IACnB,aAAa,EAAE,IAAI;IACnB,cAAc,EAAE,IAAI;IACpB,YAAY,EAAE,IAAI;IAClB,WAAW,EAAE,IAAI;IACjB,YAAY,EAAE,IAAI;IAClB,aAAa,EAAE,IAAI;IACnB,QAAQ,EAAE,IAAI;IACd,KAAK,EAAE,IAAI;IACX,MAAM,EAAE,IAAI;IACZ,OAAO,EAAE,IAAI;IACb,IAAI,EAAE,IAAI;IACV,KAAK,EAAE,IAAI;IACX,MAAM,EAAE,IAAI;IACZ,iBAAiB,EAAE,IAAI;CACxB,CAAC;AAEF,MAAM,eAAe,GAA8C;IACjE,mBAAmB,EAAE,IAAI;IACzB,UAAU,EAAE,IAAI;IAChB,cAAc,EAAE,IAAI;IACpB,WAAW,EAAE,IAAI;IACjB,iBAAiB,EAAE,IAAI;IACvB,cAAc,EAAE,IAAI;IACpB,cAAc,EAAE,IAAI;IACpB,eAAe,EAAE,IAAI;IACrB,cAAc,EAAE,IAAI;IACpB,iBAAiB,EAAE,IAAI;IACvB,eAAe,EAAE,IAAI;IACrB,WAAW,EAAE,IAAI;IACjB,iBAAiB,EAAE,IAAI;IACvB,UAAU,EAAE,IAAI;CACjB,CAAC;AAEF,MAAM,qBAAqB,GAAmD;IAC5E,SAAS,EAAE,IAAI;IACf,UAAU,EAAE,IAAI;IAChB,SAAS,EAAE,IAAI;CAChB,CAAC;AAEF,MAAM,UAAU,YAAY,CAAC,IAAa;IACxC,OAAO,MAAM,CAAC,MAAM,CAAC,gBAAgB,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;AACpD,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,IAAa;IACvC,OAAO,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;AACnD,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,IAAa;IAC5C,OAAO,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;AACzD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,UAA0B;IAC3D,QAAQ,UAAU,CAAC,IAAI,EAAE,CAAC;QACxB,KAAK,WAAW;YACd,OAAO,UAAU,CAAC,IAAI,CAAC;QACzB,KAAK,YAAY;YACf,OAAO,UAAU,kBAAkB,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5D,KAAK,WAAW;YACd,OAAO,SAAS,kBAAkB,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC;IAC9D,CAAC;AACH,CAAC"}