septima-lang 0.0.1

package/dist/src/parser.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+class Parser {
+    constructor(scanner) {
+        this.scanner = scanner;
+    }
+    parse() {
+        const ret = this.expression();
+        if (!this.scanner.eof()) {
+            throw new Error(`Loitering input ${this.scanner.sourceRef}`);
+        }
+        return ret;
+    }
+    definitions() {
+        const ret = [];
+        while (true) {
+            const start = this.scanner.consumeIf('let ');
+            if (!start) {
+                return ret;
+            }
+            const ident = this.identifier();
+            this.scanner.consume('=');
+            const value = this.lambda();
+            this.scanner.consume(';');
+            ret.push({ start, ident, value });
+        }
+    }
+    expression() {
+        const definitions = this.definitions();
+        const computation = this.lambda();
+        if (definitions.length === 0) {
+            return computation;
+        }
+        return { tag: 'topLevelExpression', definitions, computation };
+    }
+    lambda() {
+        const start = this.scanner.consumeIf('fun');
+        if (!start) {
+            return this.ifExpression();
+        }
+        this.scanner.consume('(');
+        const args = [];
+        if (this.scanner.consumeIf(')')) {
+            // no formal args
+        }
+        else {
+            while (true) {
+                const arg = this.identifier();
+                args.push(arg);
+                if (this.scanner.consumeIf(')')) {
+                    break;
+                }
+                this.scanner.consume(',');
+            }
+        }
+        const body = this.expression();
+        return { tag: 'lambda', start, formalArgs: args, body };
+    }
+    ifExpression() {
+        if (!this.scanner.consumeIf('if')) {
+            return this.unsink();
+        }
+        this.scanner.consume('(');
+        const condition = this.expression();
+        this.scanner.consume(')');
+        const positive = this.expression();
+        this.scanner.consume('else');
+        const negative = this.expression();
+        return { tag: 'if', condition, positive, negative };
+    }
+    unsink() {
+        const lhs = this.or();
+        if (this.scanner.consumeIf('??')) {
+            return { tag: 'binaryOperator', operator: '??', lhs, rhs: this.unsink() };
+        }
+        return lhs;
+    }
+    or() {
+        const lhs = this.and();
+        if (this.scanner.consumeIf('||')) {
+            return { tag: 'binaryOperator', operator: '||', lhs, rhs: this.or() };
+        }
+        return lhs;
+    }
+    and() {
+        const lhs = this.equality();
+        if (this.scanner.consumeIf('&&')) {
+            return { tag: 'binaryOperator', operator: '&&', lhs, rhs: this.and() };
+        }
+        return lhs;
+    }
+    equality() {
+        const lhs = this.comparison();
+        if (this.scanner.consumeIf('==')) {
+            return { tag: 'binaryOperator', operator: '==', lhs, rhs: this.equality() };
+        }
+        if (this.scanner.consumeIf('!=')) {
+            return { tag: 'binaryOperator', operator: '!=', lhs, rhs: this.equality() };
+        }
+        return lhs;
+    }
+    comparison() {
+        const lhs = this.addition();
+        if (this.scanner.consumeIf('>=')) {
+            return { tag: 'binaryOperator', operator: '>=', lhs, rhs: this.comparison() };
+        }
+        if (this.scanner.consumeIf('<=')) {
+            return { tag: 'binaryOperator', operator: '<=', lhs, rhs: this.comparison() };
+        }
+        if (this.scanner.consumeIf('>')) {
+            return { tag: 'binaryOperator', operator: '>', lhs, rhs: this.comparison() };
+        }
+        if (this.scanner.consumeIf('<')) {
+            return { tag: 'binaryOperator', operator: '<', lhs, rhs: this.comparison() };
+        }
+        return lhs;
+    }
+    addition() {
+        const lhs = this.multiplication();
+        if (this.scanner.consumeIf('+')) {
+            return { tag: 'binaryOperator', operator: '+', lhs, rhs: this.addition() };
+        }
+        if (this.scanner.consumeIf('-')) {
+            return { tag: 'binaryOperator', operator: '-', lhs, rhs: this.addition() };
+        }
+        return lhs;
+    }
+    multiplication() {
+        const lhs = this.power();
+        if (this.scanner.consumeIf('*')) {
+            return { tag: 'binaryOperator', operator: '*', lhs, rhs: this.multiplication() };
+        }
+        if (this.scanner.consumeIf('/')) {
+            return { tag: 'binaryOperator', operator: '/', lhs, rhs: this.multiplication() };
+        }
+        if (this.scanner.consumeIf('%')) {
+            return { tag: 'binaryOperator', operator: '%', lhs, rhs: this.multiplication() };
+        }
+        return lhs;
+    }
+    power() {
+        const lhs = this.unary();
+        if (this.scanner.consumeIf('**')) {
+            return { tag: 'binaryOperator', operator: '**', lhs, rhs: this.power() };
+        }
+        return lhs;
+    }
+    unary() {
+        let operatorToken = this.scanner.consumeIf('!');
+        if (operatorToken) {
+            return { tag: 'unaryOperator', operand: this.unary(), operator: '!', operatorToken };
+        }
+        operatorToken = this.scanner.consumeIf('+');
+        if (operatorToken) {
+            return { tag: 'unaryOperator', operand: this.unary(), operator: '+', operatorToken };
+        }
+        operatorToken = this.scanner.consumeIf('-');
+        if (operatorToken) {
+            return { tag: 'unaryOperator', operand: this.unary(), operator: '-', operatorToken };
+        }
+        return this.call();
+    }
+    call() {
+        const callee = this.memberAccess();
+        if (!this.scanner.consumeIf('(')) {
+            return callee;
+        }
+        const { actualArgs, end } = this.actualArgList();
+        return { tag: 'functionCall', actualArgs, callee, end };
+    }
+    actualArgList() {
+        const actualArgs = [];
+        const endEmpty = this.scanner.consumeIf(')');
+        if (endEmpty) {
+            // no actual args
+            return { actualArgs, end: endEmpty };
+        }
+        while (true) {
+            const arg = this.expression();
+            actualArgs.push(arg);
+            const end = this.scanner.consumeIf(')');
+            if (end) {
+                return { actualArgs, end };
+            }
+            this.scanner.consume(',');
+        }
+    }
+    memberAccess() {
+        let ret = this.parenthesized();
+        while (true) {
+            if (this.scanner.consumeIf('.')) {
+                ret = { tag: 'dot', receiver: ret, ident: this.identifier() };
+                continue;
+            }
+            if (this.scanner.consumeIf('[')) {
+                ret = { tag: 'indexAccess', receiver: ret, index: this.expression() };
+                this.scanner.consume(']');
+                continue;
+            }
+            if (this.scanner.consumeIf('(')) {
+                const { actualArgs, end } = this.actualArgList();
+                ret = { tag: 'functionCall', actualArgs, callee: ret, end };
+                continue;
+            }
+            return ret;
+        }
+    }
+    parenthesized() {
+        if (this.scanner.consumeIf('(')) {
+            const ret = this.expression();
+            this.scanner.consume(')');
+            return ret;
+        }
+        return this.literalOrIdent();
+    }
+    literalOrIdent() {
+        let t = this.scanner.consumeIf('sink!!');
+        if (t) {
+            return { tag: 'literal', type: 'sink!!', t };
+        }
+        t = this.scanner.consumeIf('sink!');
+        if (t) {
+            return { tag: 'literal', type: 'sink!', t };
+        }
+        t = this.scanner.consumeIf('sink');
+        if (t) {
+            return { tag: 'literal', type: 'sink', t };
+        }
+        t = this.scanner.consumeIf('true');
+        if (t) {
+            return { tag: 'literal', type: 'bool', t };
+        }
+        t = this.scanner.consumeIf('false');
+        if (t) {
+            return { tag: 'literal', type: 'bool', t };
+        }
+        t = this.scanner.consumeIf(/([0-9]*[.])?[0-9]+/);
+        if (t) {
+            return { tag: 'literal', type: 'num', t };
+        }
+        // double-quotes-enclosd string
+        if (this.scanner.consumeIf(`"`, false)) {
+            t = this.scanner.consume(/[^"]*/);
+            this.scanner.consume(`"`);
+            return { tag: 'literal', type: 'str', t };
+        }
+        // single-quotes-enclosd string
+        if (this.scanner.consumeIf(`'`, false)) {
+            t = this.scanner.consume(/[^']*/);
+            this.scanner.consume(`'`);
+            return { tag: 'literal', type: 'str', t };
+        }
+        t = this.scanner.consumeIf('[');
+        if (t) {
+            return this.arrayBody(t);
+        }
+        t = this.scanner.consumeIf('{');
+        if (t) {
+            return this.objectBody(t);
+        }
+        const ident = this.maybeIdentifier();
+        if (ident) {
+            return ident;
+        }
+        throw new Error(`Unparsable input ${this.scanner.sourceRef}`);
+    }
+    /**
+     * This method assumes that the caller consumed the opening '[' token. It consumes the array's elements
+     * (comma-separated list of expressions) as well as the closing ']' token.
+     */
+    arrayBody(start) {
+        const t = this.scanner.consumeIf(']');
+        if (t) {
+            // an empty array literal
+            return { tag: 'arrayLiteral', start, parts: [], end: t };
+        }
+        const parts = [];
+        while (true) {
+            if (this.scanner.consumeIf('...')) {
+                parts.push({ tag: 'spread', v: this.expression() });
+            }
+            else {
+                const exp = this.expression();
+                parts.push({ tag: 'element', v: exp });
+            }
+            const end = this.scanner.consumeIf(']');
+            if (end) {
+                return { tag: 'arrayLiteral', start, parts, end };
+            }
+            this.scanner.consume(',');
+        }
+    }
+    /**
+     * This method assumes that the caller consumed the opening '{' token. It consumes the object's attributes
+     * (comma-separated list of key:value parirs) as well as the closing '}' token.
+     */
+    objectBody(start) {
+        const t = this.scanner.consumeIf('}');
+        if (t) {
+            // an empty array literal
+            return { tag: 'objectLiteral', start, parts: [], end: t };
+        }
+        const parts = [];
+        while (true) {
+            if (this.scanner.consumeIf('...')) {
+                parts.push({ tag: 'spread', o: this.expression() });
+            }
+            else if (this.scanner.consumeIf('[')) {
+                const k = this.expression();
+                this.scanner.consume(']');
+                this.scanner.consume(':');
+                const v = this.expression();
+                parts.push({ tag: 'computedName', k, v });
+            }
+            else {
+                const k = this.identifier();
+                this.scanner.consume(':');
+                const v = this.expression();
+                parts.push({ tag: 'hardName', k, v });
+            }
+            const end = this.scanner.consumeIf('}');
+            if (end) {
+                return { tag: 'objectLiteral', start, parts, end };
+            }
+            this.scanner.consume(',');
+        }
+    }
+    identifier() {
+        const ret = this.maybeIdentifier();
+        if (!ret) {
+            throw new Error(`Expected an identifier ${this.scanner.sourceRef}`);
+        }
+        return ret;
+    }
+    maybeIdentifier() {
+        const t = this.scanner.consumeIf(/[a-zA-Z][0-9A-Za-z_]*/);
+        if (t) {
+            return { tag: 'ident', t };
+        }
+        return undefined;
+    }
+}
+exports.Parser = Parser;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parser.js","sourceRoot":"","sources":["../../src/parser.ts"],"names":[],"mappings":";;;AAGA,MAAa,MAAM;IACjB,YAA6B,OAAgB;QAAhB,YAAO,GAAP,OAAO,CAAS;IAAG,CAAC;IAEjD,KAAK;QACH,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;QAC7B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE;YACvB,MAAM,IAAI,KAAK,CAAC,mBAAmB,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,CAAA;SAC7D;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,WAAW;QACT,MAAM,GAAG,GAAU,EAAE,CAAA;QACrB,OAAO,IAAI,EAAE;YACX,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;YAC5C,IAAI,CAAC,KAAK,EAAE;gBACV,OAAO,GAAG,CAAA;aACX;YACD,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;YAC/B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;YACzB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAA;YAC3B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;YAEzB,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAA;SAClC;IACH,CAAC;IAED,UAAU;QACR,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,CAAA;QACtC,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,EAAE,CAAA;QAEjC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE;YAC5B,OAAO,WAAW,CAAA;SACnB;QAED,OAAO,EAAE,GAAG,EAAE,oBAAoB,EAAE,WAAW,EAAE,WAAW,EAAE,CAAA;IAChE,CAAC;IAED,MAAM;QACJ,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;QAC3C,IAAI,CAAC,KAAK,EAAE;YACV,OAAO,IAAI,CAAC,YAAY,EAAE,CAAA;SAC3B;QAED,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QACzB,MAAM,IAAI,GAAY,EAAE,CAAA;QAExB,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAC/B,iBAAiB;SAClB;aAAM;YACL,OAAO,IAAI,EAAE;gBACX,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;gBAC7B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;gBACd,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;oBAC/B,MAAK;iBACN;gBAED,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;aAC1B;SACF;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;QAC9B,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,CAAA;IACzD,CAAC;IAED,YAAY;QACV,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YACjC,OAAO,IAAI,CAAC,MAAM,EAAE,CAAA;SACrB;QAED,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QACzB,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;QACnC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QAEzB,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;QAElC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;QAE5B,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;QAElC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAA;IACrD,CAAC;IAED,MAAM;QACJ,MAAM,GAAG,GAAG,IAAI,CAAC,EAAE,EAAE,CAAA;QACrB,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YAChC,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,CAAA;SAC1E;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,EAAE;QACA,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;QACtB,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YAChC,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAA;SACtE;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,GAAG;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAA;QAC3B,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YAChC,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAA;SACvE;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,QAAQ;QACN,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;QAC7B,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YAChC,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAA;SAC5E;QACD,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YAChC,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAA;SAC5E;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,UAAU;QACR,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAA;QAC3B,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YAChC,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAAA;SAC9E;QACD,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YAChC,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAAA;SAC9E;QACD,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAC/B,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAAA;SAC7E;QACD,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAC/B,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAAA;SAC7E;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,QAAQ;QACN,MAAM,GAAG,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QACjC,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAC/B,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAA;SAC3E;QACD,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAC/B,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAA;SAC3E;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,cAAc;QACZ,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,EAAE,CAAA;QACxB,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAC/B,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,EAAE,CAAA;SACjF;QACD,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAC/B,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,EAAE,CAAA;SACjF;QACD,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAC/B,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,EAAE,CAAA;SACjF;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,KAAK;QACH,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,EAAE,CAAA;QACxB,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YAChC,OAAO,EAAE,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,EAAE,CAAA;SACzE;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,KAAK;QACH,IAAI,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;QAC/C,IAAI,aAAa,EAAE;YACjB,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,aAAa,EAAE,CAAA;SACrF;QACD,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;QAC3C,IAAI,aAAa,EAAE;YACjB,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,aAAa,EAAE,CAAA;SACrF;QACD,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;QAC3C,IAAI,aAAa,EAAE;YACjB,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,aAAa,EAAE,CAAA;SACrF;QAED,OAAO,IAAI,CAAC,IAAI,EAAE,CAAA;IACpB,CAAC;IAED,IAAI;QACF,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,EAAE,CAAA;QAElC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAChC,OAAO,MAAM,CAAA;SACd;QAED,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,aAAa,EAAE,CAAA;QAChD,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,CAAA;IACzD,CAAC;IAEO,aAAa;QACnB,MAAM,UAAU,GAAc,EAAE,CAAA;QAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;QAC5C,IAAI,QAAQ,EAAE;YACZ,iBAAiB;YACjB,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAA;SACrC;QAED,OAAO,IAAI,EAAE;YACX,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;YAC7B,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;YACpB,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;YACvC,IAAI,GAAG,EAAE;gBACP,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,CAAA;aAC3B;YACD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;SAC1B;IACH,CAAC;IAED,YAAY;QACV,IAAI,GAAG,GAAG,IAAI,CAAC,aAAa,EAAE,CAAA;QAE9B,OAAO,IAAI,EAAE;YACX,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;gBAC/B,GAAG,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAAA;gBAC7D,SAAQ;aACT;YAED,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;gBAC/B,GAAG,GAAG,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAAA;gBACrE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;gBACzB,SAAQ;aACT;YAED,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;gBAC/B,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,aAAa,EAAE,CAAA;gBAChD,GAAG,GAAG,EAAE,GAAG,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,CAAA;gBAC3D,SAAQ;aACT;YAED,OAAO,GAAG,CAAA;SACX;IACH,CAAC;IAED,aAAa;QACX,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAC/B,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;YAC7B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;YACzB,OAAO,GAAG,CAAA;SACX;QAED,OAAO,IAAI,CAAC,cAAc,EAAE,CAAA;IAC9B,CAAC;IAED,cAAc;QACZ,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAA;QACxC,IAAI,CAAC,EAAE;YACL,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAA;SAC7C;QAED,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;QACnC,IAAI,CAAC,EAAE;YACL,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,CAAA;SAC5C;QAED,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;QAClC,IAAI,CAAC,EAAE;YACL,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,CAAA;SAC3C;QAED,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;QAClC,IAAI,CAAC,EAAE;YACL,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,CAAA;SAC3C;QACD,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;QACnC,IAAI,CAAC,EAAE;YACL,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,CAAA;SAC3C;QAED,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAA;QAChD,IAAI,CAAC,EAAE;YACL,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,CAAA;SAC1C;QAED,+BAA+B;QAC/B,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE;YACtC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;YACjC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;YACzB,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,CAAA;SAC1C;QAED,+BAA+B;QAC/B,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE;YACtC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;YACjC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;YACzB,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,CAAA;SAC1C;QAED,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;QAC/B,IAAI,CAAC,EAAE;YACL,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;SACzB;QAED,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;QAC/B,IAAI,CAAC,EAAE;YACL,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAA;SAC1B;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,EAAE,CAAA;QACpC,IAAI,KAAK,EAAE;YACT,OAAO,KAAK,CAAA;SACb;QAED,MAAM,IAAI,KAAK,CAAC,oBAAoB,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,CAAA;IAC/D,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,KAAY;QACpB,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;QACrC,IAAI,CAAC,EAAE;YACL,yBAAyB;YACzB,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAA;SACzD;QAED,MAAM,KAAK,GAAuB,EAAE,CAAA;QACpC,OAAO,IAAI,EAAE;YACX,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;gBACjC,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,CAAA;aACpD;iBAAM;gBACL,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;gBAC7B,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAA;aACvC;YAED,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;YACvC,IAAI,GAAG,EAAE;gBACP,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,CAAA;aAClD;YAED,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;SAC1B;IACH,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,KAAY;QACrB,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;QACrC,IAAI,CAAC,EAAE;YACL,yBAAyB;YACzB,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAA;SAC1D;QAED,MAAM,KAAK,GAAwB,EAAE,CAAA;QACrC,OAAO,IAAI,EAAE;YACX,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;gBACjC,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,CAAA;aACpD;iBAAM,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;gBACtC,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;gBAC3B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;gBACzB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;gBACzB,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;gBAC3B,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,cAAc,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAA;aAC1C;iBAAM;gBACL,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;gBAC3B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;gBACzB,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;gBAC3B,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAA;aACtC;YAED,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;YACvC,IAAI,GAAG,EAAE;gBACP,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,CAAA;aACnD;YAED,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;SAC1B;IACH,CAAC;IAEO,UAAU;QAChB,MAAM,GAAG,GAAG,IAAI,CAAC,eAAe,EAAE,CAAA;QAClC,IAAI,CAAC,GAAG,EAAE;YACR,MAAM,IAAI,KAAK,CAAC,0BAA0B,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,CAAA;SACpE;QAED,OAAO,GAAG,CAAA;IACZ,CAAC;IAEO,eAAe;QACrB,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,uBAAuB,CAAC,CAAA;QACzD,IAAI,CAAC,EAAE;YACL,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,CAAA;SAC3B;QAED,OAAO,SAAS,CAAA;IAClB,CAAC;CACF;AA3YD,wBA2YC"}

package/dist/src/result.d.ts

@@ -0,0 +1,24 @@
+import { Span } from './location';
+import { SourceCode } from './source-code';
+import { Value } from './value';
+export declare type ResultSink = {
+    tag: 'sink';
+    where: Span | undefined;
+    trace: string | undefined;
+    symbols: Record<string, unknown> | undefined;
+    message: string;
+};
+export declare type Result = {
+    tag: 'ok';
+    value: unknown;
+} | ResultSink;
+export declare class ResultSinkImpl {
+    private readonly sink;
+    private readonly sourceCode;
+    readonly tag = "sink";
+    constructor(sink: Value, sourceCode: SourceCode);
+    get where(): Span | undefined;
+    get trace(): string | undefined;
+    get symbols(): Record<string, unknown> | undefined;
+    get message(): string;
+}

package/dist/src/result.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultSinkImpl = void 0;
+class ResultSinkImpl {
+    constructor(sink, sourceCode) {
+        this.sink = sink;
+        this.sourceCode = sourceCode;
+        this.tag = 'sink';
+    }
+    get where() {
+        return this.sink.span();
+    }
+    get trace() {
+        const trace = this.sink.trace();
+        if (trace) {
+            return this.sourceCode.formatTrace(trace);
+        }
+        return undefined;
+    }
+    get symbols() {
+        return this.sink.symbols()?.export();
+    }
+    get message() {
+        const at = this.trace ?? this.sourceCode.sourceRef(this.where);
+        return `Evaluated to sink: ${at}`;
+    }
+}
+exports.ResultSinkImpl = ResultSinkImpl;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzdWx0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Jlc3VsdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFtQkEsTUFBYSxjQUFjO0lBRXpCLFlBQTZCLElBQVcsRUFBbUIsVUFBc0I7UUFBcEQsU0FBSSxHQUFKLElBQUksQ0FBTztRQUFtQixlQUFVLEdBQVYsVUFBVSxDQUFZO1FBRHhFLFFBQUcsR0FBRyxNQUFNLENBQUE7SUFDK0QsQ0FBQztJQUVyRixJQUFJLEtBQUs7UUFDUCxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUE7SUFDekIsQ0FBQztJQUVELElBQUksS0FBSztRQUNQLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUE7UUFDL0IsSUFBSSxLQUFLLEVBQUU7WUFDVCxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsV0FBVyxDQUFDLEtBQUssQ0FBQyxDQUFBO1NBQzFDO1FBRUQsT0FBTyxTQUFTLENBQUE7SUFDbEIsQ0FBQztJQUVELElBQUksT0FBTztRQUNULE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsRUFBRSxNQUFNLEVBQUUsQ0FBQTtJQUN0QyxDQUFDO0lBRUQsSUFBSSxPQUFPO1FBQ1QsTUFBTSxFQUFFLEdBQUcsSUFBSSxDQUFDLEtBQUssSUFBSSxJQUFJLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUE7UUFDOUQsT0FBTyxzQkFBc0IsRUFBRSxFQUFFLENBQUE7SUFDbkMsQ0FBQztDQUNGO0FBekJELHdDQXlCQyJ9

package/dist/src/runtime.d.ts

@@ -0,0 +1,25 @@
+import { AstNode } from './ast-node';
+import { Parser } from './parser';
+import { Value } from './value';
+export declare type Verbosity = 'quiet' | 'trace';
+export declare class Runtime {
+    private readonly root;
+    private readonly verbosity;
+    private readonly parser;
+    private stack;
+    constructor(root: AstNode, verbosity: Verbosity, parser: Parser);
+    compute(): {
+        value: Value;
+        expressionTrace?: undefined;
+        errorMessage?: undefined;
+        stack?: undefined;
+    } | {
+        expressionTrace: AstNode[];
+        errorMessage: unknown;
+        stack: string[] | undefined;
+        value?: undefined;
+    };
+    private evalNode;
+    private evalNodeImpl;
+    call(callee: Value, argValues: Value[]): Value;
+}