openalgo-script 0.1.0-alpha.0

package/dist/core/diagnostics/collector.js

@@ -0,0 +1,55 @@
+import { diagnosticFor, isError } from './diagnostic.js';
+/**
+ * Gathers diagnostics instead of throwing on the first one.
+ *
+ * A trader who has three syntax errors in a file wants to see three, not one
+ * per compile. A compiler that throws makes the second error cost a whole
+ * edit-and-run cycle to discover, and it is the same file, so the cost is paid
+ * for nothing.
+ *
+ * The bag refuses an exact repeat: the same code over the same span, which is
+ * what a parser that recovers and re-enters the same construct produces. It
+ * refuses nothing else, so two different codes on one character both survive
+ * and the reader decides which one they believe.
+ */
+export class DiagnosticBag {
+    #items = [];
+    #seen = new Set();
+    report(code, span, values) {
+        this.add(diagnosticFor(code, span, values));
+    }
+    add(diagnostic) {
+        const key = `${diagnostic.code}:${diagnostic.span.offset}:${diagnostic.span.length}`;
+        if (this.#seen.has(key))
+            return;
+        this.#seen.add(key);
+        this.#items.push(diagnostic);
+    }
+    /** Everything reported, in the order it was reported. */
+    get all() {
+        return this.#items;
+    }
+    get isEmpty() {
+        return this.#items.length === 0;
+    }
+    /** Whether compilation has to stop. A file with only warnings still runs. */
+    get hasErrors() {
+        return this.#items.some(isError);
+    }
+    get errors() {
+        return this.#items.filter(isError);
+    }
+    get warnings() {
+        return this.#items.filter((item) => !isError(item));
+    }
+    /**
+     * Everything reported, in the order a reader walks the file.
+     *
+     * Stages report in the order they run, so a checker warning about line 2
+     * arrives after a parser error about line 40. A reader reads top to bottom.
+     */
+    ordered() {
+        return [...this.#items].sort((left, right) => left.span.offset - right.span.offset || left.code.localeCompare(right.code));
+    }
+}
+//# sourceMappingURL=collector.js.map

package/dist/core/diagnostics/collector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector.js","sourceRoot":"","sources":["../../../src/core/diagnostics/collector.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAkBzD;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,aAAa;IACf,MAAM,GAAiB,EAAE,CAAC;IAC1B,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;IAEnC,MAAM,CACJ,IAAU,EACV,IAAU,EACV,MAA8B;QAE9B,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9C,CAAC;IAED,GAAG,CAAC,UAAsB;QACxB,MAAM,GAAG,GAAG,GAAG,UAAU,CAAC,IAAI,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;QACrF,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAO;QAChC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC/B,CAAC;IAED,yDAAyD;IACzD,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,6EAA6E;IAC7E,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACtD,CAAC;IAED;;;;;OAKG;IACH,OAAO;QACL,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAC1B,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CACd,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAC9E,CAAC;IACJ,CAAC;CACF"}

package/dist/core/diagnostics/diagnostic.d.ts

@@ -0,0 +1,40 @@
+import type { DiagnosticCode, DiagnosticValues, PlaceholderValue, Severity, Stage } from '../catalogue/index.js';
+import type { Span } from '../span/index.js';
+/**
+ * One thing the compiler has to say about one place in a file.
+ *
+ * The code and the span come from the stage that raised it. Everything else
+ * comes from the catalogue, filled with the values the stage supplied, so no
+ * stage anywhere writes a sentence a reader sees.
+ */
+export interface Diagnostic {
+    readonly code: DiagnosticCode;
+    readonly severity: Severity;
+    readonly stage: Stage;
+    readonly title: string;
+    /** The catalogue message with its slots filled. */
+    readonly message: string;
+    /** The catalogue fix with its slots filled. What to do, in the imperative. */
+    readonly fix: string;
+    /** Whether an editor may apply the fix without asking a question. */
+    readonly autofix: boolean;
+    readonly span: Span;
+    /**
+     * The values that filled the slots, kept rather than discarded.
+     *
+     * An editor building a quick fix needs the name that went into the message,
+     * not the sentence it was put into, and a host rendering a diagnostic in
+     * another language needs every value the template consumed.
+     */
+    readonly values: Readonly<Record<string, PlaceholderValue>>;
+}
+/**
+ * Builds a diagnostic.
+ *
+ * The values argument is typed per code, so a call site that forgets a slot or
+ * misspells one fails to compile. That is the only guard that runs before a
+ * trader sees the message, which is why the placeholders are generated as types.
+ */
+export declare function diagnosticFor<Code extends DiagnosticCode>(code: Code, span: Span, values: DiagnosticValues[Code]): Diagnostic;
+export declare function isError(diagnostic: Diagnostic): boolean;
+//# sourceMappingURL=diagnostic.d.ts.map

package/dist/core/diagnostics/diagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic.d.ts","sourceRoot":"","sources":["../../../src/core/diagnostics/diagnostic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EACR,KAAK,EACN,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7C;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,8EAA8E;IAC9E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;CAC7D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,SAAS,cAAc,EACvD,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,gBAAgB,CAAC,IAAI,CAAC,GAC7B,UAAU,CAiBZ;AAED,wBAAgB,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAEvD"}

package/dist/core/diagnostics/diagnostic.js

@@ -0,0 +1,29 @@
+import { entryFor, fillTemplate } from '../catalogue/index.js';
+/**
+ * Builds a diagnostic.
+ *
+ * The values argument is typed per code, so a call site that forgets a slot or
+ * misspells one fails to compile. That is the only guard that runs before a
+ * trader sees the message, which is why the placeholders are generated as types.
+ */
+export function diagnosticFor(code, span, values) {
+    const entry = entryFor(code);
+    // DiagnosticValues is generated with every property typed PlaceholderValue,
+    // so this widening loses the per-code shape and nothing else.
+    const supplied = values;
+    return {
+        code,
+        severity: entry.severity,
+        stage: entry.stage,
+        title: entry.title,
+        message: fillTemplate(entry.message, supplied),
+        fix: fillTemplate(entry.fix, supplied),
+        autofix: entry.autofix,
+        span,
+        values: supplied,
+    };
+}
+export function isError(diagnostic) {
+    return diagnostic.severity === 'error';
+}
+//# sourceMappingURL=diagnostic.js.map

package/dist/core/diagnostics/diagnostic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic.js","sourceRoot":"","sources":["../../../src/core/diagnostics/diagnostic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAuC/D;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAC3B,IAAU,EACV,IAAU,EACV,MAA8B;IAE9B,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC7B,4EAA4E;IAC5E,8DAA8D;IAC9D,MAAM,QAAQ,GAAG,MAA+D,CAAC;IAEjF,OAAO;QACL,IAAI;QACJ,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC;QAC9C,GAAG,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,EAAE,QAAQ,CAAC;QACtC,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,IAAI;QACJ,MAAM,EAAE,QAAQ;KACjB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,UAAsB;IAC5C,OAAO,UAAU,CAAC,QAAQ,KAAK,OAAO,CAAC;AACzC,CAAC"}

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

@@ -0,0 +1,12 @@
+/**
+ * What the compiler has to say, and where it is put while it says it.
+ *
+ * Nothing here decides how a diagnostic looks on a screen. That is the render
+ * module, because a terminal, an editor gutter and a chart all want a different
+ * shape from the same diagnostic.
+ */
+export type { Diagnostic } from './diagnostic.js';
+export { diagnosticFor, isError } from './diagnostic.js';
+export type { DiagnosticSink } from './collector.js';
+export { DiagnosticBag } from './collector.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/diagnostics/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAEzD,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/core/diagnostics/index.js

@@ -0,0 +1,3 @@
+export { diagnosticFor, isError } from './diagnostic.js';
+export { DiagnosticBag } from './collector.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/diagnostics/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAGzD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/core/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * OpenScript, the compiler tier.
+ *
+ * This is the whole of what a host needs to turn a script into a compiled
+ * program, and it knows nothing about a chart, an editor or a broker. It
+ * imports no package and touches no browser global, so the same file runs in a
+ * worker, on a server and inside somebody else's application under a content
+ * security policy that forbids turning text into code.
+ *
+ * The tiers above it are separate entry points, so a host that wants only this
+ * one never loads the editor intelligence or an adapter.
+ */
+export type { Positioned, Span } from './span/index.js';
+export { containsOffset, endOffset, makeSpan, spanning } from './span/index.js';
+export type { SourceFile, SourcePosition } from './source/index.js';
+export { normaliseSource, sourceFile } from './source/index.js';
+export type { CatalogueEntry, DiagnosticCode, DiagnosticValues, PlaceholderValue, Severity, Stage, } from './catalogue/index.js';
+export { CATALOGUE_LANGUAGE_VERSION, CATALOGUE_SCHEMA_VERSION, STAGE_LABELS, allCodes, entryFor, fillTemplate, isDiagnosticCode, } from './catalogue/index.js';
+export type { Diagnostic, DiagnosticSink } from './diagnostics/index.js';
+export { DiagnosticBag, diagnosticFor, isError } from './diagnostics/index.js';
+export { renderDiagnostic, renderDiagnostics } from './render/index.js';
+export type { KeywordKind, LayoutKind, LiteralKind, NameKind, NumberToken, PunctuationKind, SimpleToken, StringToken, Token, TokenKind, } from './tokens/index.js';
+export { PUNCTUATORS, RESERVED_WORDS } from './tokens/index.js';
+export type { Argument, ArithmeticOperator, ArrayLiteral, ArrayType, Assignment, AssignmentOperator, AstNode, Binary, BinaryOperator, Block, BooleanLiteral, BreakStatement, Call, ColorLiteral, ComparisonOperator, ContinueStatement, ElseBranch, EqualityOperator, Expression, ExpressionStatement, ForInStatement, ForRangeStatement, FunctionDeclaration, Grouping, IfBranch, IfStatement, Index, LimitsLine, LogicalOperator, Member, MissingExpression, Name, NameReference, NamedType, NodeFields, NodeKind, NodeOfKind, NoneLiteral, NumberLiteral, ObjectTypeName, Parameter, ReturnStatement, Script, ScriptDeclaration, SeriesType, Statement, StringLiteral, SwitchCase, SwitchDefault, SwitchStatement, Ternary, TopLevelItem, TypeAnnotation, Unary, UnaryOperator, ValueTypeName, VarDeclaration, VersionLine, Visit, Visitor, WhileStatement, } from './ast/index.js';
+export { ARITHMETIC_OPERATORS, ASSIGNMENT_OPERATORS, COMPARISON_OPERATORS, EQUALITY_OPERATORS, LOGICAL_OPERATORS, OBJECT_TYPE_NAMES, UNARY_OPERATORS, VALUE_TYPE_NAMES, binaryPrecedence, childrenOf, isExpression, isObjectTypeName, isStatement, isTypeAnnotation, isValueTypeName, makeNode, nodeAtOffset, pathAtOffset, typeAnnotationText, walk, withoutGrouping, } from './ast/index.js';
+export { lex } from './lex/index.js';
+export { parse, parseTokens } from './parse/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,YAAY,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhF,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEhE,YAAY,EACV,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EACR,KAAK,GACN,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,0BAA0B,EAC1B,wBAAwB,EACxB,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAE/E,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAExE,YAAY,EACV,WAAW,EACX,UAAU,EACV,WAAW,EACX,QAAQ,EACR,WAAW,EACX,eAAe,EACf,WAAW,EACX,WAAW,EACX,KAAK,EACL,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEhE,YAAY,EACV,QAAQ,EACR,kBAAkB,EAClB,YAAY,EACZ,SAAS,EACT,UAAU,EACV,kBAAkB,EAClB,OAAO,EACP,MAAM,EACN,cAAc,EACd,KAAK,EACL,cAAc,EACd,cAAc,EACd,IAAI,EACJ,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,UAAU,EACV,gBAAgB,EAChB,UAAU,EACV,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,KAAK,EACL,UAAU,EACV,eAAe,EACf,MAAM,EACN,iBAAiB,EACjB,IAAI,EACJ,aAAa,EACb,SAAS,EACT,UAAU,EACV,QAAQ,EACR,UAAU,EACV,WAAW,EACX,aAAa,EACb,cAAc,EACd,SAAS,EACT,eAAe,EACf,MAAM,EACN,iBAAiB,EACjB,UAAU,EACV,SAAS,EACT,aAAa,EACb,UAAU,EACV,aAAa,EACb,eAAe,EACf,OAAO,EACP,YAAY,EACZ,cAAc,EACd,KAAK,EACL,aAAa,EACb,aAAa,EACb,cAAc,EACd,WAAW,EACX,KAAK,EACL,OAAO,EACP,cAAc,GACf,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,EACV,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,eAAe,EACf,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,IAAI,EACJ,eAAe,GAChB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,22 @@
+/**
+ * OpenScript, the compiler tier.
+ *
+ * This is the whole of what a host needs to turn a script into a compiled
+ * program, and it knows nothing about a chart, an editor or a broker. It
+ * imports no package and touches no browser global, so the same file runs in a
+ * worker, on a server and inside somebody else's application under a content
+ * security policy that forbids turning text into code.
+ *
+ * The tiers above it are separate entry points, so a host that wants only this
+ * one never loads the editor intelligence or an adapter.
+ */
+export { containsOffset, endOffset, makeSpan, spanning } from './span/index.js';
+export { normaliseSource, sourceFile } from './source/index.js';
+export { CATALOGUE_LANGUAGE_VERSION, CATALOGUE_SCHEMA_VERSION, STAGE_LABELS, allCodes, entryFor, fillTemplate, isDiagnosticCode, } from './catalogue/index.js';
+export { DiagnosticBag, diagnosticFor, isError } from './diagnostics/index.js';
+export { renderDiagnostic, renderDiagnostics } from './render/index.js';
+export { PUNCTUATORS, RESERVED_WORDS } from './tokens/index.js';
+export { ARITHMETIC_OPERATORS, ASSIGNMENT_OPERATORS, COMPARISON_OPERATORS, EQUALITY_OPERATORS, LOGICAL_OPERATORS, OBJECT_TYPE_NAMES, UNARY_OPERATORS, VALUE_TYPE_NAMES, binaryPrecedence, childrenOf, isExpression, isObjectTypeName, isStatement, isTypeAnnotation, isValueTypeName, makeNode, nodeAtOffset, pathAtOffset, typeAnnotationText, walk, withoutGrouping, } from './ast/index.js';
+export { lex } from './lex/index.js';
+export { parse, parseTokens } from './parse/index.js';
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAGhF,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAUhE,OAAO,EACL,0BAA0B,EAC1B,wBAAwB,EACxB,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAE/E,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAcxE,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAiEhE,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,EACV,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,eAAe,EACf,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,IAAI,EACJ,eAAe,GAChB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/core/lex/blocks.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The block structure of language.md 3.10, which is a stack of indentation
+ * widths and nothing more.
+ *
+ * Only a line that carries a token ever reaches this. A blank line and a
+ * comment-only line carry no indentation at all: they never open a block, never
+ * end one and are never OS1003, and the rule is kept by never asking about
+ * them rather than by asking and forgiving.
+ */
+/** What a line's indentation means for the blocks around it. */
+export type IndentEvent = 
+/** Another line of the block already open. */
+{
+    readonly kind: 'same';
+}
+/** Deeper than the header above it: a block begins. */
+ | {
+    readonly kind: 'open';
+}
+/** Shallower: this many blocks end here. */
+ | {
+    readonly kind: 'close';
+    readonly count: number;
+}
+/**
+ * Indented to a width no open block has, which is OS1003. The line is kept in
+ * the block it landed in, so that one lost space reports one error rather
+ * than reshaping every block below it.
+ */
+ | {
+    readonly kind: 'mismatch';
+    readonly count: number;
+    readonly expected: number;
+    readonly openerLine: number;
+};
+export declare class BlockStack {
+    #private;
+    get depth(): number;
+    /**
+     * Takes the next line's indentation.
+     *
+     * `afterHeader` is whether the statement above this line was one that opens a
+     * block. Without it a line that drifted one space to the right would open a
+     * block of its own and every sibling below it would be reported instead of
+     * the one line that moved.
+     */
+    enter(width: number, afterHeader: boolean, openerLine: number): IndentEvent;
+    /** Every block still open, which the end of the file closes. */
+    closeAll(): number;
+}
+//# sourceMappingURL=blocks.d.ts.map

package/dist/core/lex/blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.d.ts","sourceRoot":"","sources":["../../../src/core/lex/blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAYH,gEAAgE;AAChE,MAAM,MAAM,WAAW;AACrB,8CAA8C;AAC5C;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAC3B,uDAAuD;GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAC3B,4CAA4C;GAC1C;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AACpD;;;;GAIG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEN,qBAAa,UAAU;;IAKrB,IAAI,KAAK,IAAI,MAAM,CAElB;IAMD;;;;;;;OAOG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,WAAW;IAwB3E,gEAAgE;IAChE,QAAQ,IAAI,MAAM;CAKnB"}

package/dist/core/lex/blocks.js

@@ -0,0 +1,56 @@
+/**
+ * The block structure of language.md 3.10, which is a stack of indentation
+ * widths and nothing more.
+ *
+ * Only a line that carries a token ever reaches this. A blank line and a
+ * comment-only line carry no indentation at all: they never open a block, never
+ * end one and are never OS1003, and the rule is kept by never asking about
+ * them rather than by asking and forgiving.
+ */
+export class BlockStack {
+    // The file's own top level, which no header opened. Line 1 is the honest
+    // answer to where it began.
+    #levels = [{ width: 0, openerLine: 1 }];
+    get depth() {
+        return this.#levels.length - 1;
+    }
+    #top() {
+        return this.#levels[this.#levels.length - 1] ?? { width: 0, openerLine: 1 };
+    }
+    /**
+     * Takes the next line's indentation.
+     *
+     * `afterHeader` is whether the statement above this line was one that opens a
+     * block. Without it a line that drifted one space to the right would open a
+     * block of its own and every sibling below it would be reported instead of
+     * the one line that moved.
+     */
+    enter(width, afterHeader, openerLine) {
+        const top = this.#top();
+        if (width > top.width) {
+            if (!afterHeader) {
+                return { kind: 'mismatch', count: 0, expected: top.width, openerLine: top.openerLine };
+            }
+            this.#levels.push({ width, openerLine });
+            return { kind: 'open' };
+        }
+        if (width === top.width)
+            return { kind: 'same' };
+        let count = 0;
+        while (this.#levels.length > 1 && width < this.#top().width) {
+            this.#levels.pop();
+            count++;
+        }
+        const landed = this.#top();
+        if (width === landed.width)
+            return { kind: 'close', count };
+        return { kind: 'mismatch', count, expected: landed.width, openerLine: landed.openerLine };
+    }
+    /** Every block still open, which the end of the file closes. */
+    closeAll() {
+        const count = this.#levels.length - 1;
+        this.#levels.length = 1;
+        return count;
+    }
+}
+//# sourceMappingURL=blocks.js.map

package/dist/core/lex/blocks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.js","sourceRoot":"","sources":["../../../src/core/lex/blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAgCH,MAAM,OAAO,UAAU;IACrB,yEAAyE;IACzE,4BAA4B;IACnB,OAAO,GAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC,CAAC;IAE1D,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;IACjC,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC;IAC9E,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,KAAa,EAAE,WAAoB,EAAE,UAAkB;QAC3D,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAExB,IAAI,KAAK,GAAG,GAAG,CAAC,KAAK,EAAE,CAAC;YACtB,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC;YACzF,CAAC;YACD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;YACzC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAC1B,CAAC;QAED,IAAI,KAAK,KAAK,GAAG,CAAC,KAAK;YAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAEjD,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC;YAC5D,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;YACnB,KAAK,EAAE,CAAC;QACV,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAC3B,IAAI,KAAK,KAAK,MAAM,CAAC,KAAK;YAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;QAC5D,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC;IAC5F,CAAC;IAED,gEAAgE;IAChE,QAAQ;QACN,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QACtC,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QACxB,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

package/dist/core/lex/characters.d.ts

@@ -0,0 +1,38 @@
+/**
+ * What a character is, in the alphabet language.md 3.1 allows outside a string
+ * literal: ASCII letters, ASCII digits, space, newline and the punctuation of
+ * 3.12. Anything else is OS1001, so a classifier that answered questions about
+ * a wider alphabet would be answering a question the language never asks.
+ *
+ * Every predicate takes a code unit rather than a string. The scanner asks
+ * about each character of the file in turn, and a one character string per
+ * question is an allocation per character of every compile.
+ */
+export declare const LINE_FEED = 10;
+export declare const SPACE = 32;
+export declare const TAB = 9;
+export declare const QUOTE = 34;
+export declare const APOSTROPHE = 39;
+export declare const HASH = 35;
+export declare const DOT = 46;
+export declare const SLASH = 47;
+export declare const ASTERISK = 42;
+export declare const BACKSLASH = 92;
+export declare const SEMICOLON = 59;
+export declare const UNDERSCORE = 95;
+export declare function isDigit(code: number): boolean;
+export declare function isHexDigit(code: number): boolean;
+export declare function isAsciiLetter(code: number): boolean;
+/** An identifier begins with an ASCII letter or an underscore (3.3). */
+export declare function isNameStart(code: number): boolean;
+export declare function isNamePart(code: number): boolean;
+/**
+ * Horizontal whitespace.
+ *
+ * A tab is included although the language accepts none: it is recognised here
+ * so that it can be reported where it sits, as OS1002 in leading whitespace and
+ * as OS1001 anywhere else, rather than ending a token and confusing the next
+ * one.
+ */
+export declare function isBlank(code: number): boolean;
+//# sourceMappingURL=characters.d.ts.map

package/dist/core/lex/characters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"characters.d.ts","sourceRoot":"","sources":["../../../src/core/lex/characters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,eAAO,MAAM,SAAS,KAAO,CAAC;AAC9B,eAAO,MAAM,KAAK,KAAO,CAAC;AAC1B,eAAO,MAAM,GAAG,IAAO,CAAC;AACxB,eAAO,MAAM,KAAK,KAAO,CAAC;AAC1B,eAAO,MAAM,UAAU,KAAO,CAAC;AAC/B,eAAO,MAAM,IAAI,KAAO,CAAC;AACzB,eAAO,MAAM,GAAG,KAAO,CAAC;AACxB,eAAO,MAAM,KAAK,KAAO,CAAC;AAC1B,eAAO,MAAM,QAAQ,KAAO,CAAC;AAC7B,eAAO,MAAM,SAAS,KAAO,CAAC;AAC9B,eAAO,MAAM,SAAS,KAAO,CAAC;AAC9B,eAAO,MAAM,UAAU,KAAO,CAAC;AAE/B,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wEAAwE;AACxE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7C"}

package/dist/core/lex/characters.js

@@ -0,0 +1,50 @@
+/**
+ * What a character is, in the alphabet language.md 3.1 allows outside a string
+ * literal: ASCII letters, ASCII digits, space, newline and the punctuation of
+ * 3.12. Anything else is OS1001, so a classifier that answered questions about
+ * a wider alphabet would be answering a question the language never asks.
+ *
+ * Every predicate takes a code unit rather than a string. The scanner asks
+ * about each character of the file in turn, and a one character string per
+ * question is an allocation per character of every compile.
+ */
+export const LINE_FEED = 0x0a;
+export const SPACE = 0x20;
+export const TAB = 0x09;
+export const QUOTE = 0x22;
+export const APOSTROPHE = 0x27;
+export const HASH = 0x23;
+export const DOT = 0x2e;
+export const SLASH = 0x2f;
+export const ASTERISK = 0x2a;
+export const BACKSLASH = 0x5c;
+export const SEMICOLON = 0x3b;
+export const UNDERSCORE = 0x5f;
+export function isDigit(code) {
+    return code >= 0x30 && code <= 0x39;
+}
+export function isHexDigit(code) {
+    return isDigit(code) || (code >= 0x41 && code <= 0x46) || (code >= 0x61 && code <= 0x66);
+}
+export function isAsciiLetter(code) {
+    return (code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a);
+}
+/** An identifier begins with an ASCII letter or an underscore (3.3). */
+export function isNameStart(code) {
+    return isAsciiLetter(code) || code === UNDERSCORE;
+}
+export function isNamePart(code) {
+    return isNameStart(code) || isDigit(code);
+}
+/**
+ * Horizontal whitespace.
+ *
+ * A tab is included although the language accepts none: it is recognised here
+ * so that it can be reported where it sits, as OS1002 in leading whitespace and
+ * as OS1001 anywhere else, rather than ending a token and confusing the next
+ * one.
+ */
+export function isBlank(code) {
+    return code === SPACE || code === TAB;
+}
+//# sourceMappingURL=characters.js.map

package/dist/core/lex/characters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"characters.js","sourceRoot":"","sources":["../../../src/core/lex/characters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,CAAC;AAC9B,MAAM,CAAC,MAAM,KAAK,GAAG,IAAI,CAAC;AAC1B,MAAM,CAAC,MAAM,GAAG,GAAG,IAAI,CAAC;AACxB,MAAM,CAAC,MAAM,KAAK,GAAG,IAAI,CAAC;AAC1B,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,CAAC;AAC/B,MAAM,CAAC,MAAM,IAAI,GAAG,IAAI,CAAC;AACzB,MAAM,CAAC,MAAM,GAAG,GAAG,IAAI,CAAC;AACxB,MAAM,CAAC,MAAM,KAAK,GAAG,IAAI,CAAC;AAC1B,MAAM,CAAC,MAAM,QAAQ,GAAG,IAAI,CAAC;AAC7B,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,CAAC;AAC9B,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,CAAC;AAC9B,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,CAAC;AAE/B,MAAM,UAAU,OAAO,CAAC,IAAY;IAClC,OAAO,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,CAAC;AAC3F,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,CAAC;AAC1E,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,UAAU,CAAC;AACpD,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,OAAO,WAAW,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,OAAO,CAAC,IAAY;IAClC,OAAO,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,GAAG,CAAC;AACxC,CAAC"}

package/dist/core/lex/comments.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The block comment markers of other languages, which this one does not have
+ * (3.2).
+ *
+ * They are recognised here so that the region a writer meant as a comment can
+ * be skipped and reported once, at the marker that opened it. Read as tokens
+ * instead, the opener is a divide against a multiply and the prose between the
+ * markers is a statement, so a reader is handed several diagnostics that are
+ * each true of a program they never wrote and none of which mentions the
+ * comment. That is OS1026's whole reason for existing.
+ */
+/** Whether the two characters at `at` open a region: a slash then a star. */
+export declare function opensComment(text: string, at: number): boolean;
+/**
+ * Whether the two characters at `at` close one: a star then a slash.
+ *
+ * A star written against the line comment form is a multiply and a comment,
+ * never a closer, because the comment form the language does have wins.
+ * Without that, a legal line whose multiply touches the comment after it would
+ * be read as a marker and reported, and a diagnostic on a correct program is
+ * the one mistake a lexer may never make.
+ */
+export declare function closesComment(text: string, at: number): boolean;
+/** What is left of a region after the line it was found on. */
+export interface CommentRegion {
+    /** Where reading goes on: one past the closer, or the end of the line. */
+    readonly end: number;
+    /** Whether the region is still open, so the lines below belong to it too. */
+    readonly open: boolean;
+}
+/**
+ * Reads from `from` to the closer, stopping at the end of the line.
+ *
+ * The scan is per line because the lexer works in lines, and because a region
+ * that stays open has to be the caller's decision rather than this one's: a
+ * closer on the line it opened on costs the reader nothing else, and a missing
+ * one costs them the lines below.
+ */
+export declare function commentRegion(text: string, from: number): CommentRegion;
+/**
+ * Whether a closer is written anywhere from `from` on.
+ *
+ * An opener whose closer was never written is not a region at all: it costs the
+ * reader the line it sits on and nothing below it. Reading the rest of the file
+ * as a comment would be the silent swallow that language.md 3.2 gives as the
+ * reason the form does not exist, and one marker may not cost a reader every
+ * other mistake in their file.
+ */
+export declare function hasCloser(text: string, from: number): boolean;
+//# sourceMappingURL=comments.d.ts.map

package/dist/core/lex/comments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comments.d.ts","sourceRoot":"","sources":["../../../src/core/lex/comments.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAM/D;AAED,+DAA+D;AAC/D,MAAM,WAAW,aAAa;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAMvE;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAK7D"}

package/dist/core/lex/comments.js

@@ -0,0 +1,64 @@
+import { ASTERISK, LINE_FEED, SLASH } from './characters.js';
+/**
+ * The block comment markers of other languages, which this one does not have
+ * (3.2).
+ *
+ * They are recognised here so that the region a writer meant as a comment can
+ * be skipped and reported once, at the marker that opened it. Read as tokens
+ * instead, the opener is a divide against a multiply and the prose between the
+ * markers is a statement, so a reader is handed several diagnostics that are
+ * each true of a program they never wrote and none of which mentions the
+ * comment. That is OS1026's whole reason for existing.
+ */
+/** Whether the two characters at `at` open a region: a slash then a star. */
+export function opensComment(text, at) {
+    return text.charCodeAt(at) === SLASH && text.charCodeAt(at + 1) === ASTERISK;
+}
+/**
+ * Whether the two characters at `at` close one: a star then a slash.
+ *
+ * A star written against the line comment form is a multiply and a comment,
+ * never a closer, because the comment form the language does have wins.
+ * Without that, a legal line whose multiply touches the comment after it would
+ * be read as a marker and reported, and a diagnostic on a correct program is
+ * the one mistake a lexer may never make.
+ */
+export function closesComment(text, at) {
+    return (text.charCodeAt(at) === ASTERISK &&
+        text.charCodeAt(at + 1) === SLASH &&
+        text.charCodeAt(at + 2) !== SLASH);
+}
+/**
+ * Reads from `from` to the closer, stopping at the end of the line.
+ *
+ * The scan is per line because the lexer works in lines, and because a region
+ * that stays open has to be the caller's decision rather than this one's: a
+ * closer on the line it opened on costs the reader nothing else, and a missing
+ * one costs them the lines below.
+ */
+export function commentRegion(text, from) {
+    for (let i = from; i < text.length; i++) {
+        if (text.charCodeAt(i) === LINE_FEED)
+            return { end: i, open: true };
+        if (closesComment(text, i))
+            return { end: i + 2, open: false };
+    }
+    return { end: text.length, open: true };
+}
+/**
+ * Whether a closer is written anywhere from `from` on.
+ *
+ * An opener whose closer was never written is not a region at all: it costs the
+ * reader the line it sits on and nothing below it. Reading the rest of the file
+ * as a comment would be the silent swallow that language.md 3.2 gives as the
+ * reason the form does not exist, and one marker may not cost a reader every
+ * other mistake in their file.
+ */
+export function hasCloser(text, from) {
+    for (let i = from; i < text.length; i++) {
+        if (closesComment(text, i))
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=comments.js.map

package/dist/core/lex/comments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"comments.js","sourceRoot":"","sources":["../../../src/core/lex/comments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7D;;;;;;;;;;GAUG;AAEH,6EAA6E;AAC7E,MAAM,UAAU,YAAY,CAAC,IAAY,EAAE,EAAU;IACnD,OAAO,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,KAAK,IAAI,IAAI,CAAC,UAAU,CAAC,EAAE,GAAG,CAAC,CAAC,KAAK,QAAQ,CAAC;AAC/E,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,EAAU;IACpD,OAAO,CACL,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,QAAQ;QAChC,IAAI,CAAC,UAAU,CAAC,EAAE,GAAG,CAAC,CAAC,KAAK,KAAK;QACjC,IAAI,CAAC,UAAU,CAAC,EAAE,GAAG,CAAC,CAAC,KAAK,KAAK,CAClC,CAAC;AACJ,CAAC;AAUD;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,IAAY;IACtD,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,SAAS;YAAE,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QACpE,IAAI,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC;YAAE,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IACjE,CAAC;IACD,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AAC1C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY,EAAE,IAAY;IAClD,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,IAAI,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC;IAC1C,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

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

@@ -0,0 +1,12 @@
+/**
+ * The lexer: source text to tokens, and a diagnostic for anything it cannot
+ * read.
+ *
+ * The whole of language.md section 3 lives behind this door. What comes out is
+ * a flat list of tokens with the layout already decided, so nothing downstream
+ * counts a space or wonders whether a line was blank: a newline token ends a
+ * statement, an indent and a dedent bracket a block, and a line that carried no
+ * token is simply not in the list.
+ */
+export { lex } from './lexer.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/lex/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC"}

package/dist/core/lex/index.js

@@ -0,0 +1,12 @@
+/**
+ * The lexer: source text to tokens, and a diagnostic for anything it cannot
+ * read.
+ *
+ * The whole of language.md section 3 lives behind this door. What comes out is
+ * a flat list of tokens with the layout already decided, so nothing downstream
+ * counts a space or wonders whether a line was blank: a newline token ends a
+ * statement, an indent and a dedent bracket a block, and a line that carried no
+ * token is simply not in the list.
+ */
+export { lex } from './lexer.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/lex/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC"}