@enspirit/elo 0.9.0

package/dist/src/parser.d.ts

@@ -0,0 +1,137 @@
+import { Expr } from './ast';
+export interface ParserOptions {
+    maxDepth?: number;
+}
+export declare class Parser {
+    private lexer;
+    private currentToken;
+    private depth;
+    private maxDepth;
+    constructor(input: string, options?: ParserOptions);
+    private checkDepth;
+    private saveState;
+    private restoreState;
+    private formatLocation;
+    private eat;
+    private primary;
+    private postfix;
+    private unary;
+    private power;
+    private factor;
+    private term;
+    private addition;
+    private comparison;
+    private equality;
+    private logical_and;
+    /**
+     * Parse alternative expressions: a | b | c
+     * Returns first non-null value, left-to-right evaluation.
+     */
+    private alternative;
+    private logical_or;
+    /**
+     * Parse pipe expressions: a |> f(b) |> g(c) or a |> f |> g
+     * Desugars to: g(f(a, b), c) or g(f(a))
+     * Left-associative, lowest precedence (below logical_or)
+     * Parentheses are optional: a |> f is equivalent to a |> f()
+     */
+    private pipe;
+    /**
+     * Try to parse range membership: expr in expr..expr or expr in expr...expr
+     * Also handles: expr not in expr..expr (when negated is true)
+     * Returns null if this is not a range expression (e.g., it's 'in' from 'let...in')
+     */
+    private tryParseRangeMembership;
+    /**
+     * Desugar range membership expression.
+     * `value in start..end` becomes `value >= start and value <= end`
+     * `value in start...end` becomes `value >= start and value < end`
+     *
+     * For complex expressions, wraps in let to avoid multiple evaluation.
+     */
+    private desugarRangeMembership;
+    private letExpr;
+    /**
+     * Parse a type definition: let Person = { name: String, age: Int } in body
+     * Called after 'let' when we see an UPPER_IDENTIFIER
+     * Supports multiple bindings: let Person = {...}, Persons = [Person] in body
+     */
+    private typeDefExpr;
+    /**
+     * Parse remaining let bindings after a comma (when mixing type and value bindings)
+     * Returns a LetExpr with the remaining bindings
+     */
+    private parseLetBindingsAfterComma;
+    /**
+     * Parse a type expression: String, Int|String, Int(i | i > 0), [Int], { prop: TypeExpr, ... }
+     * Handles union types: Int|String|Bool
+     */
+    private typeExpr;
+    /**
+     * Parse a primary type expression (without union)
+     */
+    private typeExprPrimary;
+    /**
+     * Parse a subtype constraint: Int(i | i > 0)
+     * Called after the base type has been parsed, when we see '('
+     */
+    private subtypeConstraintExpr;
+    /**
+     * Parse a type schema: { name: String, age: Int, nickname :? String, ... } or { name: String, ...: Int }
+     * extras:
+     * - { x: Int } - closed, no extra attrs allowed
+     * - { x: Int, ... } - ignored, extra attrs allowed but not included
+     * - { x: Int, ...: String } - typed, extra attrs must match type
+     */
+    private typeSchemaExpr;
+    private ifExprParse;
+    /**
+     * Parse lambda expression: fn( ~> body ) or fn( x ~> body ) or fn( x, y ~> body )
+     */
+    private lambdaParse;
+    /**
+     * Parse object literal: {key: value, key2: value2, ...}
+     */
+    private objectParse;
+    /**
+     * Parse array literal: [expr, expr, ...]
+     */
+    private arrayParse;
+    /**
+     * Parse datapath literal: .x.y.z or .items.0.name
+     * Grammar: '.' pathSegment ('.' pathSegment)*
+     * pathSegment: IDENTIFIER | NUMBER
+     *
+     * Note: The lexer may tokenize "0.1" as a single NUMBER token when parsing
+     * consecutive numeric segments. We handle this by splitting such tokens.
+     * The lexer also treats ".0" as a NUMBER token (decimal number starting with dot).
+     */
+    private datapathParse;
+    /**
+     * Parse additional path segments after the first one
+     */
+    private parseAdditionalPathSegments;
+    /**
+     * Check if current token is a NUMBER that starts with a dot (e.g., ".0")
+     * This happens when the lexer treats ".0" as a decimal number
+     */
+    private isDecimalNumberToken;
+    /**
+     * Parse path segments from a NUMBER token.
+     * A NUMBER token like "0.1" in datapath context should become segments [0, 1].
+     * Returns the array of integer segments, or null if not a valid NUMBER.
+     */
+    private parseNumericPathSegments;
+    /**
+     * Parse a single path segment: IDENTIFIER or integer NUMBER
+     * Returns null if current token is not a valid segment.
+     */
+    private parsePathSegment;
+    private expr;
+    parse(): Expr;
+}
+/**
+ * Parse an arithmetic expression string into an AST
+ */
+export declare function parse(input: string, options?: ParserOptions): Expr;
+//# sourceMappingURL=parser.d.ts.map

package/dist/src/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAiX,MAAM,OAAO,CAAC;AAuf5Y,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAID,qBAAa,MAAM;IACjB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,QAAQ,CAAS;gBAEb,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB;IAMtD,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,GAAG;IAUX,OAAO,CAAC,OAAO;IAwJf,OAAO,CAAC,OAAO;IA8Bf,OAAO,CAAC,KAAK;IAmBb,OAAO,CAAC,KAAK;IAYb,OAAO,CAAC,MAAM;IAqBd,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,QAAQ;IAkBhB,OAAO,CAAC,UAAU;IA4ClB,OAAO,CAAC,QAAQ;IAkBhB,OAAO,CAAC,WAAW;IAWnB;;;OAGG;IACH,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,UAAU;IAWlB;;;;;OAKG;IACH,OAAO,CAAC,IAAI;IA0CZ;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAwC/B;;;;;;OAMG;IACH,OAAO,CAAC,sBAAsB;IA+B9B,OAAO,CAAC,OAAO;IAkCf;;;;OAIG;IACH,OAAO,CAAC,WAAW;IA4BnB;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IA0BlC;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAgBhB;;OAEG;IACH,OAAO,CAAC,eAAe;IAuCvB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAkB7B;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAuEtB,OAAO,CAAC,WAAW;IAUnB;;OAEG;IACH,OAAO,CAAC,WAAW;IA8BnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAgCnB;;OAEG;IACH,OAAO,CAAC,UAAU;IAwBlB;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IA0BrB;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAsCnC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;;;OAIG;IACH,OAAO,CAAC,wBAAwB;IAYhC;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,IAAI;IAiBZ,KAAK,IAAI,IAAI;CAKd;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,IAAI,CAGtE"}