@elwood-lang/core 0.1.0

package/dist/scope.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Variable scope for Elwood evaluation. Supports nested scopes (let bindings, lambdas).
+ */
+export declare class Scope {
+    private parent?;
+    private vars;
+    constructor(parent?: Scope | undefined);
+    set(name: string, value: unknown): void;
+    get(name: string): unknown | undefined;
+    has(name: string): boolean;
+    child(): Scope;
+}
+//# sourceMappingURL=scope.d.ts.map

package/dist/scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../src/scope.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,KAAK;IAGJ,OAAO,CAAC,MAAM,CAAC;IAF3B,OAAO,CAAC,IAAI,CAA8B;gBAEtB,MAAM,CAAC,EAAE,KAAK,YAAA;IAElC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAIvC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAKtC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAK1B,KAAK,IAAI,KAAK;CAGf"}

package/dist/scope.js

@@ -0,0 +1,27 @@
+/**
+ * Variable scope for Elwood evaluation. Supports nested scopes (let bindings, lambdas).
+ */
+export class Scope {
+    parent;
+    vars = new Map();
+    constructor(parent) {
+        this.parent = parent;
+    }
+    set(name, value) {
+        this.vars.set(name, value);
+    }
+    get(name) {
+        if (this.vars.has(name))
+            return this.vars.get(name);
+        return this.parent?.get(name);
+    }
+    has(name) {
+        if (this.vars.has(name))
+            return true;
+        return this.parent?.has(name) ?? false;
+    }
+    child() {
+        return new Scope(this);
+    }
+}
+//# sourceMappingURL=scope.js.map

package/dist/scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.js","sourceRoot":"","sources":["../src/scope.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,OAAO,KAAK;IAGI;IAFZ,IAAI,GAAG,IAAI,GAAG,EAAmB,CAAC;IAE1C,YAAoB,MAAc;QAAd,WAAM,GAAN,MAAM,CAAQ;IAAG,CAAC;IAEtC,GAAG,CAAC,IAAY,EAAE,KAAc;QAC9B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED,GAAG,CAAC,IAAY;QACd,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACpD,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,GAAG,CAAC,IAAY;QACd,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QACrC,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC;IACzC,CAAC;IAED,KAAK;QACH,OAAO,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;CACF"}

package/dist/token.d.ts

@@ -0,0 +1,65 @@
+export declare enum TokenKind {
+    StringLiteral = "StringLiteral",
+    NumberLiteral = "NumberLiteral",
+    TrueLiteral = "TrueLiteral",
+    FalseLiteral = "FalseLiteral",
+    NullLiteral = "NullLiteral",
+    Identifier = "Identifier",
+    Dollar = "Dollar",
+    DollarDot = "DollarDot",
+    Dot = "Dot",
+    DotDot = "DotDot",
+    LeftBracket = "LeftBracket",
+    RightBracket = "RightBracket",
+    LeftParen = "LeftParen",
+    RightParen = "RightParen",
+    LeftBrace = "LeftBrace",
+    RightBrace = "RightBrace",
+    Pipe = "Pipe",
+    FatArrow = "FatArrow",
+    Comma = "Comma",
+    Colon = "Colon",
+    Star = "Star",
+    Spread = "Spread",
+    Plus = "Plus",
+    Minus = "Minus",
+    Slash = "Slash",
+    Assign = "Assign",
+    EqualEqual = "EqualEqual",
+    BangEqual = "BangEqual",
+    LessThan = "LessThan",
+    LessThanOrEqual = "LessThanOrEqual",
+    GreaterThan = "GreaterThan",
+    GreaterThanOrEqual = "GreaterThanOrEqual",
+    AmpersandAmpersand = "AmpersandAmpersand",
+    PipePipe = "PipePipe",
+    Bang = "Bang",
+    Let = "Let",
+    If = "If",
+    Then = "Then",
+    Else = "Else",
+    Match = "Match",
+    Return = "Return",
+    From = "From",
+    Asc = "Asc",
+    Desc = "Desc",
+    On = "On",
+    Equals = "Equals",
+    Into = "Into",
+    Underscore = "Underscore",
+    Memo = "Memo",
+    Backtick = "Backtick",
+    Eof = "Eof"
+}
+export interface SourceSpan {
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+}
+export interface Token {
+    kind: TokenKind;
+    text: string;
+    span: SourceSpan;
+}
+//# sourceMappingURL=token.d.ts.map

package/dist/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../src/token.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS;IAEnB,aAAa,kBAAkB;IAC/B,aAAa,kBAAkB;IAC/B,WAAW,gBAAgB;IAC3B,YAAY,iBAAiB;IAC7B,WAAW,gBAAgB;IAG3B,UAAU,eAAe;IACzB,MAAM,WAAW;IACjB,SAAS,cAAc;IACvB,GAAG,QAAQ;IACX,MAAM,WAAW;IAGjB,WAAW,gBAAgB;IAC3B,YAAY,iBAAiB;IAC7B,SAAS,cAAc;IACvB,UAAU,eAAe;IACzB,SAAS,cAAc;IACvB,UAAU,eAAe;IAGzB,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,KAAK,UAAU;IACf,KAAK,UAAU;IACf,IAAI,SAAS;IACb,MAAM,WAAW;IAGjB,IAAI,SAAS;IACb,KAAK,UAAU;IACf,KAAK,UAAU;IAGf,MAAM,WAAW;IAGjB,UAAU,eAAe;IACzB,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,eAAe,oBAAoB;IACnC,WAAW,gBAAgB;IAC3B,kBAAkB,uBAAuB;IAGzC,kBAAkB,uBAAuB;IACzC,QAAQ,aAAa;IACrB,IAAI,SAAS;IAGb,GAAG,QAAQ;IACX,EAAE,OAAO;IACT,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,EAAE,OAAO;IACT,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,UAAU,eAAe;IACzB,IAAI,SAAS;IAGb,QAAQ,aAAa;IAGrB,GAAG,QAAQ;CACZ;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;CAClB"}

package/dist/token.js

@@ -0,0 +1,66 @@
+export var TokenKind;
+(function (TokenKind) {
+    // Literals
+    TokenKind["StringLiteral"] = "StringLiteral";
+    TokenKind["NumberLiteral"] = "NumberLiteral";
+    TokenKind["TrueLiteral"] = "TrueLiteral";
+    TokenKind["FalseLiteral"] = "FalseLiteral";
+    TokenKind["NullLiteral"] = "NullLiteral";
+    // Identifiers & paths
+    TokenKind["Identifier"] = "Identifier";
+    TokenKind["Dollar"] = "Dollar";
+    TokenKind["DollarDot"] = "DollarDot";
+    TokenKind["Dot"] = "Dot";
+    TokenKind["DotDot"] = "DotDot";
+    // Brackets
+    TokenKind["LeftBracket"] = "LeftBracket";
+    TokenKind["RightBracket"] = "RightBracket";
+    TokenKind["LeftParen"] = "LeftParen";
+    TokenKind["RightParen"] = "RightParen";
+    TokenKind["LeftBrace"] = "LeftBrace";
+    TokenKind["RightBrace"] = "RightBrace";
+    // Operators
+    TokenKind["Pipe"] = "Pipe";
+    TokenKind["FatArrow"] = "FatArrow";
+    TokenKind["Comma"] = "Comma";
+    TokenKind["Colon"] = "Colon";
+    TokenKind["Star"] = "Star";
+    TokenKind["Spread"] = "Spread";
+    // Arithmetic
+    TokenKind["Plus"] = "Plus";
+    TokenKind["Minus"] = "Minus";
+    TokenKind["Slash"] = "Slash";
+    // Assignment
+    TokenKind["Assign"] = "Assign";
+    // Comparison
+    TokenKind["EqualEqual"] = "EqualEqual";
+    TokenKind["BangEqual"] = "BangEqual";
+    TokenKind["LessThan"] = "LessThan";
+    TokenKind["LessThanOrEqual"] = "LessThanOrEqual";
+    TokenKind["GreaterThan"] = "GreaterThan";
+    TokenKind["GreaterThanOrEqual"] = "GreaterThanOrEqual";
+    // Logical
+    TokenKind["AmpersandAmpersand"] = "AmpersandAmpersand";
+    TokenKind["PipePipe"] = "PipePipe";
+    TokenKind["Bang"] = "Bang";
+    // Keywords
+    TokenKind["Let"] = "Let";
+    TokenKind["If"] = "If";
+    TokenKind["Then"] = "Then";
+    TokenKind["Else"] = "Else";
+    TokenKind["Match"] = "Match";
+    TokenKind["Return"] = "Return";
+    TokenKind["From"] = "From";
+    TokenKind["Asc"] = "Asc";
+    TokenKind["Desc"] = "Desc";
+    TokenKind["On"] = "On";
+    TokenKind["Equals"] = "Equals";
+    TokenKind["Into"] = "Into";
+    TokenKind["Underscore"] = "Underscore";
+    TokenKind["Memo"] = "Memo";
+    // Interpolation
+    TokenKind["Backtick"] = "Backtick";
+    // Special
+    TokenKind["Eof"] = "Eof";
+})(TokenKind || (TokenKind = {}));
+//# sourceMappingURL=token.js.map

package/dist/token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.js","sourceRoot":"","sources":["../src/token.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,SAyEX;AAzED,WAAY,SAAS;IACnB,WAAW;IACX,4CAA+B,CAAA;IAC/B,4CAA+B,CAAA;IAC/B,wCAA2B,CAAA;IAC3B,0CAA6B,CAAA;IAC7B,wCAA2B,CAAA;IAE3B,sBAAsB;IACtB,sCAAyB,CAAA;IACzB,8BAAiB,CAAA;IACjB,oCAAuB,CAAA;IACvB,wBAAW,CAAA;IACX,8BAAiB,CAAA;IAEjB,WAAW;IACX,wCAA2B,CAAA;IAC3B,0CAA6B,CAAA;IAC7B,oCAAuB,CAAA;IACvB,sCAAyB,CAAA;IACzB,oCAAuB,CAAA;IACvB,sCAAyB,CAAA;IAEzB,YAAY;IACZ,0BAAa,CAAA;IACb,kCAAqB,CAAA;IACrB,4BAAe,CAAA;IACf,4BAAe,CAAA;IACf,0BAAa,CAAA;IACb,8BAAiB,CAAA;IAEjB,aAAa;IACb,0BAAa,CAAA;IACb,4BAAe,CAAA;IACf,4BAAe,CAAA;IAEf,aAAa;IACb,8BAAiB,CAAA;IAEjB,aAAa;IACb,sCAAyB,CAAA;IACzB,oCAAuB,CAAA;IACvB,kCAAqB,CAAA;IACrB,gDAAmC,CAAA;IACnC,wCAA2B,CAAA;IAC3B,sDAAyC,CAAA;IAEzC,UAAU;IACV,sDAAyC,CAAA;IACzC,kCAAqB,CAAA;IACrB,0BAAa,CAAA;IAEb,WAAW;IACX,wBAAW,CAAA;IACX,sBAAS,CAAA;IACT,0BAAa,CAAA;IACb,0BAAa,CAAA;IACb,4BAAe,CAAA;IACf,8BAAiB,CAAA;IACjB,0BAAa,CAAA;IACb,wBAAW,CAAA;IACX,0BAAa,CAAA;IACb,sBAAS,CAAA;IACT,8BAAiB,CAAA;IACjB,0BAAa,CAAA;IACb,sCAAyB,CAAA;IACzB,0BAAa,CAAA;IAEb,gBAAgB;IAChB,kCAAqB,CAAA;IAErB,UAAU;IACV,wBAAW,CAAA;AACb,CAAC,EAzEW,SAAS,KAAT,SAAS,QAyEpB"}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@elwood-lang/core",
+  "version": "0.1.0",
+  "description": "Elwood — a functional JSON transformation DSL",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "json",
+    "jsonpath",
+    "dsl",
+    "transformation",
+    "query",
+    "functional"
+  ],
+  "author": "Massimiliano Favilli",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.9"
+  }
+}

package/src/ast.ts

@@ -0,0 +1,235 @@
+import type { SourceSpan } from './token.js';
+
+// ── Expressions ──
+
+export type ElwoodExpression =
+  | PipelineExpression
+  | PathExpression
+  | IdentifierExpression
+  | LambdaExpression
+  | ObjectExpression
+  | ArrayExpression
+  | LiteralExpression
+  | InterpolatedStringExpression
+  | BinaryExpression
+  | UnaryExpression
+  | IfExpression
+  | MatchExpression
+  | MemoExpression
+  | MethodCallExpression
+  | FunctionCallExpression
+  | MemberAccessExpression
+  | IndexExpression;
+
+// ── Top-level ──
+
+export interface ScriptNode {
+  type: 'Script';
+  bindings: LetBindingNode[];
+  returnExpression: ElwoodExpression | null;
+  span: SourceSpan;
+}
+
+export interface LetBindingNode {
+  type: 'LetBinding';
+  name: string;
+  value: ElwoodExpression;
+  span: SourceSpan;
+}
+
+// ── Expression nodes ──
+
+export interface PipelineExpression {
+  type: 'Pipeline';
+  source: ElwoodExpression;
+  operations: PipeOperation[];
+  span: SourceSpan;
+}
+
+export interface PathExpression {
+  type: 'Path';
+  segments: PathSegment[];
+  isRooted: boolean;
+  span: SourceSpan;
+}
+
+export interface IdentifierExpression {
+  type: 'Identifier';
+  name: string;
+  span: SourceSpan;
+}
+
+export interface LambdaExpression {
+  type: 'Lambda';
+  parameters: string[];
+  body: ElwoodExpression;
+  span: SourceSpan;
+}
+
+export interface ObjectExpression {
+  type: 'Object';
+  properties: ObjectProperty[];
+  span: SourceSpan;
+}
+
+export interface ObjectProperty {
+  key: string;
+  value: ElwoodExpression;
+  span: SourceSpan;
+  isSpread?: boolean;
+  computedKey?: ElwoodExpression;
+}
+
+export interface ArrayExpression {
+  type: 'Array';
+  items: ElwoodExpression[];
+  span: SourceSpan;
+}
+
+export interface LiteralExpression {
+  type: 'Literal';
+  value: string | number | boolean | null;
+  span: SourceSpan;
+}
+
+export interface InterpolatedStringExpression {
+  type: 'InterpolatedString';
+  parts: InterpolationPart[];
+  span: SourceSpan;
+}
+
+export type InterpolationPart =
+  | { type: 'Text'; text: string; span: SourceSpan }
+  | { type: 'Expression'; expression: ElwoodExpression; span: SourceSpan };
+
+export interface BinaryExpression {
+  type: 'Binary';
+  left: ElwoodExpression;
+  operator: BinaryOperator;
+  right: ElwoodExpression;
+  span: SourceSpan;
+}
+
+export interface UnaryExpression {
+  type: 'Unary';
+  operator: UnaryOperator;
+  operand: ElwoodExpression;
+  span: SourceSpan;
+}
+
+export interface IfExpression {
+  type: 'If';
+  condition: ElwoodExpression;
+  thenBranch: ElwoodExpression;
+  elseBranch: ElwoodExpression;
+  span: SourceSpan;
+}
+
+export interface MatchExpression {
+  type: 'Match';
+  input: ElwoodExpression;
+  arms: MatchArm[];
+  span: SourceSpan;
+}
+
+export interface MatchArm {
+  pattern: ElwoodExpression | null; // null = wildcard
+  result: ElwoodExpression;
+  span: SourceSpan;
+}
+
+export interface MemoExpression {
+  type: 'Memo';
+  lambda: LambdaExpression;
+  span: SourceSpan;
+}
+
+export interface MethodCallExpression {
+  type: 'MethodCall';
+  target: ElwoodExpression;
+  methodName: string;
+  arguments: ElwoodExpression[];
+  span: SourceSpan;
+}
+
+export interface FunctionCallExpression {
+  type: 'FunctionCall';
+  functionName: string;
+  arguments: ElwoodExpression[];
+  span: SourceSpan;
+}
+
+export interface MemberAccessExpression {
+  type: 'MemberAccess';
+  target: ElwoodExpression;
+  memberName: string;
+  span: SourceSpan;
+}
+
+export interface IndexExpression {
+  type: 'Index';
+  target: ElwoodExpression;
+  index: ElwoodExpression | null; // null = [*]
+  span: SourceSpan;
+}
+
+// ── Pipe Operations ──
+
+export type PipeOperation =
+  | WhereOperation
+  | SelectOperation
+  | SelectManyOperation
+  | OrderByOperation
+  | GroupByOperation
+  | DistinctOperation
+  | AggregateOperation
+  | SliceOperation
+  | BatchOperation
+  | JoinOperation
+  | ConcatOperation
+  | ReduceOperation
+  | QuantifierOperation
+  | MatchOperation;
+
+export interface WhereOperation { type: 'Where'; predicate: ElwoodExpression; span: SourceSpan }
+export interface SelectOperation { type: 'Select'; projection: ElwoodExpression; span: SourceSpan }
+export interface SelectManyOperation { type: 'SelectMany'; projection: ElwoodExpression; span: SourceSpan }
+export interface OrderByOperation { type: 'OrderBy'; keys: { key: ElwoodExpression; ascending: boolean }[]; span: SourceSpan }
+export interface GroupByOperation { type: 'GroupBy'; keySelector: ElwoodExpression; span: SourceSpan }
+export interface DistinctOperation { type: 'Distinct'; span: SourceSpan }
+export interface AggregateOperation { type: 'Aggregate'; name: string; predicate?: ElwoodExpression; span: SourceSpan }
+export interface SliceOperation { type: 'Slice'; kind: 'take' | 'skip'; count: ElwoodExpression; span: SourceSpan }
+export interface BatchOperation { type: 'Batch'; size: ElwoodExpression; span: SourceSpan }
+export interface JoinOperation {
+  type: 'Join';
+  source: ElwoodExpression;
+  leftKey: ElwoodExpression;
+  rightKey: ElwoodExpression;
+  intoAlias?: string;
+  mode: JoinMode;
+  span: SourceSpan;
+}
+export interface ConcatOperation { type: 'Concat'; separator?: ElwoodExpression; span: SourceSpan }
+export interface ReduceOperation { type: 'Reduce'; accumulator: ElwoodExpression; initialValue?: ElwoodExpression; span: SourceSpan }
+export interface QuantifierOperation { type: 'Quantifier'; kind: 'any' | 'all'; predicate: ElwoodExpression; span: SourceSpan }
+export interface MatchOperation { type: 'MatchOp'; arms: MatchArm[]; span: SourceSpan }
+
+export type JoinMode = 'inner' | 'left' | 'right' | 'full';
+
+// ── Path Segments ──
+
+export type PathSegment =
+  | { type: 'Property'; name: string; span: SourceSpan }
+  | { type: 'Index'; index: number | null; span: SourceSpan }  // null = wildcard [*]
+  | { type: 'Slice'; start: number | null; end: number | null; span: SourceSpan }
+  | { type: 'RecursiveDescent'; name: string; span: SourceSpan };
+
+// ── Operators ──
+
+export type BinaryOperator =
+  | 'Add' | 'Subtract' | 'Multiply' | 'Divide'
+  | 'Equal' | 'NotEqual'
+  | 'LessThan' | 'LessThanOrEqual' | 'GreaterThan' | 'GreaterThanOrEqual'
+  | 'And' | 'Or';
+
+export type UnaryOperator = 'Negate' | 'Not';