@rcrsr/rill 0.1.0 → 0.2.0

package/dist/parser/arithmetic.js

@@ -1,128 +0,0 @@
-/**
- * Arithmetic Expression Parsing
- * Handles | expr | arithmetic expressions
- */
-import { ParseError, TOKEN_TYPES } from '../types.js';
-import { check, advance, expect, current, makeSpan } from './state.js';
-import { parseVariable } from './variables.js';
-// ============================================================
-// ARITHMETIC EXPRESSIONS
-// ============================================================
-/**
- * Parse arithmetic expression: | expr |
- * Grammar:
- *   arith-expr = "|" additive "|"
- *   additive   = multiplicative { ("+" | "-") multiplicative }
- *   multiplicative = factor { ("*" | "/" | "%") factor }
- *   factor     = number | variable | "(" additive ")" | "-" factor
- */
-export function parseArithmetic(state) {
-    const start = current(state).span.start;
-    expect(state, TOKEN_TYPES.PIPE_BAR, 'Expected |');
-    const expr = parseArithAdditive(state);
-    expect(state, TOKEN_TYPES.PIPE_BAR, 'Expected closing |');
-    return {
-        ...expr,
-        span: makeSpan(start, current(state).span.end),
-    };
-}
-function parseArithAdditive(state) {
-    const start = current(state).span.start;
-    let left = parseArithMultiplicative(state);
-    while (check(state, TOKEN_TYPES.PLUS, TOKEN_TYPES.MINUS)) {
-        const opToken = advance(state);
-        const op = opToken.type === TOKEN_TYPES.PLUS ? '+' : '-';
-        const right = parseArithMultiplicative(state);
-        left = {
-            type: 'Arithmetic',
-            op,
-            left,
-            right,
-            span: makeSpan(start, current(state).span.end),
-        };
-    }
-    return left;
-}
-function parseArithMultiplicative(state) {
-    const start = current(state).span.start;
-    let left = parseArithFactor(state);
-    while (check(state, TOKEN_TYPES.STAR, TOKEN_TYPES.SLASH, TOKEN_TYPES.PERCENT)) {
-        const opToken = advance(state);
-        let op;
-        switch (opToken.type) {
-            case TOKEN_TYPES.STAR:
-                op = '*';
-                break;
-            case TOKEN_TYPES.SLASH:
-                op = '/';
-                break;
-            default:
-                op = '%';
-        }
-        const right = parseArithFactor(state);
-        left = {
-            type: 'Arithmetic',
-            op,
-            left,
-            right,
-            span: makeSpan(start, current(state).span.end),
-        };
-    }
-    return left;
-}
-function parseArithFactor(state) {
-    const start = current(state).span.start;
-    // Unary minus
-    if (check(state, TOKEN_TYPES.MINUS)) {
-        advance(state);
-        const operand = parseArithFactor(state);
-        // Represent -x as (0 - x)
-        const zero = {
-            type: 'NumberLiteral',
-            value: 0,
-            span: makeSpan(start, start),
-        };
-        return {
-            type: 'Arithmetic',
-            op: '-',
-            left: zero,
-            right: operand,
-            span: makeSpan(start, current(state).span.end),
-        };
-    }
-    // Grouped expression
-    if (check(state, TOKEN_TYPES.LPAREN)) {
-        advance(state);
-        const expr = parseArithAdditive(state);
-        expect(state, TOKEN_TYPES.RPAREN, 'Expected )');
-        return expr;
-    }
-    // Number literal
-    if (check(state, TOKEN_TYPES.NUMBER)) {
-        const token = advance(state);
-        return {
-            type: 'Arithmetic',
-            op: null,
-            left: {
-                type: 'NumberLiteral',
-                value: parseFloat(token.value),
-                span: token.span,
-            },
-            right: null,
-            span: token.span,
-        };
-    }
-    // Variable ($ or $name)
-    if (check(state, TOKEN_TYPES.DOLLAR, TOKEN_TYPES.PIPE_VAR)) {
-        const variable = parseVariable(state);
-        return {
-            type: 'Arithmetic',
-            op: null,
-            left: variable,
-            right: null,
-            span: variable.span,
-        };
-    }
-    throw new ParseError(`Expected number or variable in arithmetic, got: ${current(state).value}`, current(state).span.start);
-}
-//# sourceMappingURL=arithmetic.js.map

package/dist/parser/arithmetic.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"arithmetic.js","sourceRoot":"","sources":["../../src/parser/arithmetic.ts"],"names":[],"mappings":"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"}

package/dist/parser/boolean.d.ts

@@ -1,15 +0,0 @@
-/**
- * Boolean Expression Parsing - Circular Dependency Helpers
- *
- * This module only contains setter functions for breaking circular dependencies.
- * Boolean/logical operators (&&, ||, !) are now part of the main expression grammar
- * in expressions.ts.
- */
-import type { BlockNode, GroupedExprNode } from '../types.js';
-import type { ParserState } from './state.js';
-declare let parseGroupedFn: (state: ParserState) => GroupedExprNode;
-export declare function setParseGrouped(fn: (state: ParserState) => GroupedExprNode): void;
-declare let parseBlockFn: (state: ParserState) => BlockNode;
-export declare function setParseBlock(fn: (state: ParserState) => BlockNode): void;
-export { parseGroupedFn, parseBlockFn };
-//# sourceMappingURL=boolean.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../src/parser/boolean.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAG9C,QAAA,IAAI,cAAc,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,eAAe,CAAC;AAE5D,wBAAgB,eAAe,CAC7B,EAAE,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,eAAe,GAC1C,IAAI,CAEN;AAGD,QAAA,IAAI,YAAY,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,SAAS,CAAC;AAEpD,wBAAgB,aAAa,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,SAAS,GAAG,IAAI,CAEzE;AAGD,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,CAAC"}

package/dist/parser/boolean.js

@@ -1,20 +0,0 @@
-/**
- * Boolean Expression Parsing - Circular Dependency Helpers
- *
- * This module only contains setter functions for breaking circular dependencies.
- * Boolean/logical operators (&&, ||, !) are now part of the main expression grammar
- * in expressions.ts.
- */
-// Forward declaration for grouped expression parsing
-let parseGroupedFn;
-export function setParseGrouped(fn) {
-    parseGroupedFn = fn;
-}
-// Forward declaration - will be set to break circular dependency
-let parseBlockFn;
-export function setParseBlock(fn) {
-    parseBlockFn = fn;
-}
-// Re-export for any code that might still use these
-export { parseGroupedFn, parseBlockFn };
-//# sourceMappingURL=boolean.js.map

package/dist/parser/boolean.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../../src/parser/boolean.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,qDAAqD;AACrD,IAAI,cAAuD,CAAC;AAE5D,MAAM,UAAU,eAAe,CAC7B,EAA2C;IAE3C,cAAc,GAAG,EAAE,CAAC;AACtB,CAAC;AAED,iEAAiE;AACjE,IAAI,YAA+C,CAAC;AAEpD,MAAM,UAAU,aAAa,CAAC,EAAqC;IACjE,YAAY,GAAG,EAAE,CAAC;AACpB,CAAC;AAED,oDAAoD;AACpD,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,CAAC"}

package/dist/parser/control-flow.d.ts

@@ -1,56 +0,0 @@
-/**
- * Control Flow Parsing
- * Conditionals, loops, and blocks
- *
- * New loop syntax (v0.0.2):
- *   loop = [ simple-body ] , "@" , simple-body , [ "?" , simple-body ]
- *
- * Semantics (determined at runtime):
- *   - If input is bool and no trailing "?": while loop
- *   - If input is list and no trailing "?": for-each
- *   - If no input and no trailing "?": for-each over $
- *   - If trailing "? cond": do-while
- */
-import type { AnnotatedStatementNode, BlockNode, ConditionalNode, DoWhileLoopNode, ExpressionNode, ForLoopNode, BodyNode, StatementNode } from '../types.js';
-import { type ParserState } from './state.js';
-export declare function setParseStatement(fn: (state: ParserState) => StatementNode | AnnotatedStatementNode): void;
-/**
- * Parse piped conditional: ? then_body [! else_body]
- * Called when bare `?` is seen (condition is implicit $).
- */
-export declare function parsePipedConditional(state: ParserState): ConditionalNode;
-/**
- * Parse conditional after condition is already parsed: ? then_body [! else_body]
- * Called when we've parsed an expression and see `?` following it.
- */
-export declare function parseConditionalWithCondition(state: ParserState, conditionBody: BodyNode): ConditionalNode;
-/**
- * Parse the rest of a conditional after `?` is consumed.
- * Grammar: then_body [! (conditional | else_body)]
- */
-export declare function parseConditionalRest(state: ParserState, condition: BodyNode | null, start: {
-    line: number;
-    column: number;
-    offset: number;
-}): ConditionalNode;
-/**
- * Parse loop starting with @: @ body [? cond]
- *
- * New syntax:
- *   @ body           - for-each over $
- *   @ body ? cond    - do-while (body first, then check)
- *
- * Called when bare `@` is seen (no input expression).
- */
-export declare function parseLoop(state: ParserState, input: ExpressionNode | null): ForLoopNode | DoWhileLoopNode;
-/**
- * Parse loop with input: input @ body
- *
- * New syntax:
- *   input @ body     - while (if input is bool) or for-each (if input is list)
- *
- * Called when we've parsed an expression and see `@` following it.
- */
-export declare function parseLoopWithInput(state: ParserState, input: BodyNode): ForLoopNode | DoWhileLoopNode;
-export declare function parseBlock(state: ParserState): BlockNode;
-//# sourceMappingURL=control-flow.d.ts.map

package/dist/parser/control-flow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"control-flow.d.ts","sourceRoot":"","sources":["../../src/parser/control-flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,SAAS,EACT,eAAe,EACf,eAAe,EACf,cAAc,EACd,WAAW,EACX,QAAQ,EACR,aAAa,EACd,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,KAAK,WAAW,EAQjB,MAAM,YAAY,CAAC;AAQpB,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,aAAa,GAAG,sBAAsB,GACjE,IAAI,CAEN;AAMD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,WAAW,GAAG,eAAe,CAKzE;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,WAAW,EAClB,aAAa,EAAE,QAAQ,GACtB,eAAe,CAKjB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,QAAQ,GAAG,IAAI,EAC1B,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACtD,eAAe,CA6BjB;AAMD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,cAAc,GAAG,IAAI,GAC3B,WAAW,GAAG,eAAe,CA4B/B;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,QAAQ,GACd,WAAW,GAAG,eAAe,CAyB/B;AAMD,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,CAuBxD"}

package/dist/parser/control-flow.js

@@ -1,167 +0,0 @@
-/**
- * Control Flow Parsing
- * Conditionals, loops, and blocks
- *
- * New loop syntax (v0.0.2):
- *   loop = [ simple-body ] , "@" , simple-body , [ "?" , simple-body ]
- *
- * Semantics (determined at runtime):
- *   - If input is bool and no trailing "?": while loop
- *   - If input is list and no trailing "?": for-each
- *   - If no input and no trailing "?": for-each over $
- *   - If trailing "? cond": do-while
- */
-import { ParseError, TOKEN_TYPES } from '../types.js';
-import { check, advance, expect, current, isAtEnd, skipNewlines, makeSpan, } from './state.js';
-import { parseBody } from './literals.js';
-// Forward declarations - will be set to break circular dependencies
-let parseStatementFn;
-export function setParseStatement(fn) {
-    parseStatementFn = fn;
-}
-// ============================================================
-// CONDITIONALS
-// ============================================================
-/**
- * Parse piped conditional: ? then_body [! else_body]
- * Called when bare `?` is seen (condition is implicit $).
- */
-export function parsePipedConditional(state) {
-    const start = current(state).span.start;
-    expect(state, TOKEN_TYPES.QUESTION, 'Expected ?');
-    return parseConditionalRest(state, null, start);
-}
-/**
- * Parse conditional after condition is already parsed: ? then_body [! else_body]
- * Called when we've parsed an expression and see `?` following it.
- */
-export function parseConditionalWithCondition(state, conditionBody) {
-    const start = conditionBody.span.start;
-    expect(state, TOKEN_TYPES.QUESTION, 'Expected ?');
-    return parseConditionalRest(state, conditionBody, start);
-}
-/**
- * Parse the rest of a conditional after `?` is consumed.
- * Grammar: then_body [! (conditional | else_body)]
- */
-export function parseConditionalRest(state, condition, start) {
-    // Parse then branch - can be block, grouped, or postfix-expr
-    const thenBranch = parseBody(state);
-    // Optional else clause with `!` (not `:`)
-    let elseBranch = null;
-    if (check(state, TOKEN_TYPES.BANG)) {
-        advance(state);
-        // Check if this is else-if (another condition followed by ?)
-        // We need to parse a simple-body first, then check for ?
-        const elseBody = parseBody(state);
-        // If followed by ?, this is else-if chaining
-        if (check(state, TOKEN_TYPES.QUESTION)) {
-            elseBranch = parseConditionalWithCondition(state, elseBody);
-        }
-        else {
-            elseBranch = elseBody;
-        }
-    }
-    return {
-        type: 'Conditional',
-        input: null,
-        condition,
-        thenBranch,
-        elseBranch,
-        span: makeSpan(start, current(state).span.end),
-    };
-}
-// ============================================================
-// LOOPS
-// ============================================================
-/**
- * Parse loop starting with @: @ body [? cond]
- *
- * New syntax:
- *   @ body           - for-each over $
- *   @ body ? cond    - do-while (body first, then check)
- *
- * Called when bare `@` is seen (no input expression).
- */
-export function parseLoop(state, input) {
-    const start = input ? input.span.start : current(state).span.start;
-    expect(state, TOKEN_TYPES.AT, 'Expected @');
-    // Parse body - can be block, grouped, or postfix-expr
-    const body = parseBody(state);
-    // Check for do-while post-condition: @ body ? cond
-    if (check(state, TOKEN_TYPES.QUESTION)) {
-        advance(state); // consume ?
-        const condition = parseBody(state);
-        return {
-            type: 'DoWhileLoop',
-            input,
-            body,
-            condition,
-            span: makeSpan(start, current(state).span.end),
-        };
-    }
-    // Regular loop (for-each or while, determined at runtime)
-    return {
-        type: 'ForLoop',
-        input,
-        body,
-        span: makeSpan(start, current(state).span.end),
-    };
-}
-/**
- * Parse loop with input: input @ body
- *
- * New syntax:
- *   input @ body     - while (if input is bool) or for-each (if input is list)
- *
- * Called when we've parsed an expression and see `@` following it.
- */
-export function parseLoopWithInput(state, input) {
-    // Convert BodyNode to ExpressionNode (wrap if needed)
-    let inputExpr;
-    if (input.type === 'PipeChain') {
-        inputExpr = input;
-    }
-    else {
-        // Wrap in PipeChain
-        inputExpr = {
-            type: 'PipeChain',
-            head: input.type === 'PostfixExpr'
-                ? input
-                : {
-                    type: 'PostfixExpr',
-                    primary: input,
-                    methods: [],
-                    span: input.span,
-                },
-            pipes: [],
-            terminator: null,
-            span: input.span,
-        };
-    }
-    return parseLoop(state, inputExpr);
-}
-// ============================================================
-// BLOCKS
-// ============================================================
-export function parseBlock(state) {
-    const start = current(state).span.start;
-    expect(state, TOKEN_TYPES.LBRACE, 'Expected {');
-    skipNewlines(state);
-    const statements = [];
-    while (!check(state, TOKEN_TYPES.RBRACE) && !isAtEnd(state)) {
-        statements.push(parseStatementFn(state));
-        skipNewlines(state);
-    }
-    // Empty blocks are not allowed - blocks must contain at least one statement
-    if (statements.length === 0) {
-        throw new ParseError('Empty blocks are not allowed', start);
-    }
-    expect(state, TOKEN_TYPES.RBRACE, 'Expected }');
-    return {
-        type: 'Block',
-        statements,
-        span: makeSpan(start, current(state).span.end),
-    };
-}
-//# sourceMappingURL=control-flow.js.map

package/dist/parser/control-flow.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"control-flow.js","sourceRoot":"","sources":["../../src/parser/control-flow.ts"],"names":[],"mappings":"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"}

package/dist/parser/expressions.d.ts

@@ -1,23 +0,0 @@
-/**
- * Expression Parsing
- * Primary expressions, postfix expressions, pipe chains, and pipe targets
- */
-import type { CaptureNode, ExpressionNode, GroupedExprNode, PipeChainNode, PipeTargetNode, PostfixExprNode, PrimaryNode, SourceLocation } from '../types.js';
-import { type ParserState } from './state.js';
-export declare function parseExpression(state: ParserState): ExpressionNode;
-export declare function parsePipeChain(state: ParserState): PipeChainNode;
-export declare function parsePostfixExpr(state: ParserState): PostfixExprNode;
-export declare function parsePrimary(state: ParserState): PrimaryNode;
-export declare function parsePipeTarget(state: ParserState): PipeTargetNode;
-export declare function parseCapture(state: ParserState): CaptureNode;
-export declare function makePipeChain(primary: PrimaryNode, start: SourceLocation): PipeChainNode;
-/**
- * Grouped expression: ( expression )
- * Single-expression block with () delimiters.
- * Provides scoping — captures inside are local.
- *
- * Note: Boolean operators (&&, ||, !) are only supported in while loop
- * conditions @(condition), not in general grouped expressions.
- */
-export declare function parseGrouped(state: ParserState): GroupedExprNode;
-//# sourceMappingURL=expressions.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../src/parser/expressions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAIV,WAAW,EAMX,cAAc,EAId,eAAe,EAIf,aAAa,EACb,cAAc,EACd,eAAe,EACf,WAAW,EACX,cAAc,EAMf,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,KAAK,WAAW,EAOjB,MAAM,YAAY,CAAC;AAsKpB,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,cAAc,CAElE;AA4BD,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,aAAa,CAyIhE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,eAAe,CAYpE;AAoHD,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CAwD5D;AAMD,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,cAAc,CAkHlE;AAMD,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CAsB5D;AAMD,wBAAgB,aAAa,CAC3B,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,cAAc,GACpB,aAAa,CAaf;AAMD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,eAAe,CAUhE"}