septima-lang 0.0.1

package/dist/src/ast-node.d.ts

@@ -0,0 +1,85 @@
+import { Span } from './location';
+import { Token } from './scanner';
+export declare type Let = {
+    start: Token;
+    ident: Ident;
+    value: AstNode;
+};
+export declare type ObjectLiteralPart = {
+    tag: 'hardName';
+    k: Ident;
+    v: AstNode;
+} | {
+    tag: 'computedName';
+    k: AstNode;
+    v: AstNode;
+} | {
+    tag: 'spread';
+    o: AstNode;
+};
+export declare type ArrayLiteralPart = {
+    tag: 'element';
+    v: AstNode;
+} | {
+    tag: 'spread';
+    v: AstNode;
+};
+export declare type Ident = {
+    tag: 'ident';
+    t: Token;
+};
+export declare type Lambda = {
+    tag: 'lambda';
+    start: Token;
+    formalArgs: Ident[];
+    body: AstNode;
+};
+export declare type AstNode = Ident | {
+    start: Token;
+    tag: 'arrayLiteral';
+    parts: ArrayLiteralPart[];
+    end: Token;
+} | {
+    start: Token;
+    tag: 'objectLiteral';
+    parts: ObjectLiteralPart[];
+    end: Token;
+} | {
+    tag: 'literal';
+    type: 'str' | 'bool' | 'num' | 'sink' | 'sink!' | 'sink!!';
+    t: Token;
+} | {
+    tag: 'binaryOperator';
+    operator: '+' | '-' | '*' | '/' | '**' | '%' | '&&' | '||' | '>' | '<' | '>=' | '<=' | '==' | '!=' | '??';
+    lhs: AstNode;
+    rhs: AstNode;
+} | {
+    tag: 'unaryOperator';
+    operatorToken: Token;
+    operator: '+' | '-' | '!';
+    operand: AstNode;
+} | {
+    tag: 'topLevelExpression';
+    definitions: Let[];
+    computation: AstNode;
+} | Lambda | {
+    tag: 'functionCall';
+    actualArgs: AstNode[];
+    callee: AstNode;
+    end: Token;
+} | {
+    tag: 'if';
+    condition: AstNode;
+    positive: AstNode;
+    negative: AstNode;
+} | {
+    tag: 'dot';
+    receiver: AstNode;
+    ident: Ident;
+} | {
+    tag: 'indexAccess';
+    receiver: AstNode;
+    index: AstNode;
+};
+export declare function show(ast: AstNode | AstNode[]): string;
+export declare function span(ast: AstNode): Span;

package/dist/src/ast-node.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.span = exports.show = void 0;
+const should_never_happen_1 = require("./should-never-happen");
+function show(ast) {
+    if (Array.isArray(ast)) {
+        return ast.map(curr => show(curr)).join(', ');
+    }
+    if (ast.tag === 'arrayLiteral') {
+        const parts = ast.parts.map(p => {
+            if (p.tag === 'element') {
+                return show(p.v);
+            }
+            if (p.tag === 'spread') {
+                return `...${show(p.v)}`;
+            }
+            (0, should_never_happen_1.shouldNeverHappen)(p);
+        });
+        return `[${parts.join(', ')}]`;
+    }
+    if (ast.tag === 'binaryOperator') {
+        return `(${show(ast.lhs)} ${ast.operator} ${show(ast.rhs)})`;
+    }
+    if (ast.tag === 'dot') {
+        return `${show(ast.receiver)}.${show(ast.ident)}`;
+    }
+    if (ast.tag === 'functionCall') {
+        return `${show(ast.callee)}(${show(ast.actualArgs)})`;
+    }
+    if (ast.tag === 'ident') {
+        return ast.t.text;
+    }
+    if (ast.tag === 'if') {
+        return `if (${show(ast.condition)}) ${show(ast.positive)} else ${show(ast.negative)}`;
+    }
+    if (ast.tag === 'indexAccess') {
+        return `${show(ast.receiver)}[${show(ast.index)}]`;
+    }
+    if (ast.tag === 'lambda') {
+        return `fun (${show(ast.formalArgs)}) ${show(ast.body)}`;
+    }
+    if (ast.tag === 'literal') {
+        return ast.t.text;
+    }
+    if (ast.tag === 'objectLiteral') {
+        const pairs = ast.parts.map(p => {
+            if (p.tag === 'computedName') {
+                return `[${show(p.k)}]: ${show(p.v)}`;
+            }
+            if (p.tag === 'hardName') {
+                return `${show(p.k)}: ${show(p.v)}`;
+            }
+            if (p.tag === 'spread') {
+                return `...${show(p.o)}`;
+            }
+            (0, should_never_happen_1.shouldNeverHappen)(p);
+        });
+        return `{${pairs.join(', ')}}`;
+    }
+    if (ast.tag === 'topLevelExpression') {
+        const defs = ast.definitions.map(d => `let ${show(d.ident)} = ${show(d.value)}`).join('; ');
+        return `${defs ? defs + '; ' : ''}${show(ast.computation)}`;
+    }
+    if (ast.tag === 'unaryOperator') {
+        return `${ast.operator}${show(ast.operand)}`;
+    }
+    (0, should_never_happen_1.shouldNeverHappen)(ast);
+}
+exports.show = show;
+function span(ast) {
+    const ofRange = (a, b) => ({ from: a.from, to: b.to });
+    const ofToken = (t) => ({ from: t.location, to: { offset: t.location.offset + t.text.length - 1 } });
+    if (ast.tag === 'arrayLiteral') {
+        return ofRange(ofToken(ast.start), ofToken(ast.end));
+    }
+    if (ast.tag === 'binaryOperator') {
+        return ofRange(span(ast.lhs), span(ast.rhs));
+    }
+    if (ast.tag === 'dot') {
+        return ofRange(span(ast.receiver), span(ast.ident));
+    }
+    if (ast.tag === 'functionCall') {
+        return ofRange(span(ast.callee), ofToken(ast.end));
+    }
+    if (ast.tag === 'ident') {
+        return ofToken(ast.t);
+    }
+    if (ast.tag === 'if') {
+        return ofRange(span(ast.condition), span(ast.negative));
+    }
+    if (ast.tag === 'indexAccess') {
+        return ofRange(span(ast.receiver), span(ast.index));
+    }
+    if (ast.tag === 'lambda') {
+        return ofRange(ofToken(ast.start), span(ast.body));
+    }
+    if (ast.tag === 'literal') {
+        return ofToken(ast.t);
+    }
+    if (ast.tag === 'objectLiteral') {
+        return ofRange(ofToken(ast.start), ofToken(ast.end));
+    }
+    if (ast.tag === 'topLevelExpression') {
+        const d0 = ast.definitions.find(Boolean);
+        const comp = span(ast.computation);
+        return ofRange(d0 ? ofToken(d0.start) : comp, comp);
+    }
+    if (ast.tag === 'unaryOperator') {
+        return ofRange(ofToken(ast.operatorToken), span(ast.operand));
+    }
+    (0, should_never_happen_1.shouldNeverHappen)(ast);
+}
+exports.span = span;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/cdl.d.ts

@@ -0,0 +1,33 @@
+import { Parser } from './parser';
+import { Result, ResultSink } from './result';
+import { Verbosity } from './runtime';
+interface Options {
+    /**
+     * A callback function to be invoked when the CDL program evaluated to `sink`. Allows the caller to determine which
+     * value will be returned in that case. For instance, passing `() => undefined` will translate a `sink` value to
+     * `undefined`. The default behavior is to throw an error.
+     */
+    onSink?: (res: ResultSink) => unknown;
+}
+export declare class Cdl {
+    readonly input: string;
+    private readonly scanner;
+    private readonly sourceCode;
+    private readonly parser;
+    /**
+     * Runs a CDL program and returns the value it evaluates to. If it evaluates to `sink`, returns the value computed
+     * by `options.onSink()` - if present, or throws an error - otherwise.
+     *
+     * This method is the simplest way to evaluate a CDL program. One can also use `.compute()` to get a higher degree
+     * of details about the result.
+     *
+     * @param input the source code of the CDL program
+     * @param options
+     * @returns the value that `input` evaluates to
+     */
+    static run(input: string, options?: Options): unknown;
+    constructor(input: string);
+    compute(verbosity?: Verbosity): Result;
+}
+export declare function parse(arg: string | Parser): import("./ast-node").AstNode;
+export {};

package/dist/src/cdl.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.Cdl = void 0;
+const parser_1 = require("./parser");
+const result_1 = require("./result");
+const runtime_1 = require("./runtime");
+const scanner_1 = require("./scanner");
+const should_never_happen_1 = require("./should-never-happen");
+const source_code_1 = require("./source-code");
+class Cdl {
+    constructor(input) {
+        this.input = input;
+        this.sourceCode = new source_code_1.SourceCode(this.input);
+        this.scanner = new scanner_1.Scanner(this.sourceCode);
+        this.parser = new parser_1.Parser(this.scanner);
+    }
+    /**
+     * Runs a CDL program and returns the value it evaluates to. If it evaluates to `sink`, returns the value computed
+     * by `options.onSink()` - if present, or throws an error - otherwise.
+     *
+     * This method is the simplest way to evaluate a CDL program. One can also use `.compute()` to get a higher degree
+     * of details about the result.
+     *
+     * @param input the source code of the CDL program
+     * @param options
+     * @returns the value that `input` evaluates to
+     */
+    static run(input, options) {
+        const onSink = options?.onSink ??
+            ((r) => {
+                throw new Error(r.message);
+            });
+        const res = new Cdl(input).compute();
+        if (res.tag === 'ok') {
+            return res.value;
+        }
+        if (res.tag === 'sink') {
+            return onSink(res);
+        }
+        (0, should_never_happen_1.shouldNeverHappen)(res);
+    }
+    compute(verbosity = 'quiet') {
+        const ast = parse(this.parser);
+        const runtime = new runtime_1.Runtime(ast, verbosity, this.parser);
+        const c = runtime.compute();
+        if (c.value) {
+            if (!c.value.isSink()) {
+                return { value: c.value.export(), tag: 'ok' };
+            }
+            return new result_1.ResultSinkImpl(c.value, this.sourceCode);
+        }
+        const runtimeErrorMessage = `${c.errorMessage} when evaluating:\n${this.sourceCode.formatTrace(c.expressionTrace)}`;
+        throw new Error(runtimeErrorMessage);
+    }
+}
+exports.Cdl = Cdl;
+function parse(arg) {
+    const parser = typeof arg === 'string' ? new parser_1.Parser(new scanner_1.Scanner(new source_code_1.SourceCode(arg))) : arg;
+    const ast = parser.parse();
+    return ast;
+}
+exports.parse = parse;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/extract-message.d.ts

@@ -0,0 +1 @@
+export declare function extractMessage(e: unknown): string | unknown;

package/dist/src/extract-message.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMessage = void 0;
+function extractMessage(e) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const typed = e;
+    return typed.message;
+}
+exports.extractMessage = extractMessage;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0cmFjdC1tZXNzYWdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2V4dHJhY3QtbWVzc2FnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxTQUFnQixjQUFjLENBQUMsQ0FBVTtJQUN2Qyx5RUFBeUU7SUFDekUsTUFBTSxLQUFLLEdBQUcsQ0FBeUIsQ0FBQTtJQUN2QyxPQUFPLEtBQUssQ0FBQyxPQUFPLENBQUE7QUFDdEIsQ0FBQztBQUpELHdDQUlDIn0=

package/dist/src/fail-me.d.ts

@@ -0,0 +1 @@
+export declare function failMe<R>(hint?: string): NonNullable<R>;

package/dist/src/fail-me.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failMe = void 0;
+function failMe(hint) {
+    if (!hint) {
+        throw new Error(`This expression must never be evaluated`);
+    }
+    throw new Error(`Bad value: ${hint}`);
+}
+exports.failMe = failMe;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFpbC1tZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mYWlsLW1lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLFNBQWdCLE1BQU0sQ0FBSSxJQUFhO0lBQ3JDLElBQUksQ0FBQyxJQUFJLEVBQUU7UUFDVCxNQUFNLElBQUksS0FBSyxDQUFDLHlDQUF5QyxDQUFDLENBQUE7S0FDM0Q7SUFFRCxNQUFNLElBQUksS0FBSyxDQUFDLGNBQWMsSUFBSSxFQUFFLENBQUMsQ0FBQTtBQUN2QyxDQUFDO0FBTkQsd0JBTUMifQ==

package/dist/src/find-array-method.d.ts

@@ -0,0 +1,15 @@
+import { Value } from './value';
+export declare type CallEvaluator = (callable: Value, args: Value[]) => Value;
+/**
+ * return an implementation for array methods. The following Array methods were not implemented
+ * as it is hard to find an intuitive immutable API due to their mutable nature:
+ *  - copyWithin
+ *  - fill
+ *  - forEach
+ *  - keys
+ *  - pop
+ *  - push
+ *  - shift
+ *  - unshift
+ */
+export declare function findArrayMethod(arr: unknown[], index: string, callEvaluator: CallEvaluator): Value;

package/dist/src/find-array-method.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findArrayMethod = void 0;
+const value_1 = require("./value");
+/**
+ * return an implementation for array methods. The following Array methods were not implemented
+ * as it is hard to find an intuitive immutable API due to their mutable nature:
+ *  - copyWithin
+ *  - fill
+ *  - forEach
+ *  - keys
+ *  - pop
+ *  - push
+ *  - shift
+ *  - unshift
+ */
+function findArrayMethod(arr, index, callEvaluator) {
+    const adjustedCallback = (callback) => (...args) => callEvaluator(callback, args.map(x => value_1.Value.from(x)));
+    const adjustedPredicate = (predicate) => (...args) => callEvaluator(predicate, args.map(x => value_1.Value.from(x))).assertBool();
+    if (index === 'at') {
+        return value_1.Value.foreign(n => arr.at(n.assertNum()));
+    }
+    if (index === 'concat') {
+        return value_1.Value.foreign(arg => arr.concat(arg.assertArr()));
+    }
+    if (index === 'entries') {
+        return value_1.Value.foreign(() => [...arr.entries()]);
+    }
+    if (index === 'every') {
+        return value_1.Value.foreign(predicate => arr.every(adjustedPredicate(predicate)));
+    }
+    if (index === 'filter') {
+        return value_1.Value.foreign(predicate => arr.filter(adjustedPredicate(predicate)));
+    }
+    if (index === 'find') {
+        return value_1.Value.foreign(predicate => arr.find(adjustedPredicate(predicate)));
+    }
+    if (index === 'findIndex') {
+        return value_1.Value.foreign(predicate => arr.findIndex(adjustedPredicate(predicate)));
+    }
+    if (index === 'flatMap') {
+        return value_1.Value.foreign(callback => flatten(arr.map(adjustedCallback(callback))));
+    }
+    if (index === 'flat') {
+        return value_1.Value.foreign(() => flatten(arr));
+    }
+    if (index === 'includes') {
+        return value_1.Value.foreign((arg) => arr.some(curr => value_1.Value.from(curr).equalsTo(arg).isTrue()));
+    }
+    if (index === 'indexOf') {
+        return value_1.Value.foreign(arg => arr.findIndex(curr => value_1.Value.from(curr).equalsTo(arg).isTrue()));
+    }
+    if (index === 'join') {
+        return value_1.Value.foreign(arg => arr.join(arg.assertStr()));
+    }
+    if (index === 'lastIndexOf') {
+        return value_1.Value.foreign(arg => {
+            for (let i = arr.length - 1; i >= 0; --i) {
+                if (value_1.Value.from(arr[i]).equalsTo(arg).isTrue()) {
+                    return i;
+                }
+            }
+            return -1;
+        });
+    }
+    if (index === 'length') {
+        return value_1.Value.num(arr.length);
+    }
+    if (index === 'map') {
+        return value_1.Value.foreign(callback => arr.map(adjustedCallback(callback)));
+    }
+    if (index === 'reverse') {
+        return value_1.Value.foreign(() => [...arr].reverse());
+    }
+    if (index === 'reduce') {
+        return value_1.Value.foreign((callback, initialValue) => arr.reduce(adjustedCallback(callback), initialValue));
+    }
+    if (index === 'reduceRight') {
+        return value_1.Value.foreign((callback, initialValue) => arr.reduceRight(adjustedCallback(callback), initialValue));
+    }
+    if (index === 'slice') {
+        return value_1.Value.foreign((start, end) => arr.slice(start?.assertNum(), end?.assertNum()));
+    }
+    if (index === 'some') {
+        return value_1.Value.foreign(predicate => arr.some(adjustedPredicate(predicate)));
+    }
+    throw new Error(`Unrecognized array method: ${index}`);
+}
+exports.findArrayMethod = findArrayMethod;
+function flatten(input) {
+    const ret = [];
+    for (const curr of input) {
+        const v = value_1.Value.from(curr);
+        const unwrapped = v.unwrap();
+        if (Array.isArray(unwrapped)) {
+            ret.push(...unwrapped);
+        }
+        else {
+            ret.push(v);
+        }
+    }
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC1hcnJheS1tZXRob2QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmluZC1hcnJheS1tZXRob2QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQStCO0FBRy9COzs7Ozs7Ozs7OztHQVdHO0FBQ0gsU0FBZ0IsZUFBZSxDQUFDLEdBQWMsRUFBRSxLQUFhLEVBQUUsYUFBNEI7SUFDekYsTUFBTSxnQkFBZ0IsR0FDcEIsQ0FBQyxRQUFlLEVBQUUsRUFBRSxDQUNwQixDQUFDLEdBQUcsSUFBZSxFQUFFLEVBQUUsQ0FDckIsYUFBYSxDQUNYLFFBQVEsRUFDUixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsYUFBSyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUM3QixDQUFBO0lBRUwsTUFBTSxpQkFBaUIsR0FDckIsQ0FBQyxTQUFnQixFQUFFLEVBQUUsQ0FDckIsQ0FBQyxHQUFHLElBQWUsRUFBRSxFQUFFLENBQ3JCLGFBQWEsQ0FDWCxTQUFTLEVBQ1QsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLGFBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FDN0IsQ0FBQyxVQUFVLEVBQUUsQ0FBQTtJQUVsQixJQUFJLEtBQUssS0FBSyxJQUFJLEVBQUU7UUFDbEIsT0FBTyxhQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFBO0tBQ2pEO0lBQ0QsSUFBSSxLQUFLLEtBQUssUUFBUSxFQUFFO1FBQ3RCLE9BQU8sYUFBSyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQTtLQUN6RDtJQUNELElBQUksS0FBSyxLQUFLLFNBQVMsRUFBRTtRQUN2QixPQUFPLGFBQUssQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQyxHQUFHLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDLENBQUE7S0FDL0M7SUFDRCxJQUFJLEtBQUssS0FBSyxPQUFPLEVBQUU7UUFDckIsT0FBTyxhQUFLLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUE7S0FDM0U7SUFDRCxJQUFJLEtBQUssS0FBSyxRQUFRLEVBQUU7UUFDdEIsT0FBTyxhQUFLLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUE7S0FDNUU7SUFDRCxJQUFJLEtBQUssS0FBSyxNQUFNLEVBQUU7UUFDcEIsT0FBTyxhQUFLLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUE7S0FDMUU7SUFDRCxJQUFJLEtBQUssS0FBSyxXQUFXLEVBQUU7UUFDekIsT0FBTyxhQUFLLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxpQkFBaUIsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUE7S0FDL0U7SUFDRCxJQUFJLEtBQUssS0FBSyxTQUFTLEVBQUU7UUFDdkIsT0FBTyxhQUFLLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUE7S0FDL0U7SUFDRCxJQUFJLEtBQUssS0FBSyxNQUFNLEVBQUU7UUFDcEIsT0FBTyxhQUFLLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFBO0tBQ3pDO0lBQ0QsSUFBSSxLQUFLLEtBQUssVUFBVSxFQUFFO1FBQ3hCLE9BQU8sYUFBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLEdBQVUsRUFBRSxFQUFFLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUMsQ0FBQTtLQUNoRztJQUNELElBQUksS0FBSyxLQUFLLFNBQVMsRUFBRTtRQUN2QixPQUFPLGFBQUssQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsYUFBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFBO0tBQzVGO0lBQ0QsSUFBSSxLQUFLLEtBQUssTUFBTSxFQUFFO1FBQ3BCLE9BQU8sYUFBSyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQTtLQUN2RDtJQUNELElBQUksS0FBSyxLQUFLLGFBQWEsRUFBRTtRQUMzQixPQUFPLGFBQUssQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDekIsS0FBSyxJQUFJLENBQUMsR0FBRyxHQUFHLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsQ0FBQyxFQUFFO2dCQUN4QyxJQUFJLGFBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLE1BQU0sRUFBRSxFQUFFO29CQUM3QyxPQUFPLENBQUMsQ0FBQTtpQkFDVDthQUNGO1lBQ0QsT0FBTyxDQUFDLENBQUMsQ0FBQTtRQUNYLENBQUMsQ0FBQyxDQUFBO0tBQ0g7SUFDRCxJQUFJLEtBQUssS0FBSyxRQUFRLEVBQUU7UUFDdEIsT0FBTyxhQUFLLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQTtLQUM3QjtJQUNELElBQUksS0FBSyxLQUFLLEtBQUssRUFBRTtRQUNuQixPQUFPLGFBQUssQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLGdCQUFnQixDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQTtLQUN0RTtJQUNELElBQUksS0FBSyxLQUFLLFNBQVMsRUFBRTtRQUN2QixPQUFPLGFBQUssQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQyxHQUFHLEdBQUcsQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUE7S0FDL0M7SUFDRCxJQUFJLEtBQUssS0FBSyxRQUFRLEVBQUU7UUFDdEIsT0FBTyxhQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsUUFBUSxFQUFFLFlBQVksRUFBRSxFQUFFLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxRQUFRLENBQUMsRUFBRSxZQUFZLENBQUMsQ0FBQyxDQUFBO0tBQ3ZHO0lBQ0QsSUFBSSxLQUFLLEtBQUssYUFBYSxFQUFFO1FBQzNCLE9BQU8sYUFBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLFFBQVEsRUFBRSxZQUFZLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxXQUFXLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxDQUFDLEVBQUUsWUFBWSxDQUFDLENBQUMsQ0FBQTtLQUM1RztJQUNELElBQUksS0FBSyxLQUFLLE9BQU8sRUFBRTtRQUNyQixPQUFPLGFBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxLQUFLLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBRSxTQUFTLEVBQUUsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFBO0tBQ3RGO0lBQ0QsSUFBSSxLQUFLLEtBQUssTUFBTSxFQUFFO1FBQ3BCLE9BQU8sYUFBSyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFBO0tBQzFFO0lBQ0QsTUFBTSxJQUFJLEtBQUssQ0FBQyw4QkFBOEIsS0FBSyxFQUFFLENBQUMsQ0FBQTtBQUN4RCxDQUFDO0FBckZELDBDQXFGQztBQUVELFNBQVMsT0FBTyxDQUFDLEtBQWdCO0lBQy9CLE1BQU0sR0FBRyxHQUFHLEVBQUUsQ0FBQTtJQUNkLEtBQUssTUFBTSxJQUFJLElBQUksS0FBSyxFQUFFO1FBQ3hCLE1BQU0sQ0FBQyxHQUFHLGFBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUE7UUFDMUIsTUFBTSxTQUFTLEdBQUcsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFBO1FBQzVCLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRTtZQUM1QixHQUFHLENBQUMsSUFBSSxDQUFDLEdBQUcsU0FBUyxDQUFDLENBQUE7U0FDdkI7YUFBTTtZQUNMLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUE7U0FDWjtLQUNGO0lBQ0QsT0FBTyxHQUFHLENBQUE7QUFDWixDQUFDIn0=

package/dist/src/find-string-method.d.ts

@@ -0,0 +1,2 @@
+import { Value } from './value';
+export declare function findStringMethod(s: string, indexValue: string | Value): Value;

package/dist/src/find-string-method.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findStringMethod = void 0;
+const value_1 = require("./value");
+function findStringMethod(s, indexValue) {
+    const index = value_1.Value.toStringOrNumber(indexValue);
+    if (typeof index === 'number') {
+        throw new Error(`Index is of type number - not supported`);
+    }
+    if (index === 'at') {
+        return value_1.Value.foreign(n => s.at(n.assertNum()));
+    }
+    if (index === 'charAt') {
+        return value_1.Value.foreign(n => s.charAt(n.assertNum()));
+    }
+    if (index === 'concat') {
+        return value_1.Value.foreign(arg => s.concat(arg.assertStr()));
+    }
+    if (index === 'endsWith') {
+        return value_1.Value.foreign(arg => s.endsWith(arg.assertStr()));
+    }
+    if (index === 'includes') {
+        return value_1.Value.foreign(arg => s.includes(arg.assertStr()));
+    }
+    if (index === 'indexOf') {
+        return value_1.Value.foreign(searchString => s.indexOf(searchString.assertStr()));
+    }
+    if (index === 'lastIndexOf') {
+        return value_1.Value.foreign(searchString => s.lastIndexOf(searchString.assertStr()));
+    }
+    if (index === 'length') {
+        return value_1.Value.num(s.length);
+    }
+    if (index === 'match') {
+        return value_1.Value.foreign(r => s.match(r.assertStr()));
+    }
+    if (index === 'matchAll') {
+        return value_1.Value.foreign(r => [...s.matchAll(new RegExp(r.assertStr(), 'g'))]);
+    }
+    if (index === 'padEnd') {
+        return value_1.Value.foreign((maxLength, fillString) => s.padEnd(maxLength.assertNum(), fillString?.assertStr()));
+    }
+    if (index === 'padStart') {
+        return value_1.Value.foreign((maxLength, fillString) => s.padStart(maxLength.assertNum(), fillString?.assertStr()));
+    }
+    if (index === 'repeat') {
+        return value_1.Value.foreign(count => s.repeat(count.assertNum()));
+    }
+    if (index === 'replace') {
+        return value_1.Value.foreign((searchValue, replacer) => s.replace(searchValue.assertStr(), replacer.assertStr()));
+    }
+    if (index === 'replaceAll') {
+        return value_1.Value.foreign((searchValue, replacer) => s.replaceAll(searchValue.assertStr(), replacer.assertStr()));
+    }
+    if (index === 'search') {
+        return value_1.Value.foreign(searcher => s.search(searcher.assertStr()));
+    }
+    if (index === 'slice') {
+        return value_1.Value.foreign((start, end) => s.slice(start?.assertNum(), end?.assertNum()));
+    }
+    if (index === 'split') {
+        return value_1.Value.foreign(splitter => s.split(splitter.assertStr()));
+    }
+    if (index === 'startsWith') {
+        return value_1.Value.foreign(arg => s.startsWith(arg.assertStr()));
+    }
+    if (index === 'substring') {
+        return value_1.Value.foreign((start, end) => s.substring(start.assertNum(), end?.assertNum()));
+    }
+    if (index === 'toLowerCase') {
+        return value_1.Value.foreign(() => s.toLowerCase());
+    }
+    if (index === 'toUpperCase') {
+        return value_1.Value.foreign(() => s.toUpperCase());
+    }
+    if (index === 'trim') {
+        return value_1.Value.foreign(() => s.trim());
+    }
+    if (index === 'trimEnd') {
+        return value_1.Value.foreign(() => s.trimEnd());
+    }
+    if (index === 'trimStart') {
+        return value_1.Value.foreign(() => s.trimStart());
+    }
+    throw new Error(`Unrecognized string method: ${index}`);
+}
+exports.findStringMethod = findStringMethod;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export * from './cdl';

package/dist/src/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cdl"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdDQUFxQiJ9

package/dist/src/location.d.ts

@@ -0,0 +1,11 @@
+export interface Location {
+    readonly offset: number;
+}
+export interface Span {
+    from: Location;
+    to: Location;
+}
+export interface Location2d {
+    line: number;
+    col: number;
+}

package/dist/src/location.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbG9jYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/src/parser.d.ts

@@ -0,0 +1,37 @@
+import { AstNode, Let } from './ast-node';
+import { Scanner, Token } from './scanner';
+export declare class Parser {
+    private readonly scanner;
+    constructor(scanner: Scanner);
+    parse(): AstNode;
+    definitions(): Let[];
+    expression(): AstNode;
+    lambda(): AstNode;
+    ifExpression(): AstNode;
+    unsink(): AstNode;
+    or(): AstNode;
+    and(): AstNode;
+    equality(): AstNode;
+    comparison(): AstNode;
+    addition(): AstNode;
+    multiplication(): AstNode;
+    power(): AstNode;
+    unary(): AstNode;
+    call(): AstNode;
+    private actualArgList;
+    memberAccess(): AstNode;
+    parenthesized(): AstNode;
+    literalOrIdent(): AstNode;
+    /**
+     * 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: Token): AstNode;
+    /**
+     * 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: Token): AstNode;
+    private identifier;
+    private maybeIdentifier;
+}