@magnusopera/fscript 0.75.0

package/dist/FScript.Language/Parser.js

@@ -0,0 +1,2368 @@
+
+import { class_type } from "../fable_modules/fable-library-js.5.2.0/Reflection.js";
+import { singleton, tail as tail_1, head as head_1, isEmpty, foldBack, empty, length, item } from "../fable_modules/fable-library-js.5.2.0/List.js";
+import { equals } from "../fable_modules/fable-library-js.5.2.0/Util.js";
+import { ParseException, ParseError } from "./Error.js";
+import { TokenKind } from "./Token.js";
+import { Span, SpanModule_merge } from "./Span.js";
+import { isNullOrWhiteSpace, substring, concat, join, isNullOrEmpty } from "../fable_modules/fable-library-js.5.2.0/String.js";
+import { isUpper } from "../fable_modules/fable-library-js.5.2.0/Char.js";
+import { MapEntry, Ast_spanOfExpr, InterpolatedPart, Expr, Ast_spanOfPattern, Pattern, Stmt, TypeDef, Param, TypeRef, Literal } from "./Ast.js";
+import { tokenizeWithSourceName } from "./Lexer.js";
+import { addToSet } from "../fable_modules/fable-library-js.5.2.0/MapUtil.js";
+import { foldBack as foldBack_1, toList } from "../fable_modules/fable-library-js.5.2.0/Seq.js";
+import { StringBuilder__Append_244C7CD6, StringBuilder__Clear, StringBuilder__get_Length, StringBuilder_$ctor } from "../fable_modules/fable-library-js.5.2.0/System.Text.js";
+import { toString } from "../fable_modules/fable-library-js.5.2.0/Types.js";
+import { item as item_1 } from "../fable_modules/fable-library-js.5.2.0/Array.js";
+
+class TokenStream {
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.index = 0;
+    }
+}
+
+function TokenStream_$reflection() {
+    return class_type("FScript.Language.Parser.TokenStream", undefined, TokenStream);
+}
+
+function TokenStream_$ctor_Z3FD4619(tokens) {
+    return new TokenStream(tokens);
+}
+
+function TokenStream__Peek(_) {
+    return item(_.index, _.tokens);
+}
+
+function TokenStream__PeekAt_Z524259A4(_, offset) {
+    return item(_.index + offset, _.tokens);
+}
+
+function TokenStream__TokenAt_Z524259A4(_, i) {
+    return item(i, _.tokens);
+}
+
+function TokenStream__get_Index(_) {
+    return _.index | 0;
+}
+
+function TokenStream__Mark(_) {
+    return _.index | 0;
+}
+
+function TokenStream__Restore_Z524259A4(_, mark) {
+    _.index = (mark | 0);
+}
+
+function TokenStream__Next(_) {
+    const t = item(_.index, _.tokens);
+    _.index = ((_.index + 1) | 0);
+    return t;
+}
+
+function TokenStream__Match_5CEB78CD(_, kind) {
+    if (equals(item(_.index, _.tokens).Kind, kind)) {
+        _.index = ((_.index + 1) | 0);
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+function TokenStream__Expect_77B9EE56(_, kind, message) {
+    const t = item(_.index, _.tokens);
+    if (equals(t.Kind, kind)) {
+        _.index = ((_.index + 1) | 0);
+        return t;
+    }
+    else {
+        throw new ParseException(new ParseError(message, t.Span));
+    }
+}
+
+function TokenStream__ExpectIdent_Z721C83C5(_, message) {
+    const t = item(_.index, _.tokens);
+    if (t.Kind.tag === 4) {
+        _.index = ((_.index + 1) | 0);
+        return t;
+    }
+    else {
+        throw new ParseException(new ParseError(message, t.Span));
+    }
+}
+
+function TokenStream__get_AtEnd(_) {
+    return equals(item(_.index, _.tokens).Kind, new TokenKind(0, []));
+}
+
+function TokenStream__SkipNewlines(_) {
+    while (equals(item(_.index, _.tokens).Kind, new TokenKind(1, []))) {
+        _.index = ((_.index + 1) | 0);
+    }
+}
+
+function mkSpanFrom(a, b) {
+    return SpanModule_merge(a, b);
+}
+
+function isStartAtom(k) {
+    switch (k.tag) {
+        case 4:
+        case 5:
+        case 6:
+        case 7:
+        case 8:
+        case 9:
+        case 27:
+        case 29:
+        case 43:
+        case 10:
+        case 13:
+        case 17:
+        case 21:
+        case 22:
+        case 14:
+        case 46:
+        case 47:
+            return true;
+        default:
+            return false;
+    }
+}
+
+function isUpperIdent(name) {
+    if (!isNullOrEmpty(name)) {
+        return isUpper(name[0]);
+    }
+    else {
+        return false;
+    }
+}
+
+function isStartPatternAtom(k) {
+    switch (k.tag) {
+        case 4:
+        case 5:
+        case 6:
+        case 7:
+        case 9:
+        case 29:
+        case 27:
+        case 43:
+            return true;
+        default:
+            return false;
+    }
+}
+
+function parseLiteral(t) {
+    const matchValue = t.Kind;
+    switch (matchValue.tag) {
+        case 5:
+            return new Literal(0, [matchValue.fields[0]]);
+        case 6:
+            return new Literal(1, [matchValue.fields[0]]);
+        case 7:
+            return new Literal(3, [matchValue.fields[0]]);
+        case 9:
+            return new Literal(2, [matchValue.fields[0]]);
+        default:
+            throw new ParseException(new ParseError("Expected literal", t.Span));
+    }
+}
+
+export function parseProgramWithSourceName(sourceName, src) {
+    const tokens = tokenizeWithSourceName(sourceName, src);
+    const stream = TokenStream_$ctor_Z3FD4619(tokens);
+    const consumeLayoutSeparators = () => {
+        let consumed = false;
+        let progress = true;
+        while (progress) {
+            progress = false;
+            while (TokenStream__Match_5CEB78CD(stream, new TokenKind(1, []))) {
+                consumed = true;
+                progress = true;
+            }
+            while (TokenStream__Match_5CEB78CD(stream, new TokenKind(2, []))) {
+                consumed = true;
+                progress = true;
+            }
+            while (TokenStream__Match_5CEB78CD(stream, new TokenKind(3, []))) {
+                consumed = true;
+                progress = true;
+            }
+        }
+        return consumed;
+    };
+    const hasNonLayoutTokenBeforeOnSameLine = (tokenIndex, line) => {
+        let i_2 = tokenIndex - 1;
+        let keepSearching = true;
+        let foundSameLine = false;
+        while (keepSearching && (i_2 >= 0)) {
+            const tok = TokenStream__TokenAt_Z524259A4(stream, i_2);
+            const matchValue_1 = tok.Kind;
+            switch (matchValue_1.tag) {
+                case 1: {
+                    keepSearching = false;
+                    break;
+                }
+                case 2:
+                case 3: {
+                    i_2 = ((i_2 - 1) | 0);
+                    break;
+                }
+                default: {
+                    foundSameLine = (tok.Span.Start.Line === line);
+                    keepSearching = false;
+                }
+            }
+        }
+        return foundSameLine;
+    };
+    const hasNonLayoutTokenAfterOnSameLine = (tokenIndex_1, line_1) => {
+        let i_3 = tokenIndex_1 + 1;
+        let keepSearching_1 = true;
+        let foundSameLine_1 = false;
+        while (keepSearching_1 && (i_3 < length(tokens))) {
+            const tok_1 = TokenStream__TokenAt_Z524259A4(stream, i_3);
+            const matchValue_2 = tok_1.Kind;
+            switch (matchValue_2.tag) {
+                case 1:
+                case 2:
+                case 3: {
+                    i_3 = ((i_3 + 1) | 0);
+                    break;
+                }
+                default: {
+                    foundSameLine_1 = (tok_1.Span.Start.Line === line_1);
+                    keepSearching_1 = false;
+                }
+            }
+        }
+        return foundSameLine_1;
+    };
+    let allowIndentedApplication = true;
+    let allowBinaryNewlineSkipping = true;
+    const parseTypeRefAtom = () => {
+        let firstName, matchValue_3, parts_1, keepGoing;
+        TokenStream__SkipNewlines(stream);
+        const matchValue_5 = TokenStream__Peek(stream).Kind;
+        switch (matchValue_5.tag) {
+            case 4:
+                return new TypeRef(0, [(firstName = ((matchValue_3 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected type name").Kind, (matchValue_3.tag === 4) ? matchValue_3.fields[0] : "")), (parts_1 = [], (void (parts_1.push(firstName)), (keepGoing = true, ((() => {
+                    while (keepGoing && TokenStream__Match_5CEB78CD(stream, new TokenKind(36, []))) {
+                        const matchValue_4 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected identifier after \'.\' in qualified type name").Kind;
+                        if (matchValue_4.tag === 4) {
+                            void (parts_1.push(matchValue_4.fields[0]));
+                        }
+                        keepGoing = true;
+                    }
+                })(), join(".", parts_1))))))]);
+            case 43: {
+                TokenStream__Next(stream);
+                const isStructural = TokenStream__Match_5CEB78CD(stream, new TokenKind(26, []));
+                const fields = [];
+                const seen = new Set([]);
+                const parseField = () => {
+                    const nameTok = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected field name in inline record type");
+                    let fieldName;
+                    const matchValue_6 = nameTok.Kind;
+                    fieldName = ((matchValue_6.tag === 4) ? matchValue_6.fields[0] : "");
+                    if (!addToSet(fieldName, seen)) {
+                        throw new ParseException(new ParseError(concat("Duplicate field \'", fieldName, "\' in inline record type"), nameTok.Span));
+                    }
+                    TokenStream__Expect_77B9EE56(stream, new TokenKind(35, []), "Expected \':\' after inline record type field name");
+                    const fieldType = parseTypeRef();
+                    void (fields.push([fieldName, fieldType]));
+                };
+                if ((isStructural && equals(TokenStream__Peek(stream).Kind, new TokenKind(26, []))) ? true : (!isStructural && equals(TokenStream__Peek(stream).Kind, new TokenKind(44, [])))) {
+                    throw new ParseException(new ParseError("Inline record type must define at least one field", TokenStream__Peek(stream).Span));
+                }
+                parseField();
+                while (TokenStream__Match_5CEB78CD(stream, new TokenKind(33, []))) {
+                    if ((isStructural && !equals(TokenStream__Peek(stream).Kind, new TokenKind(26, []))) ? true : (!isStructural && !equals(TokenStream__Peek(stream).Kind, new TokenKind(44, [])))) {
+                        parseField();
+                    }
+                }
+                if (isStructural) {
+                    TokenStream__Expect_77B9EE56(stream, new TokenKind(26, []), "Expected \'|\' in structural record type");
+                }
+                TokenStream__Expect_77B9EE56(stream, new TokenKind(44, []), "Expected \'}\' in inline record type");
+                if (isStructural) {
+                    return new TypeRef(5, [toList(fields)]);
+                }
+                else {
+                    return new TypeRef(4, [toList(fields)]);
+                }
+            }
+            case 27: {
+                TokenStream__Next(stream);
+                const first_1 = parseTypeRef();
+                if (TokenStream__Match_5CEB78CD(stream, new TokenKind(51, []))) {
+                    const items = [];
+                    void (items.push(first_1));
+                    void (items.push(parseTypeRef()));
+                    while (TokenStream__Match_5CEB78CD(stream, new TokenKind(51, []))) {
+                        void (items.push(parseTypeRef()));
+                    }
+                    TokenStream__Expect_77B9EE56(stream, new TokenKind(28, []), "Expected \')\' in tuple type");
+                    return new TypeRef(1, [toList(items)]);
+                }
+                else {
+                    TokenStream__Expect_77B9EE56(stream, new TokenKind(28, []), "Expected \')\' in type expression");
+                    return first_1;
+                }
+            }
+            default:
+                throw new ParseException(new ParseError("Expected type expression", TokenStream__Peek(stream).Span));
+        }
+    };
+    const parseTypeRefPostfix = () => {
+        let t = parseTypeRefAtom();
+        let loop = true;
+        while (loop) {
+            const matchValue_7 = TokenStream__Peek(stream).Kind;
+            let matchResult;
+            if (matchValue_7.tag === 4) {
+                switch (matchValue_7.fields[0]) {
+                    case "list": {
+                        matchResult = 0;
+                        break;
+                    }
+                    case "option": {
+                        matchResult = 1;
+                        break;
+                    }
+                    case "map": {
+                        matchResult = 2;
+                        break;
+                    }
+                    case "task": {
+                        matchResult = 3;
+                        break;
+                    }
+                    default:
+                        matchResult = 4;
+                }
+            }
+            else {
+                matchResult = 4;
+            }
+            switch (matchResult) {
+                case 0: {
+                    TokenStream__Next(stream);
+                    t = (new TypeRef(3, [t, "list"]));
+                    break;
+                }
+                case 1: {
+                    TokenStream__Next(stream);
+                    t = (new TypeRef(3, [t, "option"]));
+                    break;
+                }
+                case 2: {
+                    TokenStream__Next(stream);
+                    t = (new TypeRef(3, [t, "map"]));
+                    break;
+                }
+                case 3: {
+                    TokenStream__Next(stream);
+                    t = (new TypeRef(3, [t, "task"]));
+                    break;
+                }
+                case 4: {
+                    loop = false;
+                    break;
+                }
+            }
+        }
+        return t;
+    };
+    const parseTypeRef = () => {
+        const left = parseTypeRefPostfix();
+        if (TokenStream__Match_5CEB78CD(stream, new TokenKind(24, []))) {
+            return new TypeRef(2, [left, parseTypeRef()]);
+        }
+        else {
+            return left;
+        }
+    };
+    const parseParam = () => {
+        TokenStream__SkipNewlines(stream);
+        const matchValue_8 = TokenStream__Peek(stream).Kind;
+        switch (matchValue_8.tag) {
+            case 4:
+                return new Param(matchValue_8.fields[0], undefined, TokenStream__Next(stream).Span);
+            case 27: {
+                const lp = TokenStream__Next(stream);
+                TokenStream__SkipNewlines(stream);
+                if (TokenStream__Match_5CEB78CD(stream, new TokenKind(28, []))) {
+                    return new Param("()", new TypeRef(0, ["unit"]), mkSpanFrom(lp.Span, TokenStream__TokenAt_Z524259A4(stream, TokenStream__get_Index(stream) - 1).Span));
+                }
+                else {
+                    let name;
+                    const matchValue_9 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected parameter name in annotated parameter").Kind;
+                    name = ((matchValue_9.tag === 4) ? matchValue_9.fields[0] : "");
+                    TokenStream__SkipNewlines(stream);
+                    TokenStream__Expect_77B9EE56(stream, new TokenKind(35, []), "Expected \':\' in annotated parameter");
+                    return new Param(name, parseTypeRef(), mkSpanFrom(lp.Span, TokenStream__Expect_77B9EE56(stream, new TokenKind(28, []), "Expected \')\' after annotated parameter").Span));
+                }
+            }
+            default:
+                throw new ParseException(new ParseError("Expected parameter", TokenStream__Peek(stream).Span));
+        }
+    };
+    const parseParamsAligned = () => {
+        const args = [];
+        let argsDone = false;
+        let firstParamColumn = undefined;
+        while (!argsDone) {
+            let sawNewline = false;
+            while (TokenStream__Match_5CEB78CD(stream, new TokenKind(1, []))) {
+                sawNewline = true;
+            }
+            while (TokenStream__Match_5CEB78CD(stream, new TokenKind(2, []))) {
+            }
+            while (TokenStream__Match_5CEB78CD(stream, new TokenKind(3, []))) {
+            }
+            const matchValue_10 = TokenStream__Peek(stream).Kind;
+            switch (matchValue_10.tag) {
+                case 4:
+                case 27: {
+                    const param = parseParam();
+                    if (firstParamColumn != null) {
+                        const firstCol = firstParamColumn | 0;
+                        if (sawNewline && (param.Span.Start.Column !== firstCol)) {
+                            throw new ParseException(new ParseError("Multiline let parameter columns must align", param.Span));
+                        }
+                    }
+                    else {
+                        firstParamColumn = param.Span.Start.Column;
+                    }
+                    void (args.push(param));
+                    break;
+                }
+                default:
+                    argsDone = true;
+            }
+        }
+        return args;
+    };
+    const parseTypeDecl = () => {
+        const typeTok = TokenStream__Expect_77B9EE56(stream, new TokenKind(45, []), "Expected \'type\'");
+        const isRec = TokenStream__Match_5CEB78CD(stream, new TokenKind(11, []));
+        let name_1;
+        const matchValue_11 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected identifier after \'type\'").Kind;
+        name_1 = ((matchValue_11.tag === 4) ? matchValue_11.fields[0] : "");
+        TokenStream__SkipNewlines(stream);
+        TokenStream__Expect_77B9EE56(stream, new TokenKind(25, []), "Expected \'=\' in type declaration");
+        let hasOuterIndent = false;
+        if (TokenStream__Match_5CEB78CD(stream, new TokenKind(1, []))) {
+            while (TokenStream__Match_5CEB78CD(stream, new TokenKind(1, []))) {
+            }
+            if (TokenStream__Match_5CEB78CD(stream, new TokenKind(2, []))) {
+                hasOuterIndent = true;
+            }
+        }
+        let patternInput_1;
+        const matchValue_15 = TokenStream__Peek(stream).Kind;
+        switch (matchValue_15.tag) {
+            case 43: {
+                const lbIndex = TokenStream__get_Index(stream) | 0;
+                const lb = TokenStream__Expect_77B9EE56(stream, new TokenKind(43, []), "Expected \'{\' in record type declaration");
+                if (!hasNonLayoutTokenAfterOnSameLine(lbIndex, lb.Span.Start.Line)) {
+                    throw new ParseException(new ParseError("Opening \'{\' cannot be on its own line; keep it with the first field", lb.Span));
+                }
+                const fields_1 = [];
+                const parseField_1 = () => {
+                    TokenStream__SkipNewlines(stream);
+                    const fieldTok = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected field name in type declaration");
+                    let fieldName_1;
+                    const matchValue_12 = fieldTok.Kind;
+                    fieldName_1 = ((matchValue_12.tag === 4) ? matchValue_12.fields[0] : "");
+                    TokenStream__SkipNewlines(stream);
+                    TokenStream__Expect_77B9EE56(stream, new TokenKind(35, []), "Expected \':\' after field name");
+                    const fieldType_1 = parseTypeRef();
+                    void (fields_1.push([fieldName_1, fieldType_1]));
+                    return fieldTok.Span.Start.Column | 0;
+                };
+                const firstFieldColumn = parseField_1() | 0;
+                let doneFields = false;
+                while (!doneFields) {
+                    if (TokenStream__Match_5CEB78CD(stream, new TokenKind(33, []))) {
+                        if (!equals(TokenStream__Peek(stream).Kind, new TokenKind(44, []))) {
+                            parseField_1();
+                        }
+                        else {
+                            doneFields = true;
+                        }
+                    }
+                    else {
+                        let sawNewline_1 = false;
+                        while (TokenStream__Match_5CEB78CD(stream, new TokenKind(1, []))) {
+                            sawNewline_1 = true;
+                        }
+                        while (TokenStream__Match_5CEB78CD(stream, new TokenKind(2, []))) {
+                        }
+                        while (TokenStream__Match_5CEB78CD(stream, new TokenKind(3, []))) {
+                        }
+                        if (sawNewline_1) {
+                            const matchValue_13 = TokenStream__Peek(stream).Kind;
+                            switch (matchValue_13.tag) {
+                                case 44: {
+                                    doneFields = true;
+                                    break;
+                                }
+                                case 4: {
+                                    if (parseField_1() !== firstFieldColumn) {
+                                        throw new ParseException(new ParseError("Type declaration fields must align", TokenStream__Peek(stream).Span));
+                                    }
+                                    break;
+                                }
+                                default:
+                                    throw new ParseException(new ParseError("Expected field or \'}\' in record type declaration", TokenStream__Peek(stream).Span));
+                            }
+                        }
+                        else {
+                            doneFields = true;
+                        }
+                    }
+                }
+                const rbIndex = TokenStream__get_Index(stream) | 0;
+                const rb = TokenStream__Expect_77B9EE56(stream, new TokenKind(44, []), "Expected \'}\' in record type declaration");
+                if (!hasNonLayoutTokenBeforeOnSameLine(rbIndex, rb.Span.Start.Line)) {
+                    throw new ParseException(new ParseError("Closing \'}\' cannot be on its own line; keep it with the last field", rb.Span));
+                }
+                patternInput_1 = [toList(fields_1), empty(), rb.Span];
+                break;
+            }
+            case 26:
+            case 4: {
+                const cases = [];
+                const parseCase = () => {
+                    TokenStream__SkipNewlines(stream);
+                    TokenStream__Match_5CEB78CD(stream, new TokenKind(26, []));
+                    const caseTok = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected union case name");
+                    let caseName;
+                    const matchValue_14 = caseTok.Kind;
+                    caseName = ((matchValue_14.tag === 4) ? matchValue_14.fields[0] : "");
+                    if (!isUpperIdent(caseName)) {
+                        throw new ParseException(new ParseError("Union case name must start with uppercase letter", caseTok.Span));
+                    }
+                    TokenStream__SkipNewlines(stream);
+                    const payload = TokenStream__Match_5CEB78CD(stream, new TokenKind(48, [])) ? parseTypeRef() : undefined;
+                    void (cases.push([caseName, payload]));
+                    return caseTok.Span;
+                };
+                let lastSpan = parseCase().End;
+                let doneCases = false;
+                while (!doneCases) {
+                    let sawNewline_2 = false;
+                    while (TokenStream__Match_5CEB78CD(stream, new TokenKind(1, []))) {
+                        sawNewline_2 = true;
+                    }
+                    while (TokenStream__Match_5CEB78CD(stream, new TokenKind(2, []))) {
+                    }
+                    if (equals(TokenStream__Peek(stream).Kind, new TokenKind(26, []))) {
+                        const s_1 = parseCase();
+                        lastSpan = s_1.End;
+                    }
+                    else if (sawNewline_2) {
+                        doneCases = true;
+                    }
+                    else {
+                        doneCases = true;
+                    }
+                }
+                patternInput_1 = [empty(), toList(cases), new Span(lastSpan, lastSpan)];
+                break;
+            }
+            default:
+                throw new ParseException(new ParseError("Expected record or union type declaration body", TokenStream__Peek(stream).Span));
+        }
+        if (hasOuterIndent) {
+            TokenStream__SkipNewlines(stream);
+            if (!TokenStream__Match_5CEB78CD(stream, new TokenKind(3, []))) {
+                throw new ParseException(new ParseError("Expected dedent after type declaration", TokenStream__Peek(stream).Span));
+            }
+            while (TokenStream__Match_5CEB78CD(stream, new TokenKind(3, []))) {
+            }
+        }
+        return new Stmt(0, [new TypeDef(name_1, isRec, patternInput_1[0], patternInput_1[1], mkSpanFrom(typeTok.Span, patternInput_1[2]))]);
+    };
+    const parsePattern = () => {
+        TokenStream__SkipNewlines(stream);
+        const t_1 = TokenStream__Peek(stream);
+        const matchValue_16 = t_1.Kind;
+        let matchResult_1, name_3, name_4;
+        switch (matchValue_16.tag) {
+            case 5:
+            case 6:
+            case 7:
+            case 9: {
+                matchResult_1 = 2;
+                break;
+            }
+            case 29: {
+                matchResult_1 = 3;
+                break;
+            }
+            case 27: {
+                matchResult_1 = 4;
+                break;
+            }
+            case 43: {
+                matchResult_1 = 5;
+                break;
+            }
+            case 4: {
+                if (matchValue_16.fields[0] === "_") {
+                    matchResult_1 = 0;
+                    name_3 = matchValue_16.fields[0];
+                }
+                else {
+                    matchResult_1 = 1;
+                    name_4 = matchValue_16.fields[0];
+                }
+                break;
+            }
+            default:
+                matchResult_1 = 6;
+        }
+        switch (matchResult_1) {
+            case 0:
+                return new Pattern(0, [TokenStream__Next(stream).Span]);
+            case 1: {
+                const t_3 = TokenStream__Next(stream);
+                if (isUpperIdent(name_4) && TokenStream__Match_5CEB78CD(stream, new TokenKind(36, []))) {
+                    const caseTok_1 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected union case name after \'.\'");
+                    let caseName_1;
+                    const matchValue_17 = caseTok_1.Kind;
+                    caseName_1 = ((matchValue_17.tag === 4) ? matchValue_17.fields[0] : "");
+                    if (!isUpperIdent(caseName_1)) {
+                        throw new ParseException(new ParseError("Union case name must start with uppercase letter", caseTok_1.Span));
+                    }
+                    if (isStartPatternAtom(TokenStream__Peek(stream).Kind)) {
+                        const p = parsePattern();
+                        return new Pattern(10, [name_4, caseName_1, p, mkSpanFrom(t_3.Span, Ast_spanOfPattern(p))]);
+                    }
+                    else {
+                        return new Pattern(10, [name_4, caseName_1, undefined, mkSpanFrom(t_3.Span, caseTok_1.Span)]);
+                    }
+                }
+                else {
+                    switch (name_4) {
+                        case "None":
+                            return new Pattern(9, [t_3.Span]);
+                        case "Some": {
+                            const p_1 = parsePattern();
+                            return new Pattern(8, [p_1, mkSpanFrom(t_3.Span, Ast_spanOfPattern(p_1))]);
+                        }
+                        default:
+                            if (isUpperIdent(name_4)) {
+                                if (isStartPatternAtom(TokenStream__Peek(stream).Kind)) {
+                                    const p_2 = parsePattern();
+                                    return new Pattern(10, [undefined, name_4, p_2, mkSpanFrom(t_3.Span, Ast_spanOfPattern(p_2))]);
+                                }
+                                else {
+                                    return new Pattern(10, [undefined, name_4, undefined, t_3.Span]);
+                                }
+                            }
+                            else {
+                                return new Pattern(1, [name_4, t_3.Span]);
+                            }
+                    }
+                }
+            }
+            case 2: {
+                const t_4 = TokenStream__Next(stream);
+                return new Pattern(2, [parseLiteral(t_4), t_4.Span]);
+            }
+            case 3: {
+                const lbIndex_1 = TokenStream__get_Index(stream) | 0;
+                const lb_1 = TokenStream__Next(stream);
+                if (!hasNonLayoutTokenAfterOnSameLine(lbIndex_1, lb_1.Span.Start.Line)) {
+                    throw new ParseException(new ParseError("Opening \'[\' cannot be on its own line; keep it with the first element", lb_1.Span));
+                }
+                if (TokenStream__Match_5CEB78CD(stream, new TokenKind(30, []))) {
+                    return new Pattern(3, [mkSpanFrom(lb_1.Span, lb_1.Span)]);
+                }
+                else {
+                    const first_2 = parsePatternCons();
+                    const elements = [];
+                    void (elements.push(first_2));
+                    while (TokenStream__Match_5CEB78CD(stream, new TokenKind(33, []))) {
+                        if (!equals(TokenStream__Peek(stream).Kind, new TokenKind(30, []))) {
+                            void (elements.push(parsePatternCons()));
+                        }
+                    }
+                    const rbIndex_1 = TokenStream__get_Index(stream) | 0;
+                    const rb_1 = TokenStream__Expect_77B9EE56(stream, new TokenKind(30, []), "Expected \']\' in list pattern");
+                    if (!hasNonLayoutTokenBeforeOnSameLine(rbIndex_1, rb_1.Span.Start.Line)) {
+                        throw new ParseException(new ParseError("Closing \']\' cannot be on its own line; keep it with the last element", rb_1.Span));
+                    }
+                    return foldBack((head, tail) => (new Pattern(4, [head, tail, mkSpanFrom(Ast_spanOfPattern(head), Ast_spanOfPattern(tail))])), toList(elements), new Pattern(3, [mkSpanFrom(rb_1.Span, rb_1.Span)]));
+                }
+            }
+            case 4: {
+                const lp_1 = TokenStream__Next(stream);
+                const first_3 = parsePatternCons();
+                if (TokenStream__Match_5CEB78CD(stream, new TokenKind(34, []))) {
+                    const elements_1 = [];
+                    void (elements_1.push(first_3));
+                    void (elements_1.push(parsePatternCons()));
+                    while (TokenStream__Match_5CEB78CD(stream, new TokenKind(34, []))) {
+                        void (elements_1.push(parsePatternCons()));
+                    }
+                    const rp_2 = TokenStream__Expect_77B9EE56(stream, new TokenKind(28, []), "Expected \')\' after tuple pattern");
+                    return new Pattern(5, [toList(elements_1), mkSpanFrom(lp_1.Span, rp_2.Span)]);
+                }
+                else {
+                    TokenStream__Expect_77B9EE56(stream, new TokenKind(28, []), "Expected \')\' after parenthesized pattern");
+                    return first_3;
+                }
+            }
+            case 5: {
+                const lbIndex_2 = TokenStream__get_Index(stream) | 0;
+                const lb_2 = TokenStream__Next(stream);
+                if (!hasNonLayoutTokenAfterOnSameLine(lbIndex_2, lb_2.Span.Start.Line)) {
+                    throw new ParseException(new ParseError("Opening \'{\' cannot be on its own line; keep it with the first entry", lb_2.Span));
+                }
+                TokenStream__SkipNewlines(stream);
+                if (TokenStream__Match_5CEB78CD(stream, new TokenKind(44, []))) {
+                    return new Pattern(7, [empty(), undefined, mkSpanFrom(lb_2.Span, lb_2.Span)]);
+                }
+                else if (equals(TokenStream__Peek(stream).Kind, new TokenKind(26, []))) {
+                    TokenStream__Next(stream);
+                    const fields_3 = [];
+                    const seen_1 = new Set([]);
+                    const parseTypeField = () => {
+                        const nameTok_3 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected field name in structural record type pattern");
+                        let fieldName_2;
+                        const matchValue_18 = nameTok_3.Kind;
+                        fieldName_2 = ((matchValue_18.tag === 4) ? matchValue_18.fields[0] : "");
+                        if (!addToSet(fieldName_2, seen_1)) {
+                            throw new ParseException(new ParseError(concat("Duplicate field \'", fieldName_2, "\' in structural record type pattern"), nameTok_3.Span));
+                        }
+                        TokenStream__Expect_77B9EE56(stream, new TokenKind(35, []), "Expected \':\' in structural record type pattern");
+                        const fieldType_2 = parseTypeRef();
+                        void (fields_3.push([fieldName_2, fieldType_2]));
+                    };
+                    parseTypeField();
+                    while (TokenStream__Match_5CEB78CD(stream, new TokenKind(33, []))) {
+                        if (!equals(TokenStream__Peek(stream).Kind, new TokenKind(26, []))) {
+                            parseTypeField();
+                        }
+                    }
+                    TokenStream__Expect_77B9EE56(stream, new TokenKind(26, []), "Expected \'|\' in structural record type pattern");
+                    const rbIndex_2 = TokenStream__get_Index(stream) | 0;
+                    const rb_2 = TokenStream__Expect_77B9EE56(stream, new TokenKind(44, []), "Expected \'}\' in structural record type pattern");
+                    if (!hasNonLayoutTokenBeforeOnSameLine(rbIndex_2, rb_2.Span.Start.Line)) {
+                        throw new ParseException(new ParseError("Closing \'}\' cannot be on its own line; keep it with the last entry", rb_2.Span));
+                    }
+                    return new Pattern(11, [new TypeRef(5, [toList(fields_3)]), mkSpanFrom(lb_2.Span, rb_2.Span)]);
+                }
+                else if (equals(TokenStream__Peek(stream).Kind, new TokenKind(29, []))) {
+                    const clauses = [];
+                    const parseClause = () => {
+                        TokenStream__Expect_77B9EE56(stream, new TokenKind(29, []), "Expected \'[\' in map pattern key");
+                        const keyPattern = parsePatternCons();
+                        TokenStream__Expect_77B9EE56(stream, new TokenKind(30, []), "Expected \']\' in map pattern key");
+                        TokenStream__SkipNewlines(stream);
+                        TokenStream__Expect_77B9EE56(stream, new TokenKind(25, []), "Expected \'=\' after map key pattern");
+                        const valuePattern = parsePatternCons();
+                        void (clauses.push([keyPattern, valuePattern]));
+                    };
+                    parseClause();
+                    TokenStream__SkipNewlines(stream);
+                    let tailPattern = undefined;
+                    let donePattern = false;
+                    while (!donePattern) {
+                        if (TokenStream__Match_5CEB78CD(stream, new TokenKind(33, []))) {
+                            TokenStream__SkipNewlines(stream);
+                            if (equals(TokenStream__Peek(stream).Kind, new TokenKind(37, []))) {
+                                TokenStream__Next(stream);
+                                tailPattern = parsePatternCons();
+                                TokenStream__SkipNewlines(stream);
+                                donePattern = true;
+                            }
+                            else if (equals(TokenStream__Peek(stream).Kind, new TokenKind(29, []))) {
+                                parseClause();
+                                TokenStream__SkipNewlines(stream);
+                            }
+                            else if (equals(TokenStream__Peek(stream).Kind, new TokenKind(44, []))) {
+                                donePattern = true;
+                            }
+                            else {
+                                throw new ParseException(new ParseError("Expected map pattern clause or \'..tail\'", TokenStream__Peek(stream).Span));
+                            }
+                        }
+                        else if (equals(TokenStream__Peek(stream).Kind, new TokenKind(37, []))) {
+                            TokenStream__Next(stream);
+                            tailPattern = parsePatternCons();
+                            TokenStream__SkipNewlines(stream);
+                            donePattern = true;
+                        }
+                        else if (equals(TokenStream__Peek(stream).Kind, new TokenKind(29, []))) {
+                            parseClause();
+                            TokenStream__SkipNewlines(stream);
+                        }
+                        else {
+                            donePattern = true;
+                        }
+                    }
+                    const rbIndex_3 = TokenStream__get_Index(stream) | 0;
+                    const rb_3 = TokenStream__Expect_77B9EE56(stream, new TokenKind(44, []), "Expected \'}\' in map pattern");
+                    if (!hasNonLayoutTokenBeforeOnSameLine(rbIndex_3, rb_3.Span.Start.Line)) {
+                        throw new ParseException(new ParseError("Closing \'}\' cannot be on its own line; keep it with the last entry", rb_3.Span));
+                    }
+                    return new Pattern(7, [toList(clauses), tailPattern, mkSpanFrom(lb_2.Span, rb_3.Span)]);
+                }
+                else {
+                    const mark = TokenStream__Mark(stream) | 0;
+                    let isTypeRefPattern;
+                    try {
+                        TokenStream__ExpectIdent_Z721C83C5(stream, "Expected field name in record type pattern");
+                        TokenStream__SkipNewlines(stream);
+                        isTypeRefPattern = TokenStream__Match_5CEB78CD(stream, new TokenKind(35, []));
+                    }
+                    catch (matchValue_19) {
+                        isTypeRefPattern = false;
+                    }
+                    TokenStream__Restore_Z524259A4(stream, mark);
+                    if (isTypeRefPattern) {
+                        const fields_4 = [];
+                        const seen_2 = new Set([]);
+                        const parseTypeField_1 = () => {
+                            TokenStream__SkipNewlines(stream);
+                            const nameTok_4 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected field name in record type pattern");
+                            let name_5;
+                            const matchValue_20 = nameTok_4.Kind;
+                            name_5 = ((matchValue_20.tag === 4) ? matchValue_20.fields[0] : "");
+                            if (!addToSet(name_5, seen_2)) {
+                                throw new ParseException(new ParseError(concat("Duplicate field \'", name_5, "\' in record type pattern"), nameTok_4.Span));
+                            }
+                            TokenStream__SkipNewlines(stream);
+                            TokenStream__Expect_77B9EE56(stream, new TokenKind(35, []), "Expected \':\' in record type pattern field");
+                            const t_5 = parseTypeRef();
+                            void (fields_4.push([name_5, t_5]));
+                        };
+                        parseTypeField_1();
+                        while (TokenStream__Match_5CEB78CD(stream, new TokenKind(33, []))) {
+                            if (!equals(TokenStream__Peek(stream).Kind, new TokenKind(44, []))) {
+                                parseTypeField_1();
+                            }
+                        }
+                        const rbIndex_4 = TokenStream__get_Index(stream) | 0;
+                        const rb_4 = TokenStream__Expect_77B9EE56(stream, new TokenKind(44, []), "Expected \'}\' in record type pattern");
+                        if (!hasNonLayoutTokenBeforeOnSameLine(rbIndex_4, rb_4.Span.Start.Line)) {
+                            throw new ParseException(new ParseError("Closing \'}\' cannot be on its own line; keep it with the last field", rb_4.Span));
+                        }
+                        return new Pattern(11, [new TypeRef(4, [toList(fields_4)]), mkSpanFrom(lb_2.Span, rb_4.Span)]);
+                    }
+                    else {
+                        const fields_5 = [];
+                        const seen_3 = new Set([]);
+                        const parseField_2 = () => {
+                            TokenStream__SkipNewlines(stream);
+                            const nameTok_5 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected field name in record pattern");
+                            let name_6;
+                            const matchValue_21 = nameTok_5.Kind;
+                            name_6 = ((matchValue_21.tag === 4) ? matchValue_21.fields[0] : "");
+                            if (!addToSet(name_6, seen_3)) {
+                                throw new ParseException(new ParseError(concat("Duplicate field \'", name_6, "\' in record pattern"), nameTok_5.Span));
+                            }
+                            TokenStream__SkipNewlines(stream);
+                            TokenStream__Expect_77B9EE56(stream, new TokenKind(25, []), "Expected \'=\' in record pattern field");
+                            const p_3 = parsePatternCons();
+                            void (fields_5.push([name_6, p_3]));
+                        };
+                        parseField_2();
+                        while (TokenStream__Match_5CEB78CD(stream, new TokenKind(33, []))) {
+                            if (!equals(TokenStream__Peek(stream).Kind, new TokenKind(44, []))) {
+                                parseField_2();
+                            }
+                        }
+                        const rbIndex_5 = TokenStream__get_Index(stream) | 0;
+                        const rb_5 = TokenStream__Expect_77B9EE56(stream, new TokenKind(44, []), "Expected \'}\' in record pattern");
+                        if (!hasNonLayoutTokenBeforeOnSameLine(rbIndex_5, rb_5.Span.Start.Line)) {
+                            throw new ParseException(new ParseError("Closing \'}\' cannot be on its own line; keep it with the last field", rb_5.Span));
+                        }
+                        return new Pattern(6, [toList(fields_5), mkSpanFrom(lb_2.Span, rb_5.Span)]);
+                    }
+                }
+            }
+            default:
+                throw new ParseException(new ParseError("Unexpected token in pattern", t_1.Span));
+        }
+    };
+    const parsePatternCons = () => {
+        const left_1 = parsePattern();
+        if (TokenStream__Match_5CEB78CD(stream, new TokenKind(61, []))) {
+            const right_1 = parsePatternCons();
+            return new Pattern(4, [left_1, right_1, mkSpanFrom(Ast_spanOfPattern(left_1), Ast_spanOfPattern(right_1))]);
+        }
+        else {
+            return left_1;
+        }
+    };
+    const parseEntryExpr = () => {
+        const previousIndentedApplication = allowIndentedApplication;
+        const previousBinaryNewlineSkipping = allowBinaryNewlineSkipping;
+        allowIndentedApplication = false;
+        allowBinaryNewlineSkipping = false;
+        try {
+            let progress_1 = true;
+            while (progress_1) {
+                progress_1 = false;
+                while (TokenStream__Match_5CEB78CD(stream, new TokenKind(1, []))) {
+                    progress_1 = true;
+                }
+                while (TokenStream__Match_5CEB78CD(stream, new TokenKind(2, []))) {
+                    progress_1 = true;
+                }
+            }
+            return parseExpr();
+        }
+        finally {
+            allowIndentedApplication = previousIndentedApplication;
+            allowBinaryNewlineSkipping = previousBinaryNewlineSkipping;
+        }
+    };
+    const parsePrimary = () => {
+        let matchValue_29, matchValue_30;
+        TokenStream__SkipNewlines(stream);
+        const t_6 = TokenStream__Peek(stream);
+        const matchValue_22 = t_6.Kind;
+        switch (matchValue_22.tag) {
+            case 5:
+            case 6:
+            case 7:
+            case 9: {
+                const t_7 = TokenStream__Next(stream);
+                return new Expr(1, [parseLiteral(t_7), t_7.Span]);
+            }
+            case 8: {
+                const raw = matchValue_22.fields[0];
+                const span = TokenStream__Next(stream).Span;
+                const parts = [];
+                const text = StringBuilder_$ctor();
+                const flushText = () => {
+                    if (StringBuilder__get_Length(text) > 0) {
+                        void (parts.push(new InterpolatedPart(0, [toString(text)])));
+                        StringBuilder__Clear(text);
+                    }
+                };
+                let i_1 = 0;
+                while (i_1 < raw.length) {
+                    let parsed;
+                    const matchValue = raw[i_1];
+                    let matchResult_2, ch_1;
+                    switch (matchValue) {
+                        case "\\": {
+                            if ((i_1 + 1) < raw.length) {
+                                matchResult_2 = 4;
+                            }
+                            else {
+                                matchResult_2 = 5;
+                                ch_1 = matchValue;
+                            }
+                            break;
+                        }
+                        case "{": {
+                            if (((i_1 + 1) < raw.length) && (raw[i_1 + 1] === "{")) {
+                                matchResult_2 = 0;
+                            }
+                            else {
+                                matchResult_2 = 2;
+                            }
+                            break;
+                        }
+                        case "}": {
+                            if (((i_1 + 1) < raw.length) && (raw[i_1 + 1] === "}")) {
+                                matchResult_2 = 1;
+                            }
+                            else {
+                                matchResult_2 = 3;
+                            }
+                            break;
+                        }
+                        default: {
+                            matchResult_2 = 5;
+                            ch_1 = matchValue;
+                        }
+                    }
+                    switch (matchResult_2) {
+                        case 0: {
+                            StringBuilder__Append_244C7CD6(text, "{");
+                            i_1 = ((i_1 + 2) | 0);
+                            break;
+                        }
+                        case 1: {
+                            StringBuilder__Append_244C7CD6(text, "}");
+                            i_1 = ((i_1 + 2) | 0);
+                            break;
+                        }
+                        case 2: {
+                            flushText();
+                            let patternInput;
+                            const s = raw;
+                            const start = (i_1 + 1) | 0;
+                            let i = start;
+                            let depth = 1;
+                            let inString = false;
+                            let escaped = false;
+                            while ((i < s.length) && (depth > 0)) {
+                                const ch = s[i];
+                                if (inString) {
+                                    if (escaped) {
+                                        escaped = false;
+                                        i = ((i + 1) | 0);
+                                    }
+                                    else {
+                                        switch (ch) {
+                                            case "\"": {
+                                                inString = false;
+                                                i = ((i + 1) | 0);
+                                                break;
+                                            }
+                                            case "\\": {
+                                                escaped = true;
+                                                i = ((i + 1) | 0);
+                                                break;
+                                            }
+                                            default:
+                                                i = ((i + 1) | 0);
+                                        }
+                                    }
+                                }
+                                else {
+                                    switch (ch) {
+                                        case "\"": {
+                                            inString = true;
+                                            i = ((i + 1) | 0);
+                                            break;
+                                        }
+                                        case "{": {
+                                            depth = ((depth + 1) | 0);
+                                            i = ((i + 1) | 0);
+                                            break;
+                                        }
+                                        case "}": {
+                                            depth = ((depth - 1) | 0);
+                                            i = ((i + 1) | 0);
+                                            break;
+                                        }
+                                        default:
+                                            i = ((i + 1) | 0);
+                                    }
+                                }
+                            }
+                            if (depth !== 0) {
+                                throw new ParseException(new ParseError("Unterminated interpolation placeholder", span));
+                            }
+                            const exprText_1 = substring(s, start, (i - start) - 1);
+                            if (isNullOrWhiteSpace(exprText_1)) {
+                                throw new ParseException(new ParseError("Interpolation placeholder cannot be empty", span));
+                            }
+                            patternInput = [(parsed = parseProgramWithSourceName(undefined, exprText_1), !isEmpty(parsed) ? ((head_1(parsed).tag === 5) ? (isEmpty(tail_1(parsed)) ? head_1(parsed).fields[0] : (() => {
+                                throw new ParseException(new ParseError("Interpolation placeholders must contain a single expression", TokenStream__Peek(stream).Span));
+                            })()) : (() => {
+                                throw new ParseException(new ParseError("Interpolation placeholders must contain a single expression", TokenStream__Peek(stream).Span));
+                            })()) : (() => {
+                                throw new ParseException(new ParseError("Interpolation placeholders must contain a single expression", TokenStream__Peek(stream).Span));
+                            })()), i];
+                            void (parts.push(new InterpolatedPart(1, [patternInput[0]])));
+                            i_1 = (patternInput[1] | 0);
+                            break;
+                        }
+                        case 3: {
+                            throw new ParseException(new ParseError("Unescaped \'}\' in interpolated string", span));
+                            break;
+                        }
+                        case 4: {
+                            const next = raw[i_1 + 1];
+                            switch (next) {
+                                case "\"": {
+                                    StringBuilder__Append_244C7CD6(text, "\"");
+                                    break;
+                                }
+                                case "\\": {
+                                    StringBuilder__Append_244C7CD6(text, "\\");
+                                    break;
+                                }
+                                case "n": {
+                                    StringBuilder__Append_244C7CD6(text, "\n");
+                                    break;
+                                }
+                                case "t": {
+                                    StringBuilder__Append_244C7CD6(text, "\t");
+                                    break;
+                                }
+                                default:
+                                    StringBuilder__Append_244C7CD6(text, next);
+                            }
+                            i_1 = ((i_1 + 2) | 0);
+                            break;
+                        }
+                        case 5: {
+                            StringBuilder__Append_244C7CD6(text, ch_1);
+                            i_1 = ((i_1 + 1) | 0);
+                            break;
+                        }
+                    }
+                }
+                flushText();
+                return new Expr(30, [(parts.length === 0) ? singleton(new InterpolatedPart(0, [""])) : toList(parts), span]);
+            }
+            case 4: {
+                const name_7 = matchValue_22.fields[0];
+                const t_9 = TokenStream__Next(stream);
+                switch (name_7) {
+                    case "None":
+                        return new Expr(27, [t_9.Span]);
+                    case "Some": {
+                        const arg = parsePrimary();
+                        return new Expr(26, [arg, mkSpanFrom(t_9.Span, Ast_spanOfExpr(arg))]);
+                    }
+                    default:
+                        return new Expr(2, [name_7, t_9.Span]);
+                }
+            }
+            case 27: {
+                const lp_2 = TokenStream__Next(stream);
+                if (equals(TokenStream__Peek(stream).Kind, new TokenKind(28, []))) {
+                    return new Expr(0, [mkSpanFrom(lp_2.Span, TokenStream__Next(stream).Span)]);
+                }
+                else {
+                    const first_4 = parseExpr();
+                    if (TokenStream__Match_5CEB78CD(stream, new TokenKind(34, []))) {
+                        const elements_2 = [];
+                        void (elements_2.push(first_4));
+                        void (elements_2.push(parseExpr()));
+                        while (TokenStream__Match_5CEB78CD(stream, new TokenKind(34, []))) {
+                            void (elements_2.push(parseExpr()));
+                        }
+                        const rp_4 = TokenStream__Expect_77B9EE56(stream, new TokenKind(28, []), "Expected \')\' after tuple expression");
+                        return new Expr(15, [toList(elements_2), mkSpanFrom(lp_2.Span, rp_4.Span)]);
+                    }
+                    else {
+                        return new Expr(3, [first_4, mkSpanFrom(lp_2.Span, TokenStream__Expect_77B9EE56(stream, new TokenKind(28, []), "Expected \')\' after expression").Span)]);
+                    }
+                }
+            }
+            case 29: {
+                const lbIndex_3 = TokenStream__get_Index(stream) | 0;
+                const lb_3 = TokenStream__Next(stream);
+                if (!hasNonLayoutTokenAfterOnSameLine(lbIndex_3, lb_3.Span.Start.Line)) {
+                    throw new ParseException(new ParseError("Opening \'[\' cannot be on its own line; keep it with the first element", lb_3.Span));
+                }
+                consumeLayoutSeparators();
+                if (TokenStream__Match_5CEB78CD(stream, new TokenKind(30, []))) {
+                    return new Expr(13, [empty(), mkSpanFrom(lb_3.Span, lb_3.Span)]);
+                }
+                else {
+                    const first_5 = parseEntryExpr();
+                    if (TokenStream__Match_5CEB78CD(stream, new TokenKind(37, []))) {
+                        const second = parseEntryExpr();
+                        if (TokenStream__Match_5CEB78CD(stream, new TokenKind(33, [])) ? true : TokenStream__Match_5CEB78CD(stream, new TokenKind(37, []))) {
+                            throw new ParseException(new ParseError("Invalid range syntax", TokenStream__Peek(stream).Span));
+                        }
+                        return new Expr(14, [first_5, second, mkSpanFrom(lb_3.Span, TokenStream__Expect_77B9EE56(stream, new TokenKind(30, []), "Expected \']\' in range expression").Span)]);
+                    }
+                    else {
+                        const elements_3 = [];
+                        void (elements_3.push(first_5));
+                        let keepParsing = true;
+                        while (keepParsing) {
+                            if ((TokenStream__Match_5CEB78CD(stream, new TokenKind(33, [])) ? ((void consumeLayoutSeparators(), true)) : consumeLayoutSeparators()) && !equals(TokenStream__Peek(stream).Kind, new TokenKind(30, []))) {
+                                void (elements_3.push(parseEntryExpr()));
+                            }
+                            else {
+                                keepParsing = false;
+                            }
+                        }
+                        const rbIndex_6 = TokenStream__get_Index(stream) | 0;
+                        const rb_7 = TokenStream__Expect_77B9EE56(stream, new TokenKind(30, []), "Expected \']\' in list literal");
+                        if (!hasNonLayoutTokenBeforeOnSameLine(rbIndex_6, rb_7.Span.Start.Line)) {
+                            throw new ParseException(new ParseError("Closing \']\' cannot be on its own line; keep it with the last element", rb_7.Span));
+                        }
+                        return new Expr(13, [toList(elements_3), mkSpanFrom(lb_3.Span, rb_7.Span)]);
+                    }
+                }
+            }
+            case 43: {
+                const lbIndex_4 = TokenStream__get_Index(stream) | 0;
+                const lb_4 = TokenStream__Next(stream);
+                if (!hasNonLayoutTokenAfterOnSameLine(lbIndex_4, lb_4.Span.Start.Line)) {
+                    throw new ParseException(new ParseError("Opening \'{\' cannot be on its own line; keep it with the first entry", lb_4.Span));
+                }
+                consumeLayoutSeparators();
+                if (TokenStream__Match_5CEB78CD(stream, new TokenKind(44, []))) {
+                    return new Expr(18, [empty(), mkSpanFrom(lb_4.Span, lb_4.Span)]);
+                }
+                else if (TokenStream__Match_5CEB78CD(stream, new TokenKind(26, []))) {
+                    if (equals(TokenStream__Peek(stream).Kind, new TokenKind(26, []))) {
+                        throw new ParseException(new ParseError("Structural record literal must define at least one field", TokenStream__Peek(stream).Span));
+                    }
+                    const mark_1 = TokenStream__Mark(stream) | 0;
+                    let matchValue_24;
+                    const baseExpr = parseExpr();
+                    TokenStream__SkipNewlines(stream);
+                    if (!TokenStream__Match_5CEB78CD(stream, new TokenKind(15, []))) {
+                        TokenStream__Restore_Z524259A4(stream, mark_1);
+                        matchValue_24 = undefined;
+                    }
+                    else {
+                        const updates = [];
+                        const parseUpdateField = () => {
+                            let name_8;
+                            const matchValue_23 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected field name in structural record update").Kind;
+                            name_8 = ((matchValue_23.tag === 4) ? matchValue_23.fields[0] : "");
+                            TokenStream__SkipNewlines(stream);
+                            TokenStream__Expect_77B9EE56(stream, new TokenKind(25, []), "Expected \'=\' in structural record update field");
+                            const value_40 = parseEntryExpr();
+                            void (updates.push([name_8, value_40]));
+                        };
+                        parseUpdateField();
+                        let keepParsing_1 = true;
+                        while (keepParsing_1) {
+                            if ((TokenStream__Match_5CEB78CD(stream, new TokenKind(33, [])) ? ((void consumeLayoutSeparators(), true)) : consumeLayoutSeparators()) && !equals(TokenStream__Peek(stream).Kind, new TokenKind(26, []))) {
+                                parseUpdateField();
+                            }
+                            else {
+                                keepParsing_1 = false;
+                            }
+                        }
+                        TokenStream__Expect_77B9EE56(stream, new TokenKind(26, []), "Expected \'|\' in structural record update");
+                        const rbIndex_7 = TokenStream__get_Index(stream) | 0;
+                        const rb_8 = TokenStream__Expect_77B9EE56(stream, new TokenKind(44, []), "Expected \'}\' in structural record update");
+                        if (!hasNonLayoutTokenBeforeOnSameLine(rbIndex_7, rb_8.Span.Start.Line)) {
+                            throw new ParseException(new ParseError("Closing \'}\' cannot be on its own line; keep it with the last entry", rb_8.Span));
+                        }
+                        matchValue_24 = (new Expr(20, [baseExpr, toList(updates), mkSpanFrom(lb_4.Span, rb_8.Span)]));
+                    }
+                    if (matchValue_24 == null) {
+                        const fields_6 = [];
+                        const parseField_3 = () => {
+                            let name_9;
+                            const matchValue_25 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected field name in structural record literal").Kind;
+                            name_9 = ((matchValue_25.tag === 4) ? matchValue_25.fields[0] : "");
+                            TokenStream__SkipNewlines(stream);
+                            TokenStream__Expect_77B9EE56(stream, new TokenKind(25, []), "Expected \'=\' in structural record field");
+                            const value_44 = parseEntryExpr();
+                            void (fields_6.push([name_9, value_44]));
+                        };
+                        parseField_3();
+                        let keepParsing_2 = true;
+                        while (keepParsing_2) {
+                            if ((TokenStream__Match_5CEB78CD(stream, new TokenKind(33, [])) ? ((void consumeLayoutSeparators(), true)) : consumeLayoutSeparators()) && !equals(TokenStream__Peek(stream).Kind, new TokenKind(26, []))) {
+                                parseField_3();
+                            }
+                            else {
+                                keepParsing_2 = false;
+                            }
+                        }
+                        TokenStream__Expect_77B9EE56(stream, new TokenKind(26, []), "Expected \'|\' in structural record literal");
+                        const rbIndex_8 = TokenStream__get_Index(stream) | 0;
+                        const rb_9 = TokenStream__Expect_77B9EE56(stream, new TokenKind(44, []), "Expected \'}\' in structural record literal");
+                        if (!hasNonLayoutTokenBeforeOnSameLine(rbIndex_8, rb_9.Span.Start.Line)) {
+                            throw new ParseException(new ParseError("Closing \'}\' cannot be on its own line; keep it with the last entry", rb_9.Span));
+                        }
+                        return new Expr(17, [toList(fields_6), mkSpanFrom(lb_4.Span, rb_9.Span)]);
+                    }
+                    else {
+                        return matchValue_24;
+                    }
+                }
+                else if (equals(TokenStream__Peek(stream).Kind, new TokenKind(29, [])) ? true : equals(TokenStream__Peek(stream).Kind, new TokenKind(37, []))) {
+                    const parseMapEntry = () => {
+                        if (TokenStream__Match_5CEB78CD(stream, new TokenKind(37, []))) {
+                            return new MapEntry(1, [parseEntryExpr()]);
+                        }
+                        else {
+                            TokenStream__Expect_77B9EE56(stream, new TokenKind(29, []), "Expected \'[\' in map entry key");
+                            const keyExpr = parseExpr();
+                            TokenStream__Expect_77B9EE56(stream, new TokenKind(30, []), "Expected \']\' after map entry key");
+                            TokenStream__SkipNewlines(stream);
+                            TokenStream__Expect_77B9EE56(stream, new TokenKind(25, []), "Expected \'=\' in map entry");
+                            return new MapEntry(0, [keyExpr, parseEntryExpr()]);
+                        }
+                    };
+                    const entries = [];
+                    void (entries.push(parseMapEntry()));
+                    let keepParsing_3 = true;
+                    while (keepParsing_3) {
+                        if (TokenStream__Match_5CEB78CD(stream, new TokenKind(33, [])) ? ((void consumeLayoutSeparators(), true)) : consumeLayoutSeparators()) {
+                            if (equals(TokenStream__Peek(stream).Kind, new TokenKind(44, []))) {
+                                keepParsing_3 = false;
+                            }
+                            else {
+                                void (entries.push(parseMapEntry()));
+                            }
+                        }
+                        else if (equals(TokenStream__Peek(stream).Kind, new TokenKind(44, []))) {
+                            keepParsing_3 = false;
+                        }
+                        else {
+                            throw new ParseException(new ParseError("Expected \';\', newline, or \'}\' in map literal", TokenStream__Peek(stream).Span));
+                        }
+                    }
+                    const rbIndex_9 = TokenStream__get_Index(stream) | 0;
+                    const rb_10 = TokenStream__Expect_77B9EE56(stream, new TokenKind(44, []), "Expected \'}\' in map literal");
+                    if (!hasNonLayoutTokenBeforeOnSameLine(rbIndex_9, rb_10.Span.Start.Line)) {
+                        throw new ParseException(new ParseError("Closing \'}\' cannot be on its own line; keep it with the last entry", rb_10.Span));
+                    }
+                    return new Expr(18, [toList(entries), mkSpanFrom(lb_4.Span, rb_10.Span)]);
+                }
+                else {
+                    const mark_2 = TokenStream__Mark(stream) | 0;
+                    let matchValue_27;
+                    const baseExpr_1 = parseExpr();
+                    TokenStream__SkipNewlines(stream);
+                    if (!TokenStream__Match_5CEB78CD(stream, new TokenKind(15, []))) {
+                        TokenStream__Restore_Z524259A4(stream, mark_2);
+                        matchValue_27 = undefined;
+                    }
+                    else {
+                        const updates_1 = [];
+                        const parseUpdateField_1 = () => {
+                            let name_10;
+                            const matchValue_26 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected field name in record update").Kind;
+                            name_10 = ((matchValue_26.tag === 4) ? matchValue_26.fields[0] : "");
+                            TokenStream__SkipNewlines(stream);
+                            TokenStream__Expect_77B9EE56(stream, new TokenKind(25, []), "Expected \'=\' in record update field");
+                            const value_53 = parseEntryExpr();
+                            void (updates_1.push([name_10, value_53]));
+                        };
+                        parseUpdateField_1();
+                        let keepParsing_4 = true;
+                        while (keepParsing_4) {
+                            if ((TokenStream__Match_5CEB78CD(stream, new TokenKind(33, [])) ? ((void consumeLayoutSeparators(), true)) : consumeLayoutSeparators()) && !equals(TokenStream__Peek(stream).Kind, new TokenKind(44, []))) {
+                                parseUpdateField_1();
+                            }
+                            else {
+                                keepParsing_4 = false;
+                            }
+                        }
+                        const rbIndex_10 = TokenStream__get_Index(stream) | 0;
+                        const rb_11 = TokenStream__Expect_77B9EE56(stream, new TokenKind(44, []), "Expected \'}\' in record update");
+                        if (!hasNonLayoutTokenBeforeOnSameLine(rbIndex_10, rb_11.Span.Start.Line)) {
+                            throw new ParseException(new ParseError("Closing \'}\' cannot be on its own line; keep it with the last entry", rb_11.Span));
+                        }
+                        matchValue_27 = (new Expr(19, [baseExpr_1, toList(updates_1), mkSpanFrom(lb_4.Span, rb_11.Span)]));
+                    }
+                    if (matchValue_27 == null) {
+                        const fields_7 = [];
+                        const parseField_4 = () => {
+                            let name_11;
+                            const matchValue_28 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected field name in record literal").Kind;
+                            name_11 = ((matchValue_28.tag === 4) ? matchValue_28.fields[0] : "");
+                            TokenStream__SkipNewlines(stream);
+                            TokenStream__Expect_77B9EE56(stream, new TokenKind(25, []), "Expected \'=\' in record field");
+                            const value_56 = parseEntryExpr();
+                            void (fields_7.push([name_11, value_56]));
+                        };
+                        parseField_4();
+                        let keepParsing_5 = true;
+                        while (keepParsing_5) {
+                            if ((TokenStream__Match_5CEB78CD(stream, new TokenKind(33, [])) ? ((void consumeLayoutSeparators(), true)) : consumeLayoutSeparators()) && !equals(TokenStream__Peek(stream).Kind, new TokenKind(44, []))) {
+                                parseField_4();
+                            }
+                            else {
+                                keepParsing_5 = false;
+                            }
+                        }
+                        const rbIndex_11 = TokenStream__get_Index(stream) | 0;
+                        const rb_12 = TokenStream__Expect_77B9EE56(stream, new TokenKind(44, []), "Expected \'}\' in record literal");
+                        if (!hasNonLayoutTokenBeforeOnSameLine(rbIndex_11, rb_12.Span.Start.Line)) {
+                            throw new ParseException(new ParseError("Closing \'}\' cannot be on its own line; keep it with the last entry", rb_12.Span));
+                        }
+                        return new Expr(16, [toList(fields_7), mkSpanFrom(lb_4.Span, rb_12.Span)]);
+                    }
+                    else {
+                        return matchValue_27;
+                    }
+                }
+            }
+            case 10:
+                return parseLetExpr();
+            case 13:
+                return parseLambda();
+            case 17:
+                return parseIf();
+            case 21: {
+                const raiseTok = TokenStream__Next(stream);
+                const value_58 = parsePrimary();
+                return new Expr(7, [value_58, mkSpanFrom(raiseTok.Span, Ast_spanOfExpr(value_58))]);
+            }
+            case 22:
+                return parseFor();
+            case 14:
+                return parseMatch();
+            case 46: {
+                const t_10 = TokenStream__Next(stream);
+                const nameTok_10 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected type name after \'typeof\'");
+                return new Expr(28, [(matchValue_29 = nameTok_10.Kind, (matchValue_29.tag === 4) ? matchValue_29.fields[0] : ""), mkSpanFrom(t_10.Span, nameTok_10.Span)]);
+            }
+            case 47: {
+                const t_11 = TokenStream__Next(stream);
+                const nameTok_11 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected identifier after \'nameof\'");
+                return new Expr(29, [(matchValue_30 = nameTok_11.Kind, (matchValue_30.tag === 4) ? matchValue_30.fields[0] : ""), mkSpanFrom(t_11.Span, nameTok_11.Span)]);
+            }
+            case 2:
+                throw new ParseException(new ParseError("Indentation error: unexpected indent in expression", t_6.Span));
+            case 3:
+                throw new ParseException(new ParseError("Indentation error: unexpected dedent in expression", t_6.Span));
+            default:
+                throw new ParseException(new ParseError("Unexpected token in expression", t_6.Span));
+        }
+    };
+    const parsePostfix = () => {
+        let expr_3 = parsePrimary();
+        let keepGoing_1 = true;
+        while (keepGoing_1) {
+            if (TokenStream__Match_5CEB78CD(stream, new TokenKind(36, []))) {
+                const fieldTok_1 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected field name after \'.\'");
+                let fieldName_3;
+                const matchValue_31 = fieldTok_1.Kind;
+                fieldName_3 = ((matchValue_31.tag === 4) ? matchValue_31.fields[0] : "");
+                expr_3 = (new Expr(21, [expr_3, fieldName_3, mkSpanFrom(Ast_spanOfExpr(expr_3), fieldTok_1.Span)]));
+            }
+            else if (equals(TokenStream__Peek(stream).Kind, new TokenKind(29, []))) {
+                const lb_5 = TokenStream__Peek(stream);
+                const targetSpan = Ast_spanOfExpr(expr_3);
+                if (((lb_5.Span.Start.Line === targetSpan.End.Line) && (lb_5.Span.Start.Column === targetSpan.End.Column)) && !equals(TokenStream__PeekAt_Z524259A4(stream, 1).Kind, new TokenKind(30, []))) {
+                    TokenStream__Next(stream);
+                    const keyExpr_1 = parseExpr();
+                    const rb_13 = TokenStream__Expect_77B9EE56(stream, new TokenKind(30, []), "Expected \']\' after index expression");
+                    expr_3 = (new Expr(22, [expr_3, keyExpr_1, mkSpanFrom(targetSpan, rb_13.Span)]));
+                }
+                else {
+                    keepGoing_1 = false;
+                }
+            }
+            else {
+                keepGoing_1 = false;
+            }
+        }
+        return expr_3;
+    };
+    const parseApplication = () => {
+        let expr_4 = parsePostfix();
+        let keepGoing_2 = true;
+        let hasMultilineArgBlock = false;
+        while (keepGoing_2) {
+            const next_2 = TokenStream__Peek(stream);
+            if ((next_2.Span.Start.Line === Ast_spanOfExpr(expr_4).End.Line) && isStartAtom(next_2.Kind)) {
+                const arg_1 = parsePostfix();
+                expr_4 = (new Expr(5, [expr_4, arg_1, mkSpanFrom(Ast_spanOfExpr(expr_4), Ast_spanOfExpr(arg_1))]));
+            }
+            else {
+                const mark_3 = TokenStream__Mark(stream) | 0;
+                let sawNewline_3 = false;
+                while (TokenStream__Match_5CEB78CD(stream, new TokenKind(1, []))) {
+                    sawNewline_3 = true;
+                }
+                if (sawNewline_3 && allowIndentedApplication) {
+                    if (TokenStream__Match_5CEB78CD(stream, new TokenKind(2, []))) {
+                        hasMultilineArgBlock = true;
+                    }
+                    const candidate = TokenStream__Peek(stream);
+                    if ((candidate.Span.Start.Column > Ast_spanOfExpr(expr_4).Start.Column) && isStartAtom(candidate.Kind)) {
+                        const arg_2 = parsePostfix();
+                        expr_4 = (new Expr(5, [expr_4, arg_2, mkSpanFrom(Ast_spanOfExpr(expr_4), Ast_spanOfExpr(arg_2))]));
+                    }
+                    else if (hasMultilineArgBlock && equals(candidate.Kind, new TokenKind(3, []))) {
+                        TokenStream__Next(stream);
+                        hasMultilineArgBlock = false;
+                        keepGoing_2 = false;
+                    }
+                    else {
+                        TokenStream__Restore_Z524259A4(stream, mark_3);
+                        keepGoing_2 = false;
+                    }
+                }
+                else {
+                    TokenStream__Restore_Z524259A4(stream, mark_3);
+                    keepGoing_2 = false;
+                }
+            }
+        }
+        return expr_4;
+    };
+    const parseBinary = (minPrec) => {
+        let left_2 = parseApplication();
+        const precedence = (op) => {
+            switch (op.tag) {
+                case 51:
+                case 52:
+                case 53:
+                    return 7;
+                case 49:
+                case 50:
+                    return 6;
+                case 62:
+                    return 5;
+                case 61:
+                    return 4;
+                case 25:
+                case 54:
+                case 55:
+                case 56:
+                case 57:
+                    return 3;
+                case 58:
+                    return 2;
+                case 59:
+                    return 1;
+                case 60:
+                    return 0;
+                default:
+                    return -1;
+            }
+        };
+        let looping = true;
+        while (looping) {
+            let op_1;
+            if (allowBinaryNewlineSkipping) {
+                let continueLoop = true;
+                while (continueLoop) {
+                    TokenStream__SkipNewlines(stream);
+                    const mark_4 = TokenStream__Mark(stream) | 0;
+                    if (TokenStream__Match_5CEB78CD(stream, new TokenKind(3, []))) {
+                        if (precedence(TokenStream__Peek(stream).Kind) >= minPrec) {
+                        }
+                        else {
+                            TokenStream__Restore_Z524259A4(stream, mark_4);
+                            continueLoop = false;
+                        }
+                    }
+                    else {
+                        TokenStream__Restore_Z524259A4(stream, mark_4);
+                        continueLoop = false;
+                    }
+                }
+            }
+            const prec = precedence(TokenStream__Peek(stream).Kind) | 0;
+            if (prec >= minPrec) {
+                const opTok = TokenStream__Next(stream);
+                const right_2 = parseBinary(prec + 1);
+                left_2 = (new Expr(25, [(op_1 = opTok.Kind, (op_1.tag === 49) ? "+" : ((op_1.tag === 50) ? "-" : ((op_1.tag === 51) ? "*" : ((op_1.tag === 52) ? "/" : ((op_1.tag === 53) ? "%" : ((op_1.tag === 25) ? "=" : ((op_1.tag === 54) ? "<" : ((op_1.tag === 55) ? ">" : ((op_1.tag === 56) ? "<=" : ((op_1.tag === 57) ? ">=" : ((op_1.tag === 58) ? "&&" : ((op_1.tag === 59) ? "||" : ((op_1.tag === 60) ? "|>" : ((op_1.tag === 61) ? "::" : ((op_1.tag === 62) ? "@" : "?"))))))))))))))), left_2, right_2, mkSpanFrom(Ast_spanOfExpr(left_2), Ast_spanOfExpr(right_2))]));
+            }
+            else {
+                looping = false;
+            }
+        }
+        return left_2;
+    };
+    const parseIf = () => parseIfAfterKeyword(TokenStream__Expect_77B9EE56(stream, new TokenKind(17, []), "Expected \'if\'").Span);
+    const parseIfAfterKeyword = (startSpan) => {
+        const cond = parseExpr();
+        TokenStream__SkipNewlines(stream);
+        TokenStream__Expect_77B9EE56(stream, new TokenKind(18, []), "Expected \'then\'");
+        const thenExpr = parseExprOrBlock();
+        TokenStream__SkipNewlines(stream);
+        while (TokenStream__Match_5CEB78CD(stream, new TokenKind(3, []))) {
+            TokenStream__SkipNewlines(stream);
+        }
+        let elseExpr;
+        const matchValue_32 = TokenStream__Peek(stream).Kind;
+        switch (matchValue_32.tag) {
+            case 19: {
+                TokenStream__Next(stream);
+                elseExpr = parseExprOrBlock();
+                break;
+            }
+            case 20: {
+                elseExpr = parseIfAfterKeyword(TokenStream__Next(stream).Span);
+                break;
+            }
+            default:
+                throw new ParseException(new ParseError("Expected \'else\' or \'elif\'", TokenStream__Peek(stream).Span));
+        }
+        return new Expr(6, [cond, thenExpr, elseExpr, mkSpanFrom(startSpan, Ast_spanOfExpr(elseExpr))]);
+    };
+    const parseFor = () => {
+        const forTok = TokenStream__Expect_77B9EE56(stream, new TokenKind(22, []), "Expected \'for\'");
+        let name_14;
+        const matchValue_33 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected identifier after \'for\'").Kind;
+        name_14 = ((matchValue_33.tag === 4) ? matchValue_33.fields[0] : "");
+        TokenStream__SkipNewlines(stream);
+        const matchValue_34 = TokenStream__Peek(stream).Kind;
+        let matchResult_3;
+        if (matchValue_34.tag === 4) {
+            if (matchValue_34.fields[0] === "in") {
+                matchResult_3 = 0;
+            }
+            else {
+                matchResult_3 = 1;
+            }
+        }
+        else {
+            matchResult_3 = 1;
+        }
+        switch (matchResult_3) {
+            case 0: {
+                TokenStream__Next(stream);
+                break;
+            }
+            case 1: {
+                throw new ParseException(new ParseError("Expected \'in\' after for loop variable", TokenStream__Peek(stream).Span));
+                break;
+            }
+        }
+        const source_19 = parsePostfix();
+        TokenStream__SkipNewlines(stream);
+        const matchValue_35 = TokenStream__Peek(stream).Kind;
+        let matchResult_4;
+        if (matchValue_35.tag === 4) {
+            if (matchValue_35.fields[0] === "do") {
+                matchResult_4 = 0;
+            }
+            else {
+                matchResult_4 = 1;
+            }
+        }
+        else {
+            matchResult_4 = 1;
+        }
+        switch (matchResult_4) {
+            case 0: {
+                TokenStream__Next(stream);
+                break;
+            }
+            case 1: {
+                throw new ParseException(new ParseError("Expected \'do\' in for loop", TokenStream__Peek(stream).Span));
+                break;
+            }
+        }
+        const body = parseExprOrBlock();
+        return new Expr(8, [name_14, source_19, body, mkSpanFrom(forTok.Span, Ast_spanOfExpr(body))]);
+    };
+    const parseLambda = () => {
+        const funTok = TokenStream__Expect_77B9EE56(stream, new TokenKind(13, []), "Expected \'fun\'");
+        const parameters = [];
+        let doneParams = false;
+        while (!doneParams) {
+            TokenStream__SkipNewlines(stream);
+            const matchValue_36 = TokenStream__Peek(stream).Kind;
+            switch (matchValue_36.tag) {
+                case 4:
+                case 27: {
+                    void (parameters.push(parseParam()));
+                    break;
+                }
+                default:
+                    doneParams = true;
+            }
+        }
+        if (parameters.length === 0) {
+            throw new ParseException(new ParseError("Expected at least one lambda parameter", TokenStream__Peek(stream).Span));
+        }
+        TokenStream__SkipNewlines(stream);
+        TokenStream__Expect_77B9EE56(stream, new TokenKind(24, []), "Expected \'->\' in lambda");
+        return foldBack_1((param_1, acc) => (new Expr(4, [param_1, acc, mkSpanFrom(funTok.Span, Ast_spanOfExpr(acc))])), parameters, parseExprOrBlock());
+    };
+    const parseMatch = () => {
+        const matchTok = TokenStream__Expect_77B9EE56(stream, new TokenKind(14, []), "Expected \'match\'");
+        const expr_5 = parseExpr();
+        TokenStream__SkipNewlines(stream);
+        TokenStream__Expect_77B9EE56(stream, new TokenKind(15, []), "Expected \'with\' in match");
+        const cases_2 = [];
+        const parseCase_1 = () => {
+            TokenStream__SkipNewlines(stream);
+            if (TokenStream__Match_5CEB78CD(stream, new TokenKind(26, []))) {
+            }
+            const pat = parsePatternCons();
+            TokenStream__SkipNewlines(stream);
+            let guard;
+            if (TokenStream__Match_5CEB78CD(stream, new TokenKind(16, []))) {
+                const g = parseExpr();
+                TokenStream__SkipNewlines(stream);
+                guard = g;
+            }
+            else {
+                guard = undefined;
+            }
+            TokenStream__Expect_77B9EE56(stream, new TokenKind(24, []), "Expected \'->\' in match case");
+            const body_2 = parseExprOrBlock();
+            const span_1 = mkSpanFrom(Ast_spanOfPattern(pat), Ast_spanOfExpr(body_2));
+            void (cases_2.push([pat, guard, body_2, span_1]));
+        };
+        if (TokenStream__Match_5CEB78CD(stream, new TokenKind(1, []))) {
+            while (TokenStream__Match_5CEB78CD(stream, new TokenKind(1, []))) {
+            }
+            const hasIndentedCaseBlock = TokenStream__Match_5CEB78CD(stream, new TokenKind(2, []));
+            const firstCaseToken = TokenStream__Peek(stream);
+            if (equals(firstCaseToken.Kind, new TokenKind(0, [])) ? true : equals(firstCaseToken.Kind, new TokenKind(3, []))) {
+                throw new ParseException(new ParseError("Expected match case", firstCaseToken.Span));
+            }
+            const caseColumn = firstCaseToken.Span.Start.Column | 0;
+            if (caseColumn < matchTok.Span.Start.Column) {
+                throw new ParseException(new ParseError("Match cases must start at match column or deeper", firstCaseToken.Span));
+            }
+            const ensureAlignedCaseStart = () => {
+                const t_12 = TokenStream__Peek(stream);
+                if (t_12.Span.Start.Column !== caseColumn) {
+                    throw new ParseException(new ParseError("Match case columns must align", t_12.Span));
+                }
+            };
+            ensureAlignedCaseStart();
+            parseCase_1();
+            let doneCases_1 = false;
+            while (!doneCases_1) {
+                TokenStream__SkipNewlines(stream);
+                const matchValue_37 = TokenStream__Peek(stream).Kind;
+                let matchResult_5;
+                switch (matchValue_37.tag) {
+                    case 26: {
+                        matchResult_5 = 0;
+                        break;
+                    }
+                    case 3: {
+                        if (hasIndentedCaseBlock) {
+                            matchResult_5 = 1;
+                        }
+                        else {
+                            matchResult_5 = 3;
+                        }
+                        break;
+                    }
+                    case 2: {
+                        matchResult_5 = 2;
+                        break;
+                    }
+                    default:
+                        matchResult_5 = 3;
+                }
+                switch (matchResult_5) {
+                    case 0: {
+                        ensureAlignedCaseStart();
+                        parseCase_1();
+                        break;
+                    }
+                    case 1: {
+                        TokenStream__Next(stream);
+                        doneCases_1 = true;
+                        break;
+                    }
+                    case 2: {
+                        throw new ParseException(new ParseError("Match case columns must align", TokenStream__Peek(stream).Span));
+                        break;
+                    }
+                    case 3: {
+                        if (hasIndentedCaseBlock) {
+                            throw new ParseException(new ParseError("Expected match case or dedent", TokenStream__Peek(stream).Span));
+                        }
+                        else {
+                            doneCases_1 = true;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        else {
+            parseCase_1();
+            let doneCases_2 = false;
+            while (!doneCases_2) {
+                TokenStream__SkipNewlines(stream);
+                const matchValue_38 = TokenStream__Peek(stream).Kind;
+                switch (matchValue_38.tag) {
+                    case 26: {
+                        parseCase_1();
+                        break;
+                    }
+                    case 3:
+                    case 0: {
+                        doneCases_2 = true;
+                        break;
+                    }
+                    default:
+                        doneCases_2 = true;
+                }
+            }
+        }
+        return new Expr(9, [expr_5, toList(cases_2), mkSpanFrom(matchTok.Span, Ast_spanOfExpr(expr_5))]);
+    };
+    const parseLetExpr = () => {
+        let matchValue_41, pattern_2;
+        const letTok = TokenStream__Expect_77B9EE56(stream, new TokenKind(10, []), "Expected \'let\'");
+        const isRec_1 = TokenStream__Match_5CEB78CD(stream, new TokenKind(11, []));
+        let patternInput_2;
+        if (isRec_1) {
+            if (equals(TokenStream__Peek(stream).Kind, new TokenKind(27, []))) {
+                throw new ParseException(new ParseError("\'let rec\' does not support pattern bindings", TokenStream__Peek(stream).Span));
+            }
+            const nameTok_13 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected identifier after \'let\'");
+            let name_15;
+            const matchValue_39 = nameTok_13.Kind;
+            name_15 = ((matchValue_39.tag === 4) ? matchValue_39.fields[0] : "");
+            const args_1 = parseParamsAligned();
+            if (args_1.length === 0) {
+                throw new ParseException(new ParseError("\'let rec\' requires at least one function argument", nameTok_13.Span));
+            }
+            patternInput_2 = [name_15, args_1, undefined, nameTok_13.Span];
+        }
+        else if (TokenStream__Peek(stream).Kind.tag === 27) {
+            let pattern_1;
+            const pattern = parsePatternCons();
+            if (pattern.tag === 5) {
+                pattern_1 = pattern;
+            }
+            else {
+                throw new ParseException(new ParseError("Only tuple patterns are supported in let bindings", Ast_spanOfPattern(pattern)));
+            }
+            patternInput_2 = ["", [], pattern_1, Ast_spanOfPattern(pattern_1)];
+        }
+        else {
+            const nameTok_14 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected identifier after \'let\'");
+            patternInput_2 = [(matchValue_41 = nameTok_14.Kind, (matchValue_41.tag === 4) ? matchValue_41.fields[0] : ""), parseParamsAligned(), undefined, nameTok_14.Span];
+        }
+        const tuplePatternOpt = patternInput_2[2];
+        const bindingName = patternInput_2[0];
+        const args_2 = patternInput_2[1];
+        TokenStream__SkipNewlines(stream);
+        let returnAnnotation;
+        if (TokenStream__Match_5CEB78CD(stream, new TokenKind(35, []))) {
+            if (args_2.length === 0) {
+                throw new ParseException(new ParseError("Return type annotations are only supported on function let bindings", TokenStream__Peek(stream).Span));
+            }
+            returnAnnotation = parseTypeRef();
+        }
+        else {
+            returnAnnotation = undefined;
+        }
+        if (equals(TokenStream__Peek(stream).Kind, new TokenKind(35, []))) {
+            throw new ParseException(new ParseError("Annotated parameters must be parenthesized as (x: T)", TokenStream__Peek(stream).Span));
+        }
+        TokenStream__Expect_77B9EE56(stream, new TokenKind(25, []), "Expected \'=\' in let binding");
+        const value_70 = parseExprOrBlock();
+        if (isRec_1) {
+            const bindings = [];
+            const firstSpan = mkSpanFrom(patternInput_2[3], Ast_spanOfExpr(value_70));
+            void (bindings.push([bindingName, toList(args_2), returnAnnotation, value_70, firstSpan]));
+            let doneBindings = false;
+            while (!doneBindings) {
+                TokenStream__SkipNewlines(stream);
+                if (TokenStream__Match_5CEB78CD(stream, new TokenKind(12, []))) {
+                    const nextNameTok = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected identifier after \'and\'");
+                    let nextName;
+                    const matchValue_42 = nextNameTok.Kind;
+                    nextName = ((matchValue_42.tag === 4) ? matchValue_42.fields[0] : "");
+                    const nextArgs = parseParamsAligned();
+                    if (nextArgs.length === 0) {
+                        throw new ParseException(new ParseError("\'let rec ... and ...\' requires function arguments for each binding", nextNameTok.Span));
+                    }
+                    TokenStream__SkipNewlines(stream);
+                    const nextReturnAnnotation = TokenStream__Match_5CEB78CD(stream, new TokenKind(35, [])) ? parseTypeRef() : undefined;
+                    if (equals(TokenStream__Peek(stream).Kind, new TokenKind(35, []))) {
+                        throw new ParseException(new ParseError("Annotated parameters must be parenthesized as (x: T)", TokenStream__Peek(stream).Span));
+                    }
+                    TokenStream__Expect_77B9EE56(stream, new TokenKind(25, []), "Expected \'=\' in let binding");
+                    const nextValue = parseExprOrBlock();
+                    const nextSpan = mkSpanFrom(nextNameTok.Span, Ast_spanOfExpr(nextValue));
+                    void (bindings.push([nextName, toList(nextArgs), nextReturnAnnotation, nextValue, nextSpan]));
+                }
+                else {
+                    doneBindings = true;
+                }
+            }
+            const matchValue_43 = TokenStream__Peek(stream).Kind;
+            let matchResult_6;
+            if (matchValue_43.tag === 4) {
+                if (matchValue_43.fields[0] === "in") {
+                    matchResult_6 = 0;
+                }
+                else {
+                    matchResult_6 = 1;
+                }
+            }
+            else {
+                matchResult_6 = 1;
+            }
+            switch (matchResult_6) {
+                case 0:
+                    throw new ParseException(new ParseError("\'in\' keyword is not supported", TokenStream__Peek(stream).Span));
+                default: {
+                    let body_3;
+                    if (TokenStream__Peek(stream).Kind.tag === 2) {
+                        TokenStream__Next(stream);
+                        body_3 = parseBlock();
+                    }
+                    else {
+                        body_3 = parseExprOrBlock();
+                    }
+                    if (bindings.length === 1) {
+                        return new Expr(10, [bindingName, foldBack_1((arg_3, acc_1) => (new Expr(4, [arg_3, acc_1, Ast_spanOfExpr(acc_1)])), args_2, value_70), body_3, true, returnAnnotation, mkSpanFrom(letTok.Span, Ast_spanOfExpr(body_3))]);
+                    }
+                    else {
+                        return new Expr(12, [toList(bindings), body_3, mkSpanFrom(letTok.Span, Ast_spanOfExpr(body_3))]);
+                    }
+                }
+            }
+        }
+        else {
+            const matchValue_45 = TokenStream__Peek(stream).Kind;
+            let matchResult_7;
+            if (matchValue_45.tag === 4) {
+                if (matchValue_45.fields[0] === "in") {
+                    matchResult_7 = 0;
+                }
+                else {
+                    matchResult_7 = 1;
+                }
+            }
+            else {
+                matchResult_7 = 1;
+            }
+            switch (matchResult_7) {
+                case 0:
+                    throw new ParseException(new ParseError("\'in\' keyword is not supported", TokenStream__Peek(stream).Span));
+                default: {
+                    let body_4;
+                    if (TokenStream__Peek(stream).Kind.tag === 2) {
+                        TokenStream__Next(stream);
+                        body_4 = parseBlock();
+                    }
+                    else {
+                        body_4 = parseExprOrBlock();
+                    }
+                    if (tuplePatternOpt == null) {
+                        return new Expr(10, [bindingName, foldBack_1((arg_4, acc_2) => (new Expr(4, [arg_4, acc_2, Ast_spanOfExpr(acc_2)])), args_2, value_70), body_4, false, returnAnnotation, mkSpanFrom(letTok.Span, Ast_spanOfExpr(body_4))]);
+                    }
+                    else if ((pattern_2 = tuplePatternOpt, args_2.length > 0)) {
+                        const pattern_3 = tuplePatternOpt;
+                        throw new ParseException(new ParseError("Tuple let binding cannot take function parameters", Ast_spanOfPattern(pattern_3)));
+                    }
+                    else {
+                        const pattern_4 = tuplePatternOpt;
+                        return new Expr(11, [pattern_4, value_70, body_4, mkSpanFrom(letTok.Span, Ast_spanOfExpr(body_4))]);
+                    }
+                }
+            }
+        }
+    };
+    const parseExprOrBlock = () => {
+        let sawNewline_4 = false;
+        while (TokenStream__Match_5CEB78CD(stream, new TokenKind(1, []))) {
+            sawNewline_4 = true;
+        }
+        if (sawNewline_4 && TokenStream__Match_5CEB78CD(stream, new TokenKind(2, []))) {
+            return parseBlock();
+        }
+        else {
+            return parseExpr();
+        }
+    };
+    const parseExpr = () => parseBinary(0);
+    const parseBlock = () => {
+        const statements = [];
+        let doneBlock = false;
+        let blockStatementColumn = undefined;
+        while (!doneBlock) {
+            let col, matchValue_49;
+            TokenStream__SkipNewlines(stream);
+            const matchValue_47 = TokenStream__Peek(stream).Kind;
+            let matchResult_8;
+            switch (matchValue_47.tag) {
+                case 3: {
+                    matchResult_8 = 0;
+                    break;
+                }
+                case 28:
+                case 30:
+                case 44: {
+                    matchResult_8 = 1;
+                    break;
+                }
+                case 0: {
+                    matchResult_8 = 2;
+                    break;
+                }
+                case 10: {
+                    matchResult_8 = 3;
+                    break;
+                }
+                case 39: {
+                    matchResult_8 = 4;
+                    break;
+                }
+                case 42: {
+                    matchResult_8 = 6;
+                    break;
+                }
+                case 38: {
+                    if (equals(TokenStream__PeekAt_Z524259A4(stream, 1).Kind, new TokenKind(39, [])) ? true : equals(TokenStream__PeekAt_Z524259A4(stream, 1).Kind, new TokenKind(41, []))) {
+                        matchResult_8 = 5;
+                    }
+                    else {
+                        matchResult_8 = 8;
+                    }
+                    break;
+                }
+                case 29: {
+                    if (equals(TokenStream__PeekAt_Z524259A4(stream, 1).Kind, new TokenKind(54, []))) {
+                        matchResult_8 = 7;
+                    }
+                    else {
+                        matchResult_8 = 8;
+                    }
+                    break;
+                }
+                default:
+                    matchResult_8 = 8;
+            }
+            switch (matchResult_8) {
+                case 0: {
+                    TokenStream__Next(stream);
+                    TokenStream__SkipNewlines(stream);
+                    const findNextNonLayout = (offset_mut) => {
+                        findNextNonLayout:
+                        while (true) {
+                            const offset = offset_mut;
+                            const matchValue_48 = TokenStream__PeekAt_Z524259A4(stream, offset).Kind;
+                            switch (matchValue_48.tag) {
+                                case 1:
+                                case 2:
+                                case 3: {
+                                    offset_mut = (offset + 1);
+                                    continue findNextNonLayout;
+                                }
+                                default:
+                                    return TokenStream__PeekAt_Z524259A4(stream, offset);
+                            }
+                            break;
+                        }
+                    };
+                    const nextSignificant = findNextNonLayout(0);
+                    const next_4 = TokenStream__Peek(stream);
+                    if (!((blockStatementColumn == null) ? false : ((col = (blockStatementColumn | 0), (matchValue_49 = nextSignificant.Kind, (matchValue_49.tag === 0) ? false : ((matchValue_49.tag === 3) ? false : ((matchValue_49.tag === 28) ? false : ((matchValue_49.tag === 30) ? false : ((matchValue_49.tag === 44) ? false : (nextSignificant.Span.Start.Column >= col)))))))))) {
+                        doneBlock = true;
+                    }
+                    break;
+                }
+                case 1: {
+                    doneBlock = true;
+                    break;
+                }
+                case 2: {
+                    doneBlock = true;
+                    break;
+                }
+                case 3: {
+                    if (blockStatementColumn == null) {
+                        blockStatementColumn = TokenStream__Peek(stream).Span.Start.Column;
+                    }
+                    void (statements.push(parseLetStmt(false)));
+                    break;
+                }
+                case 4: {
+                    throw new ParseException(new ParseError("\'import\' is only supported at top level", TokenStream__Peek(stream).Span));
+                    break;
+                }
+                case 5: {
+                    throw new ParseException(new ParseError("Use \'import \"file.fss\"\' at top level", TokenStream__Peek(stream).Span));
+                    break;
+                }
+                case 6: {
+                    throw new ParseException(new ParseError("\'module\' declarations were removed; module names are derived from imported filenames", TokenStream__Peek(stream).Span));
+                    break;
+                }
+                case 7: {
+                    throw new ParseException(new ParseError("\'[<export>]\' is only supported at top level", TokenStream__Peek(stream).Span));
+                    break;
+                }
+                case 8: {
+                    if (blockStatementColumn == null) {
+                        blockStatementColumn = TokenStream__Peek(stream).Span.Start.Column;
+                    }
+                    const expr_6 = parseExpr();
+                    void (statements.push(new Stmt(5, [expr_6])));
+                    break;
+                }
+            }
+        }
+        if (statements.length === 0) {
+            throw new ParseException(new ParseError("Empty block", TokenStream__Peek(stream).Span));
+        }
+        const desugar = (stmts) => {
+            if (!isEmpty(stmts)) {
+                switch (head_1(stmts).tag) {
+                    case 2:
+                        if (isEmpty(tail_1(stmts))) {
+                            throw new ParseException(new ParseError("Block cannot end with a let binding; add a final expression", head_1(stmts).fields[6]));
+                        }
+                        else {
+                            const valExpr = foldBack_1((arg_5, acc_3) => (new Expr(4, [arg_5, acc_3, head_1(stmts).fields[6]])), head_1(stmts).fields[1], head_1(stmts).fields[3]);
+                            const body_5 = desugar(tail_1(stmts));
+                            return new Expr(10, [head_1(stmts).fields[0], valExpr, body_5, head_1(stmts).fields[4], head_1(stmts).fields[2], mkSpanFrom(head_1(stmts).fields[6], Ast_spanOfExpr(body_5))]);
+                        }
+                    case 3:
+                        if (isEmpty(tail_1(stmts))) {
+                            throw new ParseException(new ParseError("Block cannot end with a let binding; add a final expression", head_1(stmts).fields[3]));
+                        }
+                        else {
+                            const body_6 = desugar(tail_1(stmts));
+                            return new Expr(11, [head_1(stmts).fields[0], head_1(stmts).fields[1], body_6, mkSpanFrom(head_1(stmts).fields[3], Ast_spanOfExpr(body_6))]);
+                        }
+                    case 4:
+                        if (isEmpty(tail_1(stmts))) {
+                            throw new ParseException(new ParseError("Block cannot end with a let binding; add a final expression", head_1(stmts).fields[2]));
+                        }
+                        else {
+                            const body_7 = desugar(tail_1(stmts));
+                            return new Expr(12, [head_1(stmts).fields[0], body_7, mkSpanFrom(head_1(stmts).fields[2], Ast_spanOfExpr(body_7))]);
+                        }
+                    case 0:
+                        throw new ParseException(new ParseError("Type declarations are only supported at top level", head_1(stmts).fields[0].Span));
+                    case 1:
+                        throw new ParseException(new ParseError("\'import\' is only supported at top level", head_1(stmts).fields[2]));
+                    default:
+                        if (isEmpty(tail_1(stmts))) {
+                            return head_1(stmts).fields[0];
+                        }
+                        else {
+                            const body_8 = desugar(tail_1(stmts));
+                            return new Expr(10, ["_", head_1(stmts).fields[0], body_8, false, undefined, mkSpanFrom(Ast_spanOfExpr(head_1(stmts).fields[0]), Ast_spanOfExpr(body_8))]);
+                        }
+                }
+            }
+            else {
+                return new Expr(0, [TokenStream__Peek(stream).Span]);
+            }
+        };
+        return desugar(toList(statements));
+    };
+    const parseLetStmt = (isExported) => {
+        let matchValue_52, pattern_8;
+        const letTok_1 = TokenStream__Next(stream);
+        const isRec_3 = TokenStream__Match_5CEB78CD(stream, new TokenKind(11, []));
+        let patternInput_3;
+        if (isRec_3) {
+            if (equals(TokenStream__Peek(stream).Kind, new TokenKind(27, []))) {
+                throw new ParseException(new ParseError("\'let rec\' does not support pattern bindings", TokenStream__Peek(stream).Span));
+            }
+            const nameTok_15 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected identifier after \'let\'");
+            let name_18;
+            const matchValue_50 = nameTok_15.Kind;
+            name_18 = ((matchValue_50.tag === 4) ? matchValue_50.fields[0] : "");
+            const args_4 = parseParamsAligned();
+            if (args_4.length === 0) {
+                throw new ParseException(new ParseError("\'let rec\' requires at least one function argument", nameTok_15.Span));
+            }
+            patternInput_3 = [name_18, args_4, undefined, nameTok_15.Span];
+        }
+        else if (TokenStream__Peek(stream).Kind.tag === 27) {
+            if (isExported) {
+                throw new ParseException(new ParseError("Exported let binding requires a single identifier, not a tuple pattern", TokenStream__Peek(stream).Span));
+            }
+            let pattern_7;
+            const pattern_6 = parsePatternCons();
+            if (pattern_6.tag === 5) {
+                pattern_7 = pattern_6;
+            }
+            else {
+                throw new ParseException(new ParseError("Only tuple patterns are supported in let bindings", Ast_spanOfPattern(pattern_6)));
+            }
+            patternInput_3 = ["", [], pattern_7, Ast_spanOfPattern(pattern_7)];
+        }
+        else {
+            const nameTok_16 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected identifier after \'let\'");
+            patternInput_3 = [(matchValue_52 = nameTok_16.Kind, (matchValue_52.tag === 4) ? matchValue_52.fields[0] : ""), parseParamsAligned(), undefined, nameTok_16.Span];
+        }
+        const tuplePatternOpt_1 = patternInput_3[2];
+        const bindingName_1 = patternInput_3[0];
+        const args_5 = patternInput_3[1];
+        TokenStream__SkipNewlines(stream);
+        let returnAnnotation_2;
+        if (TokenStream__Match_5CEB78CD(stream, new TokenKind(35, []))) {
+            if (args_5.length === 0) {
+                throw new ParseException(new ParseError("Return type annotations are only supported on function let bindings", TokenStream__Peek(stream).Span));
+            }
+            returnAnnotation_2 = parseTypeRef();
+        }
+        else {
+            returnAnnotation_2 = undefined;
+        }
+        if (equals(TokenStream__Peek(stream).Kind, new TokenKind(35, []))) {
+            throw new ParseException(new ParseError("Annotated parameters must be parenthesized as (x: T)", TokenStream__Peek(stream).Span));
+        }
+        TokenStream__Expect_77B9EE56(stream, new TokenKind(25, []), "Expected \'=\' in let binding");
+        const value_78 = parseExprOrBlock();
+        if (isRec_3) {
+            const bindings_2 = [];
+            const firstSpan_1 = mkSpanFrom(patternInput_3[3], Ast_spanOfExpr(value_78));
+            void (bindings_2.push([bindingName_1, toList(args_5), returnAnnotation_2, value_78, firstSpan_1]));
+            let doneBindings_1 = false;
+            while (!doneBindings_1) {
+                TokenStream__SkipNewlines(stream);
+                if (TokenStream__Match_5CEB78CD(stream, new TokenKind(12, []))) {
+                    const nextNameTok_1 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected identifier after \'and\'");
+                    let nextName_1;
+                    const matchValue_53 = nextNameTok_1.Kind;
+                    nextName_1 = ((matchValue_53.tag === 4) ? matchValue_53.fields[0] : "");
+                    const nextArgs_1 = parseParamsAligned();
+                    if (nextArgs_1.length === 0) {
+                        throw new ParseException(new ParseError("\'let rec ... and ...\' requires function arguments for each binding", nextNameTok_1.Span));
+                    }
+                    TokenStream__SkipNewlines(stream);
+                    const nextReturnAnnotation_1 = TokenStream__Match_5CEB78CD(stream, new TokenKind(35, [])) ? parseTypeRef() : undefined;
+                    if (equals(TokenStream__Peek(stream).Kind, new TokenKind(35, []))) {
+                        throw new ParseException(new ParseError("Annotated parameters must be parenthesized as (x: T)", TokenStream__Peek(stream).Span));
+                    }
+                    TokenStream__Expect_77B9EE56(stream, new TokenKind(25, []), "Expected \'=\' in let binding");
+                    const nextValue_1 = parseExprOrBlock();
+                    const nextSpan_1 = mkSpanFrom(nextNameTok_1.Span, Ast_spanOfExpr(nextValue_1));
+                    void (bindings_2.push([nextName_1, toList(nextArgs_1), nextReturnAnnotation_1, nextValue_1, nextSpan_1]));
+                }
+                else {
+                    doneBindings_1 = true;
+                }
+            }
+            if (bindings_2.length === 1) {
+                return new Stmt(2, [bindingName_1, toList(args_5), returnAnnotation_2, value_78, true, isExported, mkSpanFrom(letTok_1.Span, Ast_spanOfExpr(value_78))]);
+            }
+            else {
+                const patternInput_4 = item_1(bindings_2.length - 1, bindings_2);
+                return new Stmt(4, [toList(bindings_2), isExported, mkSpanFrom(letTok_1.Span, patternInput_4[4])]);
+            }
+        }
+        else if (tuplePatternOpt_1 == null) {
+            return new Stmt(2, [bindingName_1, toList(args_5), returnAnnotation_2, value_78, false, isExported, mkSpanFrom(letTok_1.Span, Ast_spanOfExpr(value_78))]);
+        }
+        else if ((pattern_8 = tuplePatternOpt_1, args_5.length > 0)) {
+            const pattern_9 = tuplePatternOpt_1;
+            throw new ParseException(new ParseError("Tuple let binding cannot take function parameters", Ast_spanOfPattern(pattern_9)));
+        }
+        else {
+            const pattern_10 = tuplePatternOpt_1;
+            return new Stmt(3, [pattern_10, value_78, isExported, mkSpanFrom(letTok_1.Span, Ast_spanOfExpr(value_78))]);
+        }
+    };
+    const parseAttributeName = () => {
+        TokenStream__Expect_77B9EE56(stream, new TokenKind(29, []), "Expected \'[\' in attribute");
+        TokenStream__Expect_77B9EE56(stream, new TokenKind(54, []), "Expected \'<\' in attribute");
+        const nameTok_17 = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected attribute name");
+        let name_20;
+        const matchValue_54 = nameTok_17.Kind;
+        name_20 = ((matchValue_54.tag === 4) ? matchValue_54.fields[0] : "");
+        TokenStream__Expect_77B9EE56(stream, new TokenKind(55, []), "Expected \'>\' in attribute");
+        TokenStream__Expect_77B9EE56(stream, new TokenKind(30, []), "Expected \']\' in attribute");
+        return [name_20, nameTok_17.Span];
+    };
+    const parseStmt = () => {
+        let matchValue_58;
+        TokenStream__SkipNewlines(stream);
+        if (equals(TokenStream__Peek(stream).Kind, new TokenKind(4, ["export"])) && equals(TokenStream__PeekAt_Z524259A4(stream, 1).Kind, new TokenKind(10, []))) {
+            throw new ParseException(new ParseError("\'export let\' is no longer supported; use \'[<export>] let ...\'", TokenStream__Peek(stream).Span));
+        }
+        let isExported_1 = false;
+        let hasAttributes = false;
+        let parsingAttributes = true;
+        while (parsingAttributes) {
+            if (equals(TokenStream__Peek(stream).Kind, new TokenKind(29, [])) && equals(TokenStream__PeekAt_Z524259A4(stream, 1).Kind, new TokenKind(54, []))) {
+                hasAttributes = true;
+                const patternInput_5 = parseAttributeName();
+                const span_9 = patternInput_5[1];
+                const name_21 = patternInput_5[0];
+                if (name_21 === "export") {
+                    if (isExported_1) {
+                        throw new ParseException(new ParseError("Duplicate attribute \'export\'", span_9));
+                    }
+                    isExported_1 = true;
+                }
+                else {
+                    throw new ParseException(new ParseError(concat("Unknown attribute \'", name_21, "\'"), span_9));
+                }
+                TokenStream__SkipNewlines(stream);
+            }
+            else {
+                parsingAttributes = false;
+            }
+        }
+        const matchValue_55 = TokenStream__Peek(stream).Kind;
+        switch (matchValue_55.tag) {
+            case 38: {
+                if (hasAttributes ? true : isExported_1) {
+                    throw new ParseException(new ParseError("Attributes are not supported on \'import\' directives", TokenStream__Peek(stream).Span));
+                }
+                const hashTok = TokenStream__Next(stream);
+                const matchValue_56 = TokenStream__Next(stream).Kind;
+                switch (matchValue_56.tag) {
+                    case 41:
+                        throw new ParseException(new ParseError("\'#include\' was removed in 0.32.0; use \'import \"file.fss\" as Alias\'", hashTok.Span));
+                    case 39:
+                        throw new ParseException(new ParseError("\'#import\' was removed in 0.32.0; use \'import \"file.fss\" as Alias\'", hashTok.Span));
+                    default:
+                        throw new ParseException(new ParseError("Unexpected \'#\'; use \'import \"file.fss\" as Alias\'", hashTok.Span));
+                }
+            }
+            case 39: {
+                if (hasAttributes ? true : isExported_1) {
+                    throw new ParseException(new ParseError("Attributes are not supported on \'import\' directives", TokenStream__Peek(stream).Span));
+                }
+                const importTok = TokenStream__Next(stream);
+                const pathTok = TokenStream__Next(stream);
+                const matchValue_57 = pathTok.Kind;
+                if (matchValue_57.tag === 7) {
+                    if (!isNullOrWhiteSpace(matchValue_57.fields[0])) {
+                        TokenStream__Expect_77B9EE56(stream, new TokenKind(40, []), "Expected \'as\' in import directive. Use: import \"file.fss\" as Alias");
+                        const aliasTok = TokenStream__ExpectIdent_Z721C83C5(stream, "Expected module alias after \'as\'");
+                        return new Stmt(1, [(matchValue_58 = aliasTok.Kind, (matchValue_58.tag === 4) ? matchValue_58.fields[0] : ""), matchValue_57.fields[0], mkSpanFrom(importTok.Span, aliasTok.Span)]);
+                    }
+                    else {
+                        throw new ParseException(new ParseError("Import path cannot be empty", pathTok.Span));
+                    }
+                }
+                else {
+                    throw new ParseException(new ParseError("Expected string literal import path after \'import\'", pathTok.Span));
+                }
+            }
+            case 42:
+                throw new ParseException(new ParseError("\'module\' declarations are not supported in scripts", TokenStream__Peek(stream).Span));
+            case 45: {
+                if (isExported_1) {
+                    throw new ParseException(new ParseError("\'[<export>]\' is only valid for top-level let bindings", TokenStream__Peek(stream).Span));
+                }
+                return parseTypeDecl();
+            }
+            case 10:
+                return parseLetStmt(isExported_1);
+            default:
+                if (hasAttributes) {
+                    throw new ParseException(new ParseError("\'[<export>]\' must be followed by a top-level let binding", TokenStream__Peek(stream).Span));
+                }
+                else {
+                    return new Stmt(5, [parseExpr()]);
+                }
+        }
+    };
+    const program = [];
+    TokenStream__SkipNewlines(stream);
+    while (!TokenStream__get_AtEnd(stream)) {
+        const matchValue_59 = TokenStream__Peek(stream).Kind;
+        switch (matchValue_59.tag) {
+            case 0: {
+                TokenStream__Next(stream);
+                break;
+            }
+            case 3: {
+                TokenStream__Next(stream);
+                break;
+            }
+            default: {
+                const stmt = parseStmt();
+                void (program.push(stmt));
+                TokenStream__SkipNewlines(stream);
+            }
+        }
+    }
+    return toList(program);
+}
+
+export function parseProgram(src) {
+    return parseProgramWithSourceName(undefined, src);
+}
+