@magnusopera/fscript 0.75.0

package/dist/FScript.Language/Lexer.js

@@ -0,0 +1,1067 @@
+
+import { isDigit, isLetterOrDigit, isLetter } from "../fable_modules/fable-library-js.5.2.0/Char.js";
+import { parse } from "../fable_modules/fable-library-js.5.2.0/Double.js";
+import { Span, Position } from "./Span.js";
+import { Token, TokenKind } from "./Token.js";
+import { StringBuilder__Append_244C7CD6, StringBuilder_$ctor } from "../fable_modules/fable-library-js.5.2.0/System.Text.js";
+import { ParseException, ParseError } from "./Error.js";
+import { toString } from "../fable_modules/fable-library-js.5.2.0/Types.js";
+import { printf, toText, substring } from "../fable_modules/fable-library-js.5.2.0/String.js";
+import { item } from "../fable_modules/fable-library-js.5.2.0/Array.js";
+import { toInt64_unchecked } from "../fable_modules/fable-library-js.5.2.0/BigInt.js";
+import { parse as parse_1 } from "../fable_modules/fable-library-js.5.2.0/Long.js";
+import { toList } from "../fable_modules/fable-library-js.5.2.0/Seq.js";
+
+function isIdentStart(c) {
+    if (isLetter(c)) {
+        return true;
+    }
+    else {
+        return c === "_";
+    }
+}
+
+function isIdentPart(c) {
+    if (isLetterOrDigit(c) ? true : (c === "_")) {
+        return true;
+    }
+    else {
+        return c === "\'";
+    }
+}
+
+function parseFloatLiteral(text) {
+    return parse(text);
+}
+
+function mkSpan(sourceName, line, col, length) {
+    return new Span(new Position(sourceName, line, col), new Position(sourceName, line, col + length));
+}
+
+function keywordToken(ident) {
+    switch (ident) {
+        case "let":
+            return new TokenKind(10, []);
+        case "rec":
+            return new TokenKind(11, []);
+        case "and":
+            return new TokenKind(12, []);
+        case "type":
+            return new TokenKind(45, []);
+        case "typeof":
+            return new TokenKind(46, []);
+        case "nameof":
+            return new TokenKind(47, []);
+        case "of":
+            return new TokenKind(48, []);
+        case "fun":
+            return new TokenKind(13, []);
+        case "match":
+            return new TokenKind(14, []);
+        case "with":
+            return new TokenKind(15, []);
+        case "when":
+            return new TokenKind(16, []);
+        case "if":
+            return new TokenKind(17, []);
+        case "then":
+            return new TokenKind(18, []);
+        case "else":
+            return new TokenKind(19, []);
+        case "elif":
+            return new TokenKind(20, []);
+        case "raise":
+            return new TokenKind(21, []);
+        case "for":
+            return new TokenKind(22, []);
+        case "import":
+            return new TokenKind(39, []);
+        case "as":
+            return new TokenKind(40, []);
+        case "include":
+            return new TokenKind(41, []);
+        case "module":
+            return new TokenKind(42, []);
+        case "true":
+            return new TokenKind(9, [true]);
+        case "false":
+            return new TokenKind(9, [false]);
+        default:
+            return undefined;
+    }
+}
+
+function addToken(kind, span, tokens) {
+    void (tokens.push(new Token(kind, span)));
+}
+
+function readString(sourceName, src, i, line, col) {
+    const sb = StringBuilder_$ctor();
+    let idx = i + 1;
+    let cLine = line;
+    let cCol = col + 1;
+    let doneFlag = false;
+    while ((idx < src.length) && !doneFlag) {
+        const ch = src[idx];
+        if (ch === "\"") {
+            doneFlag = true;
+            idx = ((idx + 1) | 0);
+            cCol = ((cCol + 1) | 0);
+        }
+        else if ((ch === "\\") && ((idx + 1) < src.length)) {
+            const next = src[idx + 1];
+            switch (next) {
+                case "\"": {
+                    StringBuilder__Append_244C7CD6(sb, "\"");
+                    break;
+                }
+                case "\\": {
+                    StringBuilder__Append_244C7CD6(sb, "\\");
+                    break;
+                }
+                case "n": {
+                    StringBuilder__Append_244C7CD6(sb, "\n");
+                    break;
+                }
+                case "t": {
+                    StringBuilder__Append_244C7CD6(sb, "\t");
+                    break;
+                }
+                default:
+                    StringBuilder__Append_244C7CD6(sb, next);
+            }
+            idx = ((idx + 2) | 0);
+            cCol = ((cCol + 2) | 0);
+        }
+        else {
+            StringBuilder__Append_244C7CD6(sb, ch);
+            if (ch === "\n") {
+                cLine = ((cLine + 1) | 0);
+                cCol = 1;
+            }
+            else {
+                cCol = ((cCol + 1) | 0);
+            }
+            idx = ((idx + 1) | 0);
+        }
+    }
+    if (!doneFlag) {
+        throw new ParseException(new ParseError("Unterminated string literal", mkSpan(sourceName, line, col, 1)));
+    }
+    return [toString(sb), idx, cLine, cCol];
+}
+
+function readInterpolatedRaw(sourceName, src, i, line, col) {
+    let idx = i + 2;
+    let cLine = line;
+    let cCol = col + 2;
+    let doneFlag = false;
+    let escaped = false;
+    let placeholderDepth = 0;
+    let inPlaceholderString = false;
+    let placeholderEscaped = false;
+    while ((idx < src.length) && !doneFlag) {
+        const ch = src[idx];
+        if (placeholderDepth > 0) {
+            if (inPlaceholderString) {
+                if (placeholderEscaped) {
+                    placeholderEscaped = false;
+                }
+                else {
+                    switch (ch) {
+                        case "\"": {
+                            inPlaceholderString = false;
+                            break;
+                        }
+                        case "\\": {
+                            placeholderEscaped = true;
+                            break;
+                        }
+                        default:
+                            undefined;
+                    }
+                }
+            }
+            else {
+                switch (ch) {
+                    case "\"": {
+                        inPlaceholderString = true;
+                        break;
+                    }
+                    case "{": {
+                        placeholderDepth = ((placeholderDepth + 1) | 0);
+                        break;
+                    }
+                    case "}": {
+                        placeholderDepth = ((placeholderDepth - 1) | 0);
+                        break;
+                    }
+                    default:
+                        undefined;
+                }
+            }
+            if (ch === "\n") {
+                cLine = ((cLine + 1) | 0);
+                cCol = 1;
+            }
+            else {
+                cCol = ((cCol + 1) | 0);
+            }
+            idx = ((idx + 1) | 0);
+        }
+        else if (escaped) {
+            escaped = false;
+            if (ch === "\n") {
+                cLine = ((cLine + 1) | 0);
+                cCol = 1;
+            }
+            else {
+                cCol = ((cCol + 1) | 0);
+            }
+            idx = ((idx + 1) | 0);
+        }
+        else {
+            switch (ch) {
+                case "\n": {
+                    idx = ((idx + 1) | 0);
+                    cLine = ((cLine + 1) | 0);
+                    cCol = 1;
+                    break;
+                }
+                case "\"": {
+                    doneFlag = true;
+                    idx = ((idx + 1) | 0);
+                    cCol = ((cCol + 1) | 0);
+                    break;
+                }
+                case "\\": {
+                    escaped = true;
+                    idx = ((idx + 1) | 0);
+                    cCol = ((cCol + 1) | 0);
+                    break;
+                }
+                case "{": {
+                    if (((idx + 1) < src.length) && (src[idx + 1] === "{")) {
+                        idx = ((idx + 2) | 0);
+                        cCol = ((cCol + 2) | 0);
+                    }
+                    else {
+                        placeholderDepth = 1;
+                        idx = ((idx + 1) | 0);
+                        cCol = ((cCol + 1) | 0);
+                    }
+                    break;
+                }
+                default: {
+                    idx = ((idx + 1) | 0);
+                    cCol = ((cCol + 1) | 0);
+                }
+            }
+        }
+    }
+    if (!doneFlag) {
+        throw new ParseException(new ParseError("Unterminated interpolated string literal", mkSpan(sourceName, line, col, 2)));
+    }
+    const start = (i + 2) | 0;
+    const contentLen = ((idx - 1) - start) | 0;
+    return [(contentLen <= 0) ? "" : substring(src, start, contentLen), idx, cLine, cCol];
+}
+
+export function tokenizeWithSourceName(sourceName, src) {
+    const tokens = [];
+    const indentStack = [];
+    void (indentStack.push(0));
+    let i = 0;
+    let line = 1;
+    let col = 1;
+    let atLineStart = true;
+    let inLetBindingHead = false;
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    while (i < src.length) {
+        const ch = src[i];
+        if (atLineStart) {
+            let idx = i;
+            let indent = 0;
+            let cCol = col;
+            let onlyWhitespace = true;
+            while ((idx < src.length) && ((src[idx] === " ") ? true : (src[idx] === "\t"))) {
+                indent = ((indent + ((src[idx] === "\t") ? 4 : 1)) | 0);
+                idx = ((idx + 1) | 0);
+                cCol = ((cCol + 1) | 0);
+            }
+            if ((idx < src.length) && (src[idx] === "\n")) {
+                addToken(new TokenKind(1, []), mkSpan(sourceName, line, col, 1), tokens);
+                i = ((idx + 1) | 0);
+                line = ((line + 1) | 0);
+                col = 1;
+                atLineStart = true;
+            }
+            else if ((((idx < src.length) && (src[idx] === "/")) && ((idx + 1) < src.length)) && (src[idx + 1] === "/")) {
+                while ((i < src.length) && (src[i] !== "\n")) {
+                    i = ((i + 1) | 0);
+                }
+                addToken(new TokenKind(1, []), mkSpan(sourceName, line, col, 1), tokens);
+                if ((i < src.length) && (src[i] === "\n")) {
+                    i = ((i + 1) | 0);
+                    line = ((line + 1) | 0);
+                    col = 1;
+                }
+                atLineStart = true;
+            }
+            else {
+                const span_1 = mkSpan(sourceName, line, col, 1);
+                const startsWithParameterHead = (idx < src.length) && ((src[idx] === "(") ? true : isIdentStart(src[idx]));
+                if (inLetBindingHead && startsWithParameterHead) {
+                }
+                else {
+                    const newIndent = indent | 0;
+                    const span = span_1;
+                    const current = item(indentStack.length - 1, indentStack) | 0;
+                    if (newIndent > current) {
+                        void (indentStack.push(newIndent));
+                        addToken(new TokenKind(2, []), span, tokens);
+                    }
+                    else if (newIndent < current) {
+                        let j = indentStack.length - 1;
+                        while ((j > 0) && (item(j, indentStack) > newIndent)) {
+                            indentStack.splice(j, 1);
+                            addToken(new TokenKind(3, []), span, tokens);
+                            j = ((j - 1) | 0);
+                        }
+                        if (item(indentStack.length - 1, indentStack) !== newIndent) {
+                            if ((((parenDepth > 0) ? true : (bracketDepth > 0)) ? true : (braceDepth > 0)) && (item(indentStack.length - 1, indentStack) < newIndent)) {
+                                void (indentStack.push(newIndent));
+                                addToken(new TokenKind(2, []), span, tokens);
+                            }
+                            else {
+                                throw new ParseException(new ParseError("Inconsistent indentation", span));
+                            }
+                        }
+                    }
+                }
+                i = (idx | 0);
+                col = (cCol | 0);
+                atLineStart = false;
+            }
+        }
+        else {
+            let matchResult, c_48, c_49;
+            switch (ch) {
+                case "\t":
+                case " ": {
+                    matchResult = 0;
+                    break;
+                }
+                case "\n": {
+                    matchResult = 2;
+                    break;
+                }
+                case "\r": {
+                    matchResult = 1;
+                    break;
+                }
+                case "\"": {
+                    matchResult = 5;
+                    break;
+                }
+                case "#": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 37;
+                    }
+                    break;
+                }
+                case "$": {
+                    if (((i + 1) < src.length) && (src[i + 1] === "\"")) {
+                        matchResult = 6;
+                    }
+                    else if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 40;
+                    }
+                    break;
+                }
+                case "%": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 21;
+                    }
+                    break;
+                }
+                case "&": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else if (((i + 1) < src.length) && (src[i + 1] === "&")) {
+                        matchResult = 13;
+                    }
+                    else {
+                        matchResult = 40;
+                    }
+                    break;
+                }
+                case "(": {
+                    if (((i + 1) < src.length) && (src[i + 1] === "*")) {
+                        matchResult = 4;
+                    }
+                    else if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 27;
+                    }
+                    break;
+                }
+                case ")": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 28;
+                    }
+                    break;
+                }
+                case "*": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 19;
+                    }
+                    break;
+                }
+                case "+": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 17;
+                    }
+                    break;
+                }
+                case ",": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 33;
+                    }
+                    break;
+                }
+                case "-": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else if (((i + 1) < src.length) && (src[i + 1] === ">")) {
+                        matchResult = 9;
+                    }
+                    else {
+                        matchResult = 18;
+                    }
+                    break;
+                }
+                case ".": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else if (((i + 1) < src.length) && (src[i + 1] === ".")) {
+                        matchResult = 35;
+                    }
+                    else {
+                        matchResult = 36;
+                    }
+                    break;
+                }
+                case "/": {
+                    if (((i + 1) < src.length) && (src[i + 1] === "/")) {
+                        matchResult = 3;
+                    }
+                    else if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 20;
+                    }
+                    break;
+                }
+                case ":": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else if (((i + 1) < src.length) && (src[i + 1] === ":")) {
+                        matchResult = 10;
+                    }
+                    else {
+                        matchResult = 34;
+                    }
+                    break;
+                }
+                case ";": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 32;
+                    }
+                    break;
+                }
+                case "<": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else if (((i + 1) < src.length) && (src[i + 1] === "=")) {
+                        matchResult = 11;
+                    }
+                    else {
+                        matchResult = 23;
+                    }
+                    break;
+                }
+                case "=": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 22;
+                    }
+                    break;
+                }
+                case ">": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else if (((i + 1) < src.length) && (src[i + 1] === "=")) {
+                        matchResult = 12;
+                    }
+                    else {
+                        matchResult = 24;
+                    }
+                    break;
+                }
+                case "@": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 26;
+                    }
+                    break;
+                }
+                case "[": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else if (((i + 1) < src.length) && (src[i + 1] === "|")) {
+                        matchResult = 29;
+                    }
+                    else {
+                        matchResult = 30;
+                    }
+                    break;
+                }
+                case "]": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 31;
+                    }
+                    break;
+                }
+                case "{": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 38;
+                    }
+                    break;
+                }
+                case "|": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else if (((i + 1) < src.length) && (src[i + 1] === "]")) {
+                        matchResult = 14;
+                    }
+                    else if (((i + 1) < src.length) && (src[i + 1] === "|")) {
+                        matchResult = 15;
+                    }
+                    else if (((i + 1) < src.length) && (src[i + 1] === ">")) {
+                        matchResult = 16;
+                    }
+                    else {
+                        matchResult = 25;
+                    }
+                    break;
+                }
+                case "}": {
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 39;
+                    }
+                    break;
+                }
+                default:
+                    if (isDigit(ch)) {
+                        matchResult = 7;
+                        c_48 = ch;
+                    }
+                    else if (isIdentStart(ch)) {
+                        matchResult = 8;
+                        c_49 = ch;
+                    }
+                    else {
+                        matchResult = 40;
+                    }
+            }
+            switch (matchResult) {
+                case 0: {
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 1: {
+                    i = ((i + 1) | 0);
+                    break;
+                }
+                case 2: {
+                    addToken(new TokenKind(1, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    line = ((line + 1) | 0);
+                    col = 1;
+                    atLineStart = true;
+                    break;
+                }
+                case 3: {
+                    while ((i < src.length) && (src[i] !== "\n")) {
+                        i = ((i + 1) | 0);
+                    }
+                    break;
+                }
+                case 4: {
+                    throw new ParseException(new ParseError("Block comments are not supported", mkSpan(sourceName, line, col, 2)));
+                    break;
+                }
+                case 5: {
+                    const patternInput = readString(sourceName, src, i, line, col);
+                    const idx_1 = patternInput[1] | 0;
+                    addToken(new TokenKind(7, [patternInput[0]]), mkSpan(sourceName, line, col, idx_1 - i), tokens);
+                    i = (idx_1 | 0);
+                    line = (patternInput[2] | 0);
+                    col = (patternInput[3] | 0);
+                    break;
+                }
+                case 6: {
+                    const patternInput_1 = readInterpolatedRaw(sourceName, src, i, line, col);
+                    const idx_2 = patternInput_1[1] | 0;
+                    addToken(new TokenKind(8, [patternInput_1[0]]), mkSpan(sourceName, line, col, idx_2 - i), tokens);
+                    i = (idx_2 | 0);
+                    line = (patternInput_1[2] | 0);
+                    col = (patternInput_1[3] | 0);
+                    break;
+                }
+                case 7: {
+                    const start = i | 0;
+                    const startCol = col | 0;
+                    let hasDot = false;
+                    let idx_3 = i;
+                    while ((idx_3 < src.length) && (isDigit(src[idx_3]) ? true : ((((src[idx_3] === ".") && !hasDot) && ((idx_3 + 1) < src.length)) && isDigit(src[idx_3 + 1])))) {
+                        if (src[idx_3] === ".") {
+                            hasDot = true;
+                            idx_3 = ((idx_3 + 1) | 0);
+                        }
+                        else {
+                            idx_3 = ((idx_3 + 1) | 0);
+                        }
+                    }
+                    const text = substring(src, start, idx_3 - start);
+                    const span_4 = mkSpan(sourceName, line, startCol, idx_3 - start);
+                    if (hasDot) {
+                        addToken(new TokenKind(6, [parseFloatLiteral(text)]), span_4, tokens);
+                    }
+                    else {
+                        addToken(new TokenKind(5, [toInt64_unchecked(parse_1(text, 511, false, 64))]), span_4, tokens);
+                    }
+                    i = (idx_3 | 0);
+                    col = ((startCol + (idx_3 - start)) | 0);
+                    break;
+                }
+                case 8: {
+                    const start_1 = i | 0;
+                    const startCol_1 = col | 0;
+                    let idx_4 = i + 1;
+                    while ((idx_4 < src.length) && isIdentPart(src[idx_4])) {
+                        idx_4 = ((idx_4 + 1) | 0);
+                    }
+                    const ident = substring(src, start_1, idx_4 - start_1);
+                    const span_5 = mkSpan(sourceName, line, startCol_1, idx_4 - start_1);
+                    const matchValue = keywordToken(ident);
+                    if (matchValue == null) {
+                        addToken(new TokenKind(4, [ident]), span_5, tokens);
+                    }
+                    else {
+                        const k = matchValue;
+                        addToken(k, span_5, tokens);
+                        switch (k.tag) {
+                            case 10:
+                            case 12: {
+                                inLetBindingHead = true;
+                                break;
+                            }
+                            default:
+                                undefined;
+                        }
+                    }
+                    i = (idx_4 | 0);
+                    col = ((startCol_1 + (idx_4 - start_1)) | 0);
+                    break;
+                }
+                case 9: {
+                    addToken(new TokenKind(24, []), mkSpan(sourceName, line, col, 2), tokens);
+                    i = ((i + 2) | 0);
+                    col = ((col + 2) | 0);
+                    break;
+                }
+                case 10: {
+                    addToken(new TokenKind(61, []), mkSpan(sourceName, line, col, 2), tokens);
+                    i = ((i + 2) | 0);
+                    col = ((col + 2) | 0);
+                    break;
+                }
+                case 11: {
+                    addToken(new TokenKind(56, []), mkSpan(sourceName, line, col, 2), tokens);
+                    i = ((i + 2) | 0);
+                    col = ((col + 2) | 0);
+                    break;
+                }
+                case 12: {
+                    addToken(new TokenKind(57, []), mkSpan(sourceName, line, col, 2), tokens);
+                    i = ((i + 2) | 0);
+                    col = ((col + 2) | 0);
+                    break;
+                }
+                case 13: {
+                    addToken(new TokenKind(58, []), mkSpan(sourceName, line, col, 2), tokens);
+                    i = ((i + 2) | 0);
+                    col = ((col + 2) | 0);
+                    break;
+                }
+                case 14: {
+                    addToken(new TokenKind(32, []), mkSpan(sourceName, line, col, 2), tokens);
+                    if (bracketDepth > 0) {
+                        bracketDepth = ((bracketDepth - 1) | 0);
+                    }
+                    i = ((i + 2) | 0);
+                    col = ((col + 2) | 0);
+                    break;
+                }
+                case 15: {
+                    addToken(new TokenKind(59, []), mkSpan(sourceName, line, col, 2), tokens);
+                    i = ((i + 2) | 0);
+                    col = ((col + 2) | 0);
+                    break;
+                }
+                case 16: {
+                    addToken(new TokenKind(60, []), mkSpan(sourceName, line, col, 2), tokens);
+                    i = ((i + 2) | 0);
+                    col = ((col + 2) | 0);
+                    break;
+                }
+                case 17: {
+                    addToken(new TokenKind(49, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 18: {
+                    addToken(new TokenKind(50, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 19: {
+                    addToken(new TokenKind(51, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 20: {
+                    addToken(new TokenKind(52, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 21: {
+                    addToken(new TokenKind(53, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 22: {
+                    addToken(new TokenKind(25, []), mkSpan(sourceName, line, col, 1), tokens);
+                    inLetBindingHead = false;
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 23: {
+                    addToken(new TokenKind(54, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 24: {
+                    addToken(new TokenKind(55, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 25: {
+                    addToken(new TokenKind(26, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 26: {
+                    addToken(new TokenKind(62, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 27: {
+                    addToken(new TokenKind(27, []), mkSpan(sourceName, line, col, 1), tokens);
+                    parenDepth = ((parenDepth + 1) | 0);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 28: {
+                    addToken(new TokenKind(28, []), mkSpan(sourceName, line, col, 1), tokens);
+                    if (parenDepth > 0) {
+                        parenDepth = ((parenDepth - 1) | 0);
+                    }
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 29: {
+                    addToken(new TokenKind(31, []), mkSpan(sourceName, line, col, 2), tokens);
+                    bracketDepth = ((bracketDepth + 1) | 0);
+                    i = ((i + 2) | 0);
+                    col = ((col + 2) | 0);
+                    break;
+                }
+                case 30: {
+                    addToken(new TokenKind(29, []), mkSpan(sourceName, line, col, 1), tokens);
+                    bracketDepth = ((bracketDepth + 1) | 0);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 31: {
+                    addToken(new TokenKind(30, []), mkSpan(sourceName, line, col, 1), tokens);
+                    if (bracketDepth > 0) {
+                        bracketDepth = ((bracketDepth - 1) | 0);
+                    }
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 32: {
+                    addToken(new TokenKind(33, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 33: {
+                    addToken(new TokenKind(34, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 34: {
+                    addToken(new TokenKind(35, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 35: {
+                    addToken(new TokenKind(37, []), mkSpan(sourceName, line, col, 2), tokens);
+                    i = ((i + 2) | 0);
+                    col = ((col + 2) | 0);
+                    break;
+                }
+                case 36: {
+                    addToken(new TokenKind(36, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 37: {
+                    addToken(new TokenKind(38, []), mkSpan(sourceName, line, col, 1), tokens);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 38: {
+                    addToken(new TokenKind(43, []), mkSpan(sourceName, line, col, 1), tokens);
+                    braceDepth = ((braceDepth + 1) | 0);
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 39: {
+                    addToken(new TokenKind(44, []), mkSpan(sourceName, line, col, 1), tokens);
+                    if (braceDepth > 0) {
+                        braceDepth = ((braceDepth - 1) | 0);
+                    }
+                    i = ((i + 1) | 0);
+                    col = ((col + 1) | 0);
+                    break;
+                }
+                case 40: {
+                    throw new ParseException(new ParseError(toText(printf("Unexpected character \'%c\'"))(ch), mkSpan(sourceName, line, col, 1)));
+                    break;
+                }
+            }
+        }
+    }
+    addToken(new TokenKind(1, []), mkSpan(sourceName, line, col, 1), tokens);
+    while (indentStack.length > 1) {
+        indentStack.splice(indentStack.length - 1, 1);
+        addToken(new TokenKind(3, []), mkSpan(sourceName, line, col, 1), tokens);
+    }
+    addToken(new TokenKind(0, []), mkSpan(sourceName, line, col, 1), tokens);
+    return toList(tokens);
+}
+
+export function tokenize(src) {
+    return tokenizeWithSourceName(undefined, src);
+}
+