@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev4

package/dist/ast/nodes/expr/CaseExpr.js

@@ -0,0 +1,30 @@
+export class CaseExpr {
+    matchExpr;
+    cases;
+    wildcardCase;
+    range;
+    constructor(matchExpr, cases, wildcardCase, range) {
+        this.matchExpr = matchExpr;
+        this.cases = cases;
+        this.wildcardCase = wildcardCase;
+        this.range = range;
+    }
+}
+export class CaseExprMatcher {
+    pattern;
+    body;
+    range;
+    constructor(pattern, body, range) {
+        this.pattern = pattern;
+        this.body = body;
+        this.range = range;
+    }
+}
+export class CaseWildcardMatcher {
+    body;
+    range;
+    constructor(body, range) {
+        this.body = body;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/ElemAccessExpr.d.ts

@@ -0,0 +1,12 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { PebbleExpr } from "./PebbleExpr.js";
+/**
+ * `arrLikeExpr[ indexExpr ]`
+ */
+export declare class ElemAccessExpr implements HasSourceRange {
+    readonly arrLikeExpr: PebbleExpr;
+    readonly indexExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(arrLikeExpr: PebbleExpr, indexExpr: PebbleExpr, range: SourceRange);
+}

package/dist/ast/nodes/expr/ElemAccessExpr.js

@@ -0,0 +1,13 @@
+/**
+ * `arrLikeExpr[ indexExpr ]`
+ */
+export class ElemAccessExpr {
+    arrLikeExpr;
+    indexExpr;
+    range;
+    constructor(arrLikeExpr, indexExpr, range) {
+        this.arrLikeExpr = arrLikeExpr;
+        this.indexExpr = indexExpr;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/IsExpr.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ast/nodes/expr/IsExpr.js

@@ -0,0 +1,14 @@
+export {};
+// TODO:
+// should optionally check for destructuring 
+/*
+export class IsExpr
+    implements HasSourceRange
+{
+    constructor(
+        readonly instanceExpr: PebbleExpr,
+        readonly ofType: Identifier,
+        readonly range: SourceRange
+    ) {}
+}
+    //*/ 

package/dist/ast/nodes/expr/ParentesizedExpr.d.ts

@@ -0,0 +1,8 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { PebbleExpr } from "./PebbleExpr.js";
+export declare class ParentesizedExpr implements HasSourceRange {
+    readonly expr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(expr: PebbleExpr, range: SourceRange);
+}

package/dist/ast/nodes/expr/ParentesizedExpr.js

@@ -0,0 +1,8 @@
+export class ParentesizedExpr {
+    expr;
+    range;
+    constructor(expr, range) {
+        this.expr = expr;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/PebbleExpr.d.ts

@@ -0,0 +1,18 @@
+import { CaseExpr } from "./CaseExpr.js";
+import { ElemAccessExpr } from "./ElemAccessExpr.js";
+import { CallExpr } from "./functions/CallExpr.js";
+import { FuncExpr } from "./functions/FuncExpr.js";
+import { LitteralExpr } from "./litteral/LitteralExpr.js";
+import { NonNullExpr } from "./unary/NonNullExpr.js";
+import { ParentesizedExpr } from "./ParentesizedExpr.js";
+import { TernaryExpr } from "./TernaryExpr.js";
+import { TypeConversionExpr } from "./TypeConversionExpr.js";
+import { UnaryPrefixExpr } from "./unary/UnaryPrefixExpr.js";
+import { Identifier } from "../common/Identifier.js";
+import { BinaryExpr } from "./binary/BinaryExpr.js";
+/**
+ * an expression is anything that can be evaluated to a value
+ * it must therefore have a type
+ */
+export type PebbleExpr = UnaryPrefixExpr | NonNullExpr | LitteralExpr | ParentesizedExpr | FuncExpr | CallExpr | CaseExpr | TypeConversionExpr | NonNullExpr | ElemAccessExpr | TernaryExpr | Identifier | BinaryExpr;
+export declare function isPebbleExpr(thing: any): thing is PebbleExpr;

package/dist/ast/nodes/expr/PebbleExpr.js

@@ -0,0 +1,31 @@
+import { CaseExpr } from "./CaseExpr.js";
+import { ElemAccessExpr } from "./ElemAccessExpr.js";
+import { CallExpr } from "./functions/CallExpr.js";
+import { FuncExpr } from "./functions/FuncExpr.js";
+import { isLitteralExpr } from "./litteral/LitteralExpr.js";
+import { NonNullExpr } from "./unary/NonNullExpr.js";
+import { ParentesizedExpr } from "./ParentesizedExpr.js";
+import { isPropAccessExpr } from "./PropAccessExpr.js";
+import { TernaryExpr } from "./TernaryExpr.js";
+import { TypeConversionExpr } from "./TypeConversionExpr.js";
+import { isUnaryPrefixExpr } from "./unary/UnaryPrefixExpr.js";
+import { Identifier } from "../common/Identifier.js";
+import { isBinaryExpr } from "./binary/BinaryExpr.js";
+export function isPebbleExpr(thing) {
+    return (isUnaryPrefixExpr(thing)
+        || thing instanceof NonNullExpr
+        || isLitteralExpr(thing)
+        || thing instanceof ParentesizedExpr
+        || thing instanceof FuncExpr
+        || thing instanceof CallExpr
+        || thing instanceof CaseExpr
+        || thing instanceof TypeConversionExpr
+        || thing instanceof NonNullExpr
+        // || thing instanceof IsExpr
+        || thing instanceof ElemAccessExpr
+        || thing instanceof TernaryExpr
+        // || thing instanceof CommaExpr
+        || isPropAccessExpr(thing)
+        || thing instanceof Identifier
+        || isBinaryExpr(thing));
+}

package/dist/ast/nodes/expr/PropAccessExpr.d.ts

@@ -0,0 +1,28 @@
+import { HasSourceRange } from "../HasSourceRange.js";
+import { SourceRange } from "../../Source/SourceRange.js";
+import { PebbleExpr } from "./PebbleExpr.js";
+import { Identifier } from "../common/Identifier.js";
+import { Token } from "../../../tokenizer/Token.js";
+export type PropAccessExpr = OptionalPropAccessExpr | NonNullPropAccessExpr | DotPropAccessExpr;
+export type PropAccessToken = Token.Question_Dot | Token.Exclamation_Dot | Token.Dot;
+export type PropAccessTokenToExpr<T extends PropAccessToken> = T extends Token.Question_Dot ? OptionalPropAccessExpr : T extends Token.Exclamation_Dot ? NonNullPropAccessExpr : T extends Token.Dot ? DotPropAccessExpr : never;
+export declare function makePropAccessExpr<T extends PropAccessToken>(token: T, object: PebbleExpr, prop: Identifier, range: SourceRange): PropAccessTokenToExpr<T>;
+export declare function isPropAccessExpr(thing: any): thing is PropAccessExpr;
+export declare class OptionalPropAccessExpr implements HasSourceRange {
+    readonly object: PebbleExpr;
+    readonly prop: Identifier;
+    readonly range: SourceRange;
+    constructor(object: PebbleExpr, prop: Identifier, range: SourceRange);
+}
+export declare class NonNullPropAccessExpr implements HasSourceRange {
+    readonly object: PebbleExpr;
+    readonly prop: Identifier;
+    readonly range: SourceRange;
+    constructor(object: PebbleExpr, prop: Identifier, range: SourceRange);
+}
+export declare class DotPropAccessExpr implements HasSourceRange {
+    readonly object: PebbleExpr;
+    readonly prop: Identifier;
+    readonly range: SourceRange;
+    constructor(object: PebbleExpr, prop: Identifier, range: SourceRange);
+}

package/dist/ast/nodes/expr/PropAccessExpr.js

@@ -0,0 +1,46 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { Token } from "../../../tokenizer/Token.js";
+export function makePropAccessExpr(token, object, prop, range) {
+    switch (token) {
+        case Token.Question_Dot: return new OptionalPropAccessExpr(object, prop, range);
+        case Token.Exclamation_Dot: return new NonNullPropAccessExpr(object, prop, range);
+        case Token.Dot: return new DotPropAccessExpr(object, prop, range);
+        default:
+            throw new Error("Invalid token for property access expression");
+    }
+}
+export function isPropAccessExpr(thing) {
+    return isObject(thing) && (thing instanceof OptionalPropAccessExpr
+        || thing instanceof NonNullPropAccessExpr
+        || thing instanceof DotPropAccessExpr);
+}
+export class OptionalPropAccessExpr {
+    object;
+    prop;
+    range;
+    constructor(object, prop, range) {
+        this.object = object;
+        this.prop = prop;
+        this.range = range;
+    }
+}
+export class NonNullPropAccessExpr {
+    object;
+    prop;
+    range;
+    constructor(object, prop, range) {
+        this.object = object;
+        this.prop = prop;
+        this.range = range;
+    }
+}
+export class DotPropAccessExpr {
+    object;
+    prop;
+    range;
+    constructor(object, prop, range) {
+        this.object = object;
+        this.prop = prop;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/TernaryExpr.d.ts

@@ -0,0 +1,10 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { PebbleExpr } from "./PebbleExpr.js";
+export declare class TernaryExpr implements HasSourceRange {
+    readonly condition: PebbleExpr;
+    readonly ifTrue: PebbleExpr;
+    readonly ifFalse: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(condition: PebbleExpr, ifTrue: PebbleExpr, ifFalse: PebbleExpr, range: SourceRange);
+}

package/dist/ast/nodes/expr/TernaryExpr.js

@@ -0,0 +1,12 @@
+export class TernaryExpr {
+    condition;
+    ifTrue;
+    ifFalse;
+    range;
+    constructor(condition, ifTrue, ifFalse, range) {
+        this.condition = condition;
+        this.ifTrue = ifTrue;
+        this.ifFalse = ifFalse;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/TypeConversionExpr.d.ts

@@ -0,0 +1,10 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { AstTypeExpr } from "../types/AstTypeExpr.js";
+import { PebbleExpr } from "./PebbleExpr.js";
+export declare class TypeConversionExpr implements HasSourceRange {
+    readonly expr: PebbleExpr;
+    readonly asType: AstTypeExpr;
+    readonly range: SourceRange;
+    constructor(expr: PebbleExpr, asType: AstTypeExpr, range?: SourceRange);
+}

package/dist/ast/nodes/expr/TypeConversionExpr.js

@@ -0,0 +1,11 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+export class TypeConversionExpr {
+    expr;
+    asType;
+    range;
+    constructor(expr, asType, range = SourceRange.join(expr.range, asType.range)) {
+        this.expr = expr;
+        this.asType = asType;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/binary/BinaryExpr.d.ts

@@ -0,0 +1,133 @@
+import { Token } from "../../../../tokenizer/Token.js";
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { PebbleExpr } from "../PebbleExpr.js";
+export type BinaryExpr = ExponentiationExpr | LessThanExpr | GreaterThanExpr | LessThanEqualExpr | GreaterThanEqualExpr | EqualExpr | NotEqualExpr | AddExpr | SubExpr | MultExpr | DivExpr | ModuloExpr | ShiftLeftExpr | ShiftRightExpr | BitwiseAndExpr | BitwiseXorExpr | BitwiseOrExpr | LogicalAndExpr | LogicalOrExpr | OptionalDefaultExpr;
+export type BinaryExprToken = Token.Asterisk_Asterisk | Token.LessThan | Token.GreaterThan | Token.LessThan_Equals | Token.GreaterThan_Equals | Token.Equals_Equals | Token.Equals_Equals_Equals | Token.Exclamation_Equals_Equals | Token.Exclamation_Equals | Token.Plus | Token.Minus | Token.Asterisk | Token.Slash | Token.Percent | Token.LessThan_LessThan | Token.GreaterThan_GreaterThan | Token.GreaterThan_GreaterThan_GreaterThan | Token.Ampersand | Token.Bar | Token.Caret | Token.Ampersand_Ampersand | Token.Question_Question | Token.Bar_Bar;
+export type BinaryTokenToExpr<T extends BinaryExprToken> = T extends Token.Asterisk_Asterisk ? ExponentiationExpr : T extends Token.LessThan ? LessThanExpr : T extends Token.GreaterThan ? GreaterThanExpr : T extends Token.LessThan_Equals ? LessThanEqualExpr : T extends Token.GreaterThan_Equals ? GreaterThanEqualExpr : T extends Token.Equals_Equals ? EqualExpr : T extends Token.Equals_Equals_Equals ? EqualExpr : T extends Token.Exclamation_Equals_Equals ? NotEqualExpr : T extends Token.Exclamation_Equals ? NotEqualExpr : T extends Token.Plus ? AddExpr : T extends Token.Minus ? SubExpr : T extends Token.Asterisk ? MultExpr : T extends Token.Slash ? DivExpr : T extends Token.Percent ? ModuloExpr : T extends Token.LessThan_LessThan ? ShiftLeftExpr : T extends Token.GreaterThan_GreaterThan ? ShiftRightExpr : T extends Token.GreaterThan_GreaterThan_GreaterThan ? ShiftRightExpr : T extends Token.Ampersand ? BitwiseAndExpr : T extends Token.Caret ? BitwiseXorExpr : T extends Token.Bar ? BitwiseOrExpr : T extends Token.Ampersand_Ampersand ? LogicalAndExpr : T extends Token.Bar_Bar ? LogicalOrExpr : T extends Token.Question_Question ? OptionalDefaultExpr : never;
+export declare function makeBinaryExpr<T extends BinaryExprToken>(token: T, left: PebbleExpr, right: PebbleExpr, range: SourceRange): BinaryTokenToExpr<T>;
+export declare function isBinaryExpr(thing: any): thing is BinaryExpr;
+export interface IBinaryExpr extends HasSourceRange {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+}
+export declare class ExponentiationExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class LessThanExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class GreaterThanExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class LessThanEqualExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class GreaterThanEqualExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class EqualExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class NotEqualExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class AddExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class SubExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class MultExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class DivExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class ModuloExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class ShiftLeftExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class ShiftRightExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class BitwiseAndExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class BitwiseXorExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class BitwiseOrExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class LogicalAndExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class LogicalOrExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}
+export declare class OptionalDefaultExpr implements IBinaryExpr {
+    readonly left: PebbleExpr;
+    readonly right: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
+}

package/dist/ast/nodes/expr/binary/BinaryExpr.js

@@ -0,0 +1,253 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { Token } from "../../../../tokenizer/Token.js";
+export function makeBinaryExpr(token, left, right, range) {
+    switch (token) {
+        case Token.Asterisk_Asterisk: return new ExponentiationExpr(left, right, range);
+        case Token.LessThan: return new LessThanExpr(left, right, range);
+        case Token.GreaterThan: return new GreaterThanExpr(left, right, range);
+        case Token.LessThan_Equals: return new LessThanEqualExpr(left, right, range);
+        case Token.GreaterThan_Equals: return new GreaterThanEqualExpr(left, right, range);
+        case Token.Equals_Equals: return new EqualExpr(left, right, range);
+        case Token.Equals_Equals_Equals: return new EqualExpr(left, right, range);
+        case Token.Exclamation_Equals_Equals: return new NotEqualExpr(left, right, range);
+        case Token.Exclamation_Equals: return new NotEqualExpr(left, right, range);
+        case Token.Plus: return new AddExpr(left, right, range);
+        case Token.Minus: return new SubExpr(left, right, range);
+        case Token.Asterisk: return new MultExpr(left, right, range);
+        case Token.Slash: return new DivExpr(left, right, range);
+        case Token.Percent: return new ModuloExpr(left, right, range);
+        case Token.LessThan_LessThan: return new ShiftLeftExpr(left, right, range);
+        case Token.GreaterThan_GreaterThan: return new ShiftRightExpr(left, right, range);
+        case Token.GreaterThan_GreaterThan_GreaterThan: return new ShiftRightExpr(left, right, range);
+        case Token.Ampersand: return new BitwiseAndExpr(left, right, range);
+        case Token.Caret: return new BitwiseXorExpr(left, right, range);
+        case Token.Bar: return new BitwiseOrExpr(left, right, range);
+        case Token.Ampersand_Ampersand: return new LogicalAndExpr(left, right, range);
+        case Token.Bar_Bar: return new LogicalOrExpr(left, right, range);
+        case Token.Question_Question: return new OptionalDefaultExpr(left, right, range);
+        default:
+            throw new Error("Invalid token for binary expression");
+    }
+}
+export function isBinaryExpr(thing) {
+    return isObject(thing) && (thing instanceof ExponentiationExpr
+        || thing instanceof LessThanExpr
+        || thing instanceof GreaterThanExpr
+        || thing instanceof LessThanEqualExpr
+        || thing instanceof GreaterThanEqualExpr
+        || thing instanceof EqualExpr
+        || thing instanceof NotEqualExpr
+        || thing instanceof AddExpr
+        || thing instanceof SubExpr
+        || thing instanceof MultExpr
+        || thing instanceof DivExpr
+        || thing instanceof ModuloExpr
+        || thing instanceof ShiftLeftExpr
+        || thing instanceof ShiftRightExpr
+        || thing instanceof BitwiseAndExpr
+        || thing instanceof BitwiseXorExpr
+        || thing instanceof BitwiseOrExpr
+        || thing instanceof LogicalAndExpr
+        || thing instanceof LogicalOrExpr
+        || thing instanceof OptionalDefaultExpr);
+}
+export class ExponentiationExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class LessThanExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class GreaterThanExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class LessThanEqualExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class GreaterThanEqualExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class EqualExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class NotEqualExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class AddExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class SubExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class MultExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class DivExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class ModuloExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class ShiftLeftExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class ShiftRightExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class BitwiseAndExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class BitwiseXorExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class BitwiseOrExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class LogicalAndExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class LogicalOrExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}
+export class OptionalDefaultExpr {
+    left;
+    right;
+    range;
+    constructor(left, right, range) {
+        this.left = left;
+        this.right = right;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/functions/ArrowKind.d.ts

@@ -0,0 +1,9 @@
+/** Indicates the kind of an array function. */
+export declare enum ArrowKind {
+    /** Not an arrow function. */
+    None = 0,
+    /** Parenthesized parameter list. */
+    Parenthesized = 1,
+    /** Single parameter without parenthesis. */
+    Single = 2
+}

package/dist/ast/nodes/expr/functions/ArrowKind.js

@@ -0,0 +1,11 @@
+/** Indicates the kind of an array function. */
+export var ArrowKind;
+(function (ArrowKind) {
+    /** Not an arrow function. */
+    ArrowKind[ArrowKind["None"] = 0] = "None";
+    /** Parenthesized parameter list. */
+    ArrowKind[ArrowKind["Parenthesized"] = 1] = "Parenthesized";
+    /** Single parameter without parenthesis. */
+    ArrowKind[ArrowKind["Single"] = 2] = "Single";
+})(ArrowKind || (ArrowKind = {}));
+Object.freeze(ArrowKind);