openalgo-script 0.1.0-alpha.0

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

@@ -0,0 +1,22 @@
+/**
+ * A number literal, in every form of language.md 3.5: decimal with or without a
+ * fractional part, a fractional part with no leading digit, an exponent, digit
+ * group underscores and the hexadecimal form. There is no octal form, so `010`
+ * is ten, which falls out of reading the digits rather than being a special
+ * case.
+ */
+export interface NumberLiteral {
+    /** One past the last character of the literal. */
+    readonly end: number;
+    readonly value: number;
+}
+/**
+ * Reads the literal starting at `start`, which the caller has established
+ * begins a number: a digit, or a dot with a digit after it.
+ *
+ * The value is computed here and carried on the token so that no later stage
+ * re-reads the text and has to agree a second time about underscores and about
+ * the hexadecimal form.
+ */
+export declare function scanNumber(text: string, start: number): NumberLiteral;
+//# sourceMappingURL=numbers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.d.ts","sourceRoot":"","sources":["../../../src/core/lex/numbers.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,kDAAkD;IAClD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAwBD;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,CA+BrE"}

package/dist/core/lex/numbers.js

@@ -0,0 +1,58 @@
+import { DOT, isDigit, isHexDigit, UNDERSCORE } from './characters.js';
+/**
+ * An underscore separates digit groups, so it only belongs to the literal when
+ * a digit follows it. `1_` and `1__0` therefore end the literal at the first
+ * underscore, and the caller reports what follows as a name that starts with a
+ * digit, which is what they are.
+ */
+function runOfDigits(text, from, digit) {
+    let i = from;
+    for (;;) {
+        const code = text.charCodeAt(i);
+        if (digit(code)) {
+            i++;
+            continue;
+        }
+        if (code === UNDERSCORE && digit(text.charCodeAt(i + 1))) {
+            i += 2;
+            continue;
+        }
+        return i;
+    }
+}
+/**
+ * Reads the literal starting at `start`, which the caller has established
+ * begins a number: a digit, or a dot with a digit after it.
+ *
+ * The value is computed here and carried on the token so that no later stage
+ * re-reads the text and has to agree a second time about underscores and about
+ * the hexadecimal form.
+ */
+export function scanNumber(text, start) {
+    const second = text.charCodeAt(start + 1);
+    const isHex = text.charCodeAt(start) === 0x30 &&
+        (second === 0x78 || second === 0x58) &&
+        isHexDigit(text.charCodeAt(start + 2));
+    if (isHex) {
+        const end = runOfDigits(text, start + 2, isHexDigit);
+        return { end, value: Number(text.slice(start, end).replace(/_/g, '')) };
+    }
+    let i = runOfDigits(text, start, isDigit);
+    // A dot only belongs to the literal when a digit follows it, so `x.y` reads as
+    // an element access and `1.` reads as a number and a dot.
+    if (text.charCodeAt(i) === DOT && isDigit(text.charCodeAt(i + 1))) {
+        i = runOfDigits(text, i + 1, isDigit);
+    }
+    const exponent = text.charCodeAt(i);
+    if (exponent === 0x65 || exponent === 0x45) {
+        const sign = text.charCodeAt(i + 1);
+        const digits = sign === 0x2b || sign === 0x2d ? i + 2 : i + 1;
+        // Without a digit the `e` is not an exponent, and the caller reports the
+        // letter sitting against a number rather than this reading a literal that
+        // is not there.
+        if (isDigit(text.charCodeAt(digits)))
+            i = runOfDigits(text, digits, isDigit);
+    }
+    return { end: i, value: Number(text.slice(start, i).replace(/_/g, '')) };
+}
+//# sourceMappingURL=numbers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.js","sourceRoot":"","sources":["../../../src/core/lex/numbers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAevE;;;;;GAKG;AACH,SAAS,WAAW,CAAC,IAAY,EAAE,IAAY,EAAE,KAAgC;IAC/E,IAAI,CAAC,GAAG,IAAI,CAAC;IACb,SAAS,CAAC;QACR,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAChC,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YAChB,CAAC,EAAE,CAAC;YACJ,SAAS;QACX,CAAC;QACD,IAAI,IAAI,KAAK,UAAU,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YACzD,CAAC,IAAI,CAAC,CAAC;YACP,SAAS;QACX,CAAC;QACD,OAAO,CAAC,CAAC;IACX,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,KAAa;IACpD,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;IAC1C,MAAM,KAAK,GACT,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,IAAI;QAC/B,CAAC,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI,CAAC;QACpC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;IAEzC,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,GAAG,GAAG,WAAW,CAAC,IAAI,EAAE,KAAK,GAAG,CAAC,EAAE,UAAU,CAAC,CAAC;QACrD,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC;IAC1E,CAAC;IAED,IAAI,CAAC,GAAG,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IAE1C,+EAA+E;IAC/E,0DAA0D;IAC1D,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QAClE,CAAC,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;IACxC,CAAC;IAED,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IACpC,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACpC,MAAM,MAAM,GAAG,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC9D,yEAAyE;QACzE,0EAA0E;QAC1E,gBAAgB;QAChB,IAAI,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAAE,CAAC,GAAG,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/E,CAAC;IAED,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC;AAC3E,CAAC"}

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

@@ -0,0 +1,24 @@
+import type { Token, TokenKind } from '../tokens/index.js';
+/**
+ * Whether the last two tokens are the `=>` of a function declaration.
+ *
+ * Section 3.12 does not list `=>` among the punctuation, so it arrives as an
+ * `=` and a `>` that touch. Both readings need saying apart here: a line whose
+ * last token is `>` continues onto the next line, and a line that ends in `=>`
+ * is a function header whose body is the indented block below it, so it must
+ * not.
+ */
+export declare function endsWithArrow(tokens: readonly Token[]): boolean;
+/** Whether the statement so far promises more, so the next line belongs to it. */
+export declare function continuesLine(tokens: readonly Token[]): boolean;
+/**
+ * Whether a statement that begins with this token and ends this way opens a
+ * block.
+ *
+ * `fn` is the one header with a form that fits on one line: with its body after
+ * the `=>` it opens nothing, and with nothing after the `=>` the block below it
+ * is the body (3.10, 11.1). Every other header opens a block always, because
+ * there is no statement separator to end a one-line body with.
+ */
+export declare function opensBlock(firstKind: TokenKind, arrowAtEnd: boolean): boolean;
+//# sourceMappingURL=statements.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../../src/core/lex/statements.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAqD3D;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,OAAO,CAS/D;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,OAAO,CAK/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAG7E"}

package/dist/core/lex/statements.js

@@ -0,0 +1,90 @@
+/**
+ * Where a statement ends, and whether it opens a block. Both questions are
+ * asked of the tokens of a line, which is the whole of what language.md 3.10
+ * and 3.11 need to know about a statement before it is parsed.
+ */
+/**
+ * The tokens that promise a right-hand side, from 3.11: a binary operator, a
+ * comma, a `?`, a `:` or an `=`. A line ending in one of them continues onto
+ * the next line.
+ *
+ * The compound assignments are here on the same terms as `=`: each one promises
+ * a value just as plainly. `.` is deliberately absent, because 3.11 does not
+ * list it and a line that ends in a dot is a mistake rather than a wrap.
+ */
+const CONTINUING = new Set([
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '==',
+    '!=',
+    '<',
+    '<=',
+    '>',
+    '>=',
+    '=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    ',',
+    '?',
+    ':',
+    'and',
+    'or',
+]);
+/** The words that introduce a block, per 3.10 and the grammar of section 19. */
+const HEADERS = new Set([
+    'if',
+    'else',
+    'for',
+    'while',
+    'switch',
+    'case',
+    'default',
+]);
+/**
+ * Whether the last two tokens are the `=>` of a function declaration.
+ *
+ * Section 3.12 does not list `=>` among the punctuation, so it arrives as an
+ * `=` and a `>` that touch. Both readings need saying apart here: a line whose
+ * last token is `>` continues onto the next line, and a line that ends in `=>`
+ * is a function header whose body is the indented block below it, so it must
+ * not.
+ */
+export function endsWithArrow(tokens) {
+    const last = tokens[tokens.length - 1];
+    const before = tokens[tokens.length - 2];
+    if (last === undefined || before === undefined)
+        return false;
+    return (last.kind === '>' &&
+        before.kind === '=' &&
+        before.span.offset + before.span.length === last.span.offset);
+}
+/** Whether the statement so far promises more, so the next line belongs to it. */
+export function continuesLine(tokens) {
+    const last = tokens[tokens.length - 1];
+    if (last === undefined)
+        return false;
+    if (endsWithArrow(tokens))
+        return false;
+    return CONTINUING.has(last.kind);
+}
+/**
+ * Whether a statement that begins with this token and ends this way opens a
+ * block.
+ *
+ * `fn` is the one header with a form that fits on one line: with its body after
+ * the `=>` it opens nothing, and with nothing after the `=>` the block below it
+ * is the body (3.10, 11.1). Every other header opens a block always, because
+ * there is no statement separator to end a one-line body with.
+ */
+export function opensBlock(firstKind, arrowAtEnd) {
+    if (firstKind === 'fn')
+        return arrowAtEnd;
+    return HEADERS.has(firstKind);
+}
+//# sourceMappingURL=statements.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statements.js","sourceRoot":"","sources":["../../../src/core/lex/statements.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;GAQG;AACH,MAAM,UAAU,GAA2B,IAAI,GAAG,CAAY;IAC5D,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,IAAI;IACJ,IAAI;IACJ,GAAG;IACH,IAAI;IACJ,GAAG;IACH,IAAI;IACJ,GAAG;IACH,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,GAAG;IACH,GAAG;IACH,GAAG;IACH,KAAK;IACL,IAAI;CACL,CAAC,CAAC;AAEH,gFAAgF;AAChF,MAAM,OAAO,GAA2B,IAAI,GAAG,CAAY;IACzD,IAAI;IACJ,MAAM;IACN,KAAK;IACL,OAAO;IACP,QAAQ;IACR,MAAM;IACN,SAAS;CACV,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAAC,MAAwB;IACpD,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACzC,IAAI,IAAI,KAAK,SAAS,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IAC7D,OAAO,CACL,IAAI,CAAC,IAAI,KAAK,GAAG;QACjB,MAAM,CAAC,IAAI,KAAK,GAAG;QACnB,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,IAAI,CAAC,MAAM,CAC7D,CAAC;AACJ,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,aAAa,CAAC,MAAwB;IACpD,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvC,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACrC,IAAI,aAAa,CAAC,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IACxC,OAAO,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,UAAU,CAAC,SAAoB,EAAE,UAAmB;IAClE,IAAI,SAAS,KAAK,IAAI;QAAE,OAAO,UAAU,CAAC;IAC1C,OAAO,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AAChC,CAAC"}

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

@@ -0,0 +1,27 @@
+/** A backslash sequence the language does not define, for OS1005. */
+export interface BadEscape {
+    readonly offset: number;
+    readonly length: number;
+    /** The backslash and what followed it, which is the {sequence} of OS1005. */
+    readonly text: string;
+}
+export interface StringLiteral {
+    /** One past the closing quote, or the end of the line when there was none. */
+    readonly end: number;
+    /** The text the literal denotes, with its escapes already resolved. */
+    readonly value: string;
+    readonly unterminated: boolean;
+    readonly badEscapes: readonly BadEscape[];
+}
+/**
+ * Reads the literal opening at `start`, which is the quote character, in either
+ * delimiter of language.md 3.6.
+ *
+ * A literal may not span a line, so the scan stops at the newline and says so
+ * rather than swallowing the rest of the file. The caller reports OS1004 at the
+ * opening quote, which is where the mistake is, and keeps the text that was
+ * read so that the statement around it still parses and the reader is not shown
+ * a second error for the same missing character.
+ */
+export declare function scanString(text: string, start: number): StringLiteral;
+//# sourceMappingURL=strings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../../src/core/lex/strings.ts"],"names":[],"mappings":"AAEA,qEAAqE;AACrE,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;CAC3C;AAsBD;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,CAqErE"}

package/dist/core/lex/strings.js

@@ -0,0 +1,92 @@
+import { BACKSLASH, isHexDigit, LINE_FEED } from './characters.js';
+/** The escapes of language.md 3.6, apart from \uXXXX which carries its own digits. */
+const SIMPLE = new Map([
+    [0x5c, '\\'],
+    [0x22, '"'],
+    [0x27, "'"],
+    [0x6e, '\n'],
+    [0x74, '\t'],
+    [0x72, '\r'],
+    [0x30, '\u0000'],
+]);
+const UNICODE_ESCAPE = 0x75;
+/** How many hexadecimal digits follow, up to the four a \uXXXX escape needs. */
+function hexDigitsAfter(text, from) {
+    let count = 0;
+    while (count < 4 && isHexDigit(text.charCodeAt(from + count)))
+        count++;
+    return count;
+}
+/**
+ * Reads the literal opening at `start`, which is the quote character, in either
+ * delimiter of language.md 3.6.
+ *
+ * A literal may not span a line, so the scan stops at the newline and says so
+ * rather than swallowing the rest of the file. The caller reports OS1004 at the
+ * opening quote, which is where the mistake is, and keeps the text that was
+ * read so that the statement around it still parses and the reader is not shown
+ * a second error for the same missing character.
+ */
+export function scanString(text, start) {
+    const quote = text.charCodeAt(start);
+    const badEscapes = [];
+    let value = '';
+    let plainFrom = start + 1;
+    let i = start + 1;
+    const takePlain = (upTo) => {
+        if (upTo > plainFrom)
+            value += text.slice(plainFrom, upTo);
+    };
+    while (i < text.length) {
+        const code = text.charCodeAt(i);
+        if (code === LINE_FEED)
+            break;
+        if (code === quote) {
+            takePlain(i);
+            return { end: i + 1, value, unterminated: false, badEscapes };
+        }
+        if (code !== BACKSLASH) {
+            i++;
+            continue;
+        }
+        const next = text.charCodeAt(i + 1);
+        // A backslash at the end of the line escapes nothing, because the line is
+        // where the literal has to end. That is one missing quote, not two errors.
+        if (Number.isNaN(next) || next === LINE_FEED)
+            break;
+        takePlain(i);
+        const simple = SIMPLE.get(next);
+        if (simple !== undefined) {
+            value += simple;
+            i += 2;
+            plainFrom = i;
+            continue;
+        }
+        if (next === UNICODE_ESCAPE) {
+            const digits = hexDigitsAfter(text, i + 2);
+            if (digits === 4) {
+                value += String.fromCharCode(Number.parseInt(text.slice(i + 2, i + 6), 16));
+                i += 6;
+                plainFrom = i;
+                continue;
+            }
+            const length = 2 + digits;
+            badEscapes.push({ offset: i, length, text: text.slice(i, i + length) });
+            value += text.slice(i + 1, i + length);
+            i += length;
+            plainFrom = i;
+            continue;
+        }
+        // The written character, whole: an astral character is two code units, and
+        // reporting half of one puts a broken surrogate in the message.
+        const written = String.fromCodePoint(text.codePointAt(i + 1) ?? next);
+        const length = 1 + written.length;
+        badEscapes.push({ offset: i, length, text: text.slice(i, i + length) });
+        value += written;
+        i += length;
+        plainFrom = i;
+    }
+    takePlain(i);
+    return { end: i, value, unterminated: true, badEscapes };
+}
+//# sourceMappingURL=strings.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strings.js","sourceRoot":"","sources":["../../../src/core/lex/strings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAmBnE,sFAAsF;AACtF,MAAM,MAAM,GAAG,IAAI,GAAG,CAAiB;IACrC,CAAC,IAAI,EAAE,IAAI,CAAC;IACZ,CAAC,IAAI,EAAE,GAAG,CAAC;IACX,CAAC,IAAI,EAAE,GAAG,CAAC;IACX,CAAC,IAAI,EAAE,IAAI,CAAC;IACZ,CAAC,IAAI,EAAE,IAAI,CAAC;IACZ,CAAC,IAAI,EAAE,IAAI,CAAC;IACZ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACjB,CAAC,CAAC;AAEH,MAAM,cAAc,GAAG,IAAI,CAAC;AAE5B,gFAAgF;AAChF,SAAS,cAAc,CAAC,IAAY,EAAE,IAAY;IAChD,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,OAAO,KAAK,GAAG,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC;QAAE,KAAK,EAAE,CAAC;IACvE,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,KAAa;IACpD,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACrC,MAAM,UAAU,GAAgB,EAAE,CAAC;IACnC,IAAI,KAAK,GAAG,EAAE,CAAC;IACf,IAAI,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;IAC1B,IAAI,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;IAElB,MAAM,SAAS,GAAG,CAAC,IAAY,EAAQ,EAAE;QACvC,IAAI,IAAI,GAAG,SAAS;YAAE,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC7D,CAAC,CAAC;IAEF,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QACvB,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAEhC,IAAI,IAAI,KAAK,SAAS;YAAE,MAAM;QAE9B,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;YACnB,SAAS,CAAC,CAAC,CAAC,CAAC;YACb,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC;QAChE,CAAC;QAED,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,CAAC,EAAE,CAAC;YACJ,SAAS;QACX,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACpC,0EAA0E;QAC1E,2EAA2E;QAC3E,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,SAAS;YAAE,MAAM;QAEpD,SAAS,CAAC,CAAC,CAAC,CAAC;QAEb,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,KAAK,IAAI,MAAM,CAAC;YAChB,CAAC,IAAI,CAAC,CAAC;YACP,SAAS,GAAG,CAAC,CAAC;YACd,SAAS;QACX,CAAC;QAED,IAAI,IAAI,KAAK,cAAc,EAAE,CAAC;YAC5B,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;YAC3C,IAAI,MAAM,KAAK,CAAC,EAAE,CAAC;gBACjB,KAAK,IAAI,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;gBAC5E,CAAC,IAAI,CAAC,CAAC;gBACP,SAAS,GAAG,CAAC,CAAC;gBACd,SAAS;YACX,CAAC;YACD,MAAM,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC;YAC1B,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;YACxE,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC;YACvC,CAAC,IAAI,MAAM,CAAC;YACZ,SAAS,GAAG,CAAC,CAAC;YACd,SAAS;QACX,CAAC;QAED,2EAA2E;QAC3E,gEAAgE;QAChE,MAAM,OAAO,GAAG,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;QACtE,MAAM,MAAM,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;QAClC,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;QACxE,KAAK,IAAI,OAAO,CAAC;QACjB,CAAC,IAAI,MAAM,CAAC;QACZ,SAAS,GAAG,CAAC,CAAC;IAChB,CAAC;IAED,SAAS,CAAC,CAAC,CAAC,CAAC;IACb,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAC3D,CAAC"}

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

@@ -0,0 +1,31 @@
+/**
+ * OS1001: naming the character that was found, and the plain spelling to write
+ * instead.
+ *
+ * The replacement sentences are the substitution table of errors.md section 7,
+ * which is the one part of an OS1001 message that errors.json does not carry:
+ * the catalogue holds the message and the fix, and section 7 holds the third
+ * column that fills {suggestion}. The table is transcribed here rather than
+ * paraphrased, and the moment it moves into errors.json this file is generated
+ * away instead of being edited.
+ *
+ * A character the table does not name takes the generic sentence, which is what
+ * section 7 says to do with one.
+ */
+export interface Unexpected {
+    /** The {char} slot: what was found, quoted, and named when it cannot be seen. */
+    readonly char: string;
+    /** The {suggestion} slot: one sentence naming the plain spelling to use. */
+    readonly suggestion: string;
+}
+/** What OS1001 says about one rejected character, or one rejected operator. */
+export declare function describeUnexpected(written: string): Unexpected;
+/**
+ * Whether a code point is a letter the language does not allow in a name.
+ *
+ * It is asked once per word, at the character that ended the word, so that
+ * `l\u00e4ngd` is one name with one error on the one character 3.3 refuses,
+ * rather than two names with a stray character between them.
+ */
+export declare function isNonAsciiLetter(point: number): boolean;
+//# sourceMappingURL=unexpected.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unexpected.d.ts","sourceRoot":"","sources":["../../../src/core/lex/unexpected.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,UAAU;IACzB,iFAAiF;IACjF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AA0FD,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAE9D;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEvD"}

package/dist/core/lex/unexpected.js

@@ -0,0 +1,114 @@
+/**
+ * OS1001: naming the character that was found, and the plain spelling to write
+ * instead.
+ *
+ * The replacement sentences are the substitution table of errors.md section 7,
+ * which is the one part of an OS1001 message that errors.json does not carry:
+ * the catalogue holds the message and the fix, and section 7 holds the third
+ * column that fills {suggestion}. The table is transcribed here rather than
+ * paraphrased, and the moment it moves into errors.json this file is generated
+ * away instead of being edited.
+ *
+ * A character the table does not name takes the generic sentence, which is what
+ * section 7 says to do with one.
+ */
+const PLAIN_SPACE = 'Use a plain space instead.';
+const STRAIGHT_QUOTE = 'Use a straight quote instead.';
+const ASCII_NAME = 'Use the ASCII spelling of the name instead.';
+const INDENTATION = 'Use indentation instead, which is how a block is written.';
+const PUT_IN_A_STRING = 'Delete it, or put the text in a string.';
+const GENERIC = 'Delete it, or move it inside a string literal.';
+/** The rows of section 7 that name an exact spelling. */
+const SPELLINGS = new Map([
+    ['!', 'Write not instead.'],
+    ['&&', 'Write and instead.'],
+    ['||', 'Write or instead.'],
+    ['^', 'Write pow(a, b) instead.'],
+    ['**', 'Write pow(a, b) instead.'],
+    ['++', 'Write a += 1 instead.'],
+    ['{', INDENTATION],
+    ['}', INDENTATION],
+    ['#', PUT_IN_A_STRING],
+    ['$', PUT_IN_A_STRING],
+    ['@', PUT_IN_A_STRING],
+]);
+/**
+ * Names for the characters a reader cannot see on their screen.
+ *
+ * A message that quotes an invisible character quotes nothing, and the whole
+ * point of OS1001 is that an invisible character produces a baffling error
+ * three tokens later. The name and the code point are what makes the message
+ * act on: a reader can search their file for the one and read the other aloud.
+ */
+const NAMES = new Map([
+    [0x0009, 'a tab'],
+    [0x000d, 'a carriage return'],
+    [0x00a0, 'a no-break space'],
+    [0x2002, 'an en space'],
+    [0x2003, 'an em space'],
+    [0x2007, 'a figure space'],
+    [0x2009, 'a thin space'],
+    [0x200a, 'a hair space'],
+    [0x202f, 'a narrow no-break space'],
+    [0x3000, 'an ideographic space'],
+    [0x200b, 'a zero width space'],
+    [0x200c, 'a zero width non-joiner'],
+    [0x200d, 'a zero width joiner'],
+    [0xfeff, 'a byte order mark'],
+    [0x2018, 'a left single quotation mark'],
+    [0x2019, 'a right single quotation mark'],
+    [0x201c, 'a left double quotation mark'],
+    [0x201d, 'a right double quotation mark'],
+    [0x2013, 'an en dash'],
+    [0x2014, 'an em dash'],
+    [0x2026, 'a horizontal ellipsis'],
+]);
+const TYPOGRAPHIC_QUOTES = '\u2018\u2019\u201c\u201d\u201a\u201b\u201e\u201f';
+const SPACE_SEPARATOR = /\p{Zs}/u;
+const LETTER = /\p{L}/u;
+const ASCII_GRAPHIC = /^[\x21-\x7e]+$/;
+function codePointLabel(text) {
+    const point = text.codePointAt(0) ?? 0;
+    return `U+${point.toString(16).toUpperCase().padStart(4, '0')}`;
+}
+/**
+ * The {char} slot. An ASCII graphic speaks for itself; everything else is
+ * quoted and then identified, because the quotes may well hold nothing a reader
+ * can see.
+ */
+function describe(written) {
+    if (ASCII_GRAPHIC.test(written))
+        return `"${written}"`;
+    const name = NAMES.get(written.codePointAt(0) ?? -1);
+    const label = codePointLabel(written);
+    return name === undefined ? `"${written}" (${label})` : `"${written}" (${name}, ${label})`;
+}
+function suggestionFor(written) {
+    const spelling = SPELLINGS.get(written);
+    if (spelling !== undefined)
+        return spelling;
+    // A tab is a space that happens to be a control character, and the table's
+    // answer to every other invisible space is the same plain space.
+    if (written === '\t' || SPACE_SEPARATOR.test(written))
+        return PLAIN_SPACE;
+    if (TYPOGRAPHIC_QUOTES.includes(written))
+        return STRAIGHT_QUOTE;
+    if (LETTER.test(written))
+        return ASCII_NAME;
+    return GENERIC;
+}
+/** What OS1001 says about one rejected character, or one rejected operator. */
+export function describeUnexpected(written) {
+    return { char: describe(written), suggestion: suggestionFor(written) };
+}
+/**
+ * Whether a code point is a letter the language does not allow in a name.
+ *
+ * It is asked once per word, at the character that ended the word, so that
+ * `l\u00e4ngd` is one name with one error on the one character 3.3 refuses,
+ * rather than two names with a stray character between them.
+ */
+export function isNonAsciiLetter(point) {
+    return point > 0x7f && LETTER.test(String.fromCodePoint(point));
+}
+//# sourceMappingURL=unexpected.js.map

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

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

package/dist/core/parse/annotations.d.ts

@@ -0,0 +1,4 @@
+import type { TypeAnnotation } from '../ast/index.js';
+import type { Cursor } from './cursor.js';
+export declare function parseTypeAnnotation(cursor: Cursor): TypeAnnotation;
+//# sourceMappingURL=annotations.d.ts.map

package/dist/core/parse/annotations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotations.d.ts","sourceRoot":"","sources":["../../../src/core/parse/annotations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAKtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AA6B1C,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAyBlE"}

package/dist/core/parse/annotations.js

@@ -0,0 +1,49 @@
+import { makeNode } from '../ast/index.js';
+import { spanning } from '../span/index.js';
+import { RESERVED_WORDS } from '../tokens/index.js';
+/**
+ * A type as a script writes it, on a parameter or a `var`.
+ *
+ * The grammar of section 19 admits only the real type names. The prose wins
+ * here, because OS2016 and OS2019 are check stage: this reads any word into a
+ * `namedType` and lets the checker be the one to say that `whole` is not a
+ * type, which is the difference between a caret with no sentence and a sentence
+ * naming the types that do exist.
+ */
+const RESERVED = new Set(RESERVED_WORDS);
+/**
+ * What may stand as a type name.
+ *
+ * A literal is taken as well as a word, so `len: 5` reaches OS2016 with `5` in
+ * its message instead of failing here with a caret and nothing to act on.
+ */
+function isTypeWord(kind) {
+    return (kind === 'identifier' ||
+        kind === 'numberLiteral' ||
+        kind === 'stringLiteral' ||
+        RESERVED.has(kind));
+}
+export function parseTypeAnnotation(cursor) {
+    const token = cursor.token;
+    if (token.kind === 'series') {
+        cursor.advance();
+        const element = parseTypeAnnotation(cursor);
+        return makeNode('seriesType', spanning(token.span, element.span), { element });
+    }
+    if (token.kind === 'array' && cursor.peek().kind === '<') {
+        cursor.advance();
+        cursor.advance();
+        const element = parseTypeAnnotation(cursor);
+        const close = cursor.take('>');
+        if (close === undefined)
+            cursor.unexpected(cursor.token);
+        return makeNode('arrayType', spanning(token.span, close?.span ?? element.span), { element });
+    }
+    if (isTypeWord(token.kind)) {
+        cursor.advance();
+        return makeNode('namedType', token.span, { name: token.text });
+    }
+    cursor.unexpected(token);
+    return makeNode('namedType', cursor.holeSpan(), { name: '' });
+}
+//# sourceMappingURL=annotations.js.map

package/dist/core/parse/annotations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotations.js","sourceRoot":"","sources":["../../../src/core/parse/annotations.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpD;;;;;;;;GAQG;AAEH,MAAM,QAAQ,GAA2B,IAAI,GAAG,CAAY,cAAc,CAAC,CAAC;AAE5E;;;;;GAKG;AACH,SAAS,UAAU,CAAC,IAAe;IACjC,OAAO,CACL,IAAI,KAAK,YAAY;QACrB,IAAI,KAAK,eAAe;QACxB,IAAI,KAAK,eAAe;QACxB,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CACnB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,MAAc;IAChD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAE3B,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC5B,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,MAAM,OAAO,GAAG,mBAAmB,CAAC,MAAM,CAAC,CAAC;QAC5C,OAAO,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IACjF,CAAC;IAED,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,GAAG,EAAE,CAAC;QACzD,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,MAAM,OAAO,GAAG,mBAAmB,CAAC,MAAM,CAAC,CAAC;QAC5C,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,KAAK,KAAK,SAAS;YAAE,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACzD,OAAO,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IAC/F,CAAC;IAED,IAAI,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3B,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,OAAO,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;IACjE,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACzB,OAAO,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,QAAQ,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;AAChE,CAAC"}

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

@@ -0,0 +1,18 @@
+import type { Block } from '../ast/index.js';
+import type { Span } from '../span/index.js';
+import type { Cursor } from './cursor.js';
+/**
+ * The indented lines under a header, language.md 3.10.
+ *
+ * The lexer has already decided where a block begins and ends, so this reads an
+ * `indent`, statements, and a `dedent`, and the one rule it owns is what to do
+ * when the `indent` is not there: OS1010, reported against the header rather
+ * than against the line that failed to be a body, because the header is what
+ * the reader has to change.
+ *
+ * The statement loop insists on progress. A rule that reports without consuming
+ * anything would otherwise spin on the token it could not read, and a compiler
+ * that hangs on a malformed file is worse than one that gives up on it.
+ */
+export declare function parseBlock(cursor: Cursor, header: string, at: Span): Block;
+//# sourceMappingURL=blocks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.d.ts","sourceRoot":"","sources":["../../../src/core/parse/blocks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAkC,MAAM,iBAAiB,CAAC;AAE7E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG1C;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,GAAG,KAAK,CA+B1E"}

package/dist/core/parse/blocks.js

@@ -0,0 +1,47 @@
+import { makeNode } from '../ast/index.js';
+import { spanning } from '../span/index.js';
+import { parseStatement } from './statements.js';
+/**
+ * The indented lines under a header, language.md 3.10.
+ *
+ * The lexer has already decided where a block begins and ends, so this reads an
+ * `indent`, statements, and a `dedent`, and the one rule it owns is what to do
+ * when the `indent` is not there: OS1010, reported against the header rather
+ * than against the line that failed to be a body, because the header is what
+ * the reader has to change.
+ *
+ * The statement loop insists on progress. A rule that reports without consuming
+ * anything would otherwise spin on the token it could not read, and a compiler
+ * that hangs on a malformed file is worse than one that gives up on it.
+ */
+export function parseBlock(cursor, header, at) {
+    if (!cursor.at('indent')) {
+        // A header that was already reported on has nothing to add by saying its
+        // body is missing too: the body is missing because of what it was told.
+        if (!cursor.reportedHere)
+            cursor.report('OS1010', at, { header });
+        const hole = cursor.holeSpan();
+        return makeNode('block', hole, { statements: [] });
+    }
+    if (!cursor.openBlock(cursor.token.span)) {
+        const span = cursor.token.span;
+        cursor.skipBlockBody();
+        return makeNode('block', span, { statements: [] });
+    }
+    const indent = cursor.advance();
+    const statements = [];
+    while (!cursor.at('dedent') && !cursor.at('endOfFile')) {
+        const before = cursor.position;
+        const statement = parseStatement(cursor);
+        if (statement !== undefined)
+            statements.push(statement);
+        if (cursor.position === before)
+            cursor.skipStatement();
+    }
+    cursor.closeBlock();
+    cursor.take('dedent');
+    const last = statements[statements.length - 1];
+    const span = last === undefined ? indent.span : spanning(indent.span, last.span);
+    return makeNode('block', span, { statements });
+}
+//# sourceMappingURL=blocks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.js","sourceRoot":"","sources":["../../../src/core/parse/blocks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,UAAU,CAAC,MAAc,EAAE,MAAc,EAAE,EAAQ;IACjE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzB,yEAAyE;QACzE,wEAAwE;QACxE,IAAI,CAAC,MAAM,CAAC,YAAY;YAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QAClE,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;QAC/B,OAAO,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;IACrD,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACzC,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;QAC/B,MAAM,CAAC,aAAa,EAAE,CAAC;QACvB,OAAO,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;IACrD,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC;IAChC,MAAM,UAAU,GAAwC,EAAE,CAAC;IAE3D,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC;QACvD,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC;QAC/B,MAAM,SAAS,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;QACzC,IAAI,SAAS,KAAK,SAAS;YAAE,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACxD,IAAI,MAAM,CAAC,QAAQ,KAAK,MAAM;YAAE,MAAM,CAAC,aAAa,EAAE,CAAC;IACzD,CAAC;IAED,MAAM,CAAC,UAAU,EAAE,CAAC;IACpB,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAEtB,MAAM,IAAI,GAAG,UAAU,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC/C,MAAM,IAAI,GAAG,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACjF,OAAO,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;AACjD,CAAC"}