@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

package/dist/ast/nodes/statements/AssignmentStmt.js

@@ -0,0 +1,211 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { Token } from "../../../tokenizer/Token.js";
+import { DecrStmt } from "./DecrStmt.js";
+import { IncrStmt } from "./IncrStmt.js";
+export function isAssignmentToken(token) {
+    return token === Token.Equals
+        || token === Token.Plus_Equals
+        || token === Token.Minus_Equals
+        || token === Token.Asterisk_Asterisk_Equals
+        || token === Token.Asterisk_Equals
+        || token === Token.Slash_Equals
+        || token === Token.Percent_Equals
+        || token === Token.Plus_Plus
+        || token === Token.Minus_Minus
+        || token === Token.LessThan_LessThan_Equals
+        || token === Token.GreaterThan_GreaterThan_Equals
+        || token === Token.GreaterThan_GreaterThan_GreaterThan_Equals
+        || token === Token.Ampersand_Equals
+        || token === Token.Caret_Equals
+        || token === Token.Bar_Equals
+        || token === Token.Ampersand_Ampersand_Equals
+        || token === Token.Bar_Bar_Equals;
+}
+export function isAssignmentStmt(stmt) {
+    return isImplicitAssignmentStmt(stmt)
+        || isExplicitAssignmentStmt(stmt);
+}
+export function isImplicitAssignmentStmt(stmt) {
+    return isObject(stmt) && (stmt instanceof IncrStmt
+        || stmt instanceof DecrStmt);
+}
+export function isExplicitAssignmentStmt(stmt) {
+    return isObject(stmt) && (stmt instanceof SimpleAssignmentStmt
+        || stmt instanceof AddAssignmentStmt
+        || stmt instanceof SubAssignmentStmt
+        || stmt instanceof ExpAssignmentStmt
+        || stmt instanceof MultAssignmentStmt
+        || stmt instanceof DivAssignmentStmt
+        || stmt instanceof ModuloAssignmentStmt
+        // || stmt instanceof IncrStmt
+        // || stmt instanceof DecrStmt
+        || stmt instanceof ShiftLeftAssignmentStmt
+        || stmt instanceof ShiftRightAssignmentStmt
+        || stmt instanceof BitwiseAndAssignmentStmt
+        || stmt instanceof BitwiseXorAssignmentStmt
+        || stmt instanceof BitwiseOrAssignmentStmt
+        || stmt instanceof LogicalAndAssignmentStmt
+        || stmt instanceof LogicalOrAssignmentStmt);
+}
+export function makeAssignmentStmt(varIdentifier, token, assignedExpr, range) {
+    switch (token) {
+        case Token.Equals: return new SimpleAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.Plus_Equals: return new AddAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.Minus_Equals: return new SubAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.Asterisk_Asterisk_Equals: return new ExpAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.Asterisk_Equals: return new MultAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.Slash_Equals: return new DivAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.Percent_Equals: return new ModuloAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.Plus_Plus: return new IncrStmt(varIdentifier, range);
+        case Token.Minus_Minus: return new DecrStmt(varIdentifier, range);
+        case Token.LessThan_LessThan_Equals: return new ShiftLeftAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.GreaterThan_GreaterThan_Equals: return new ShiftRightAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.GreaterThan_GreaterThan_GreaterThan_Equals: return new ShiftRightAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.Ampersand_Equals: return new BitwiseAndAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.Caret_Equals: return new BitwiseXorAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.Bar_Equals: return new BitwiseOrAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.Ampersand_Ampersand_Equals: return new LogicalAndAssignmentStmt(varIdentifier, assignedExpr, range);
+        case Token.Bar_Bar_Equals: return new LogicalOrAssignmentStmt(varIdentifier, assignedExpr, range);
+        default: throw new Error(`Invalid assignment token: ${token}`);
+    }
+}
+export class SimpleAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class AddAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class SubAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class ExpAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class MultAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class DivAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class ModuloAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class ShiftLeftAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class ShiftRightAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class BitwiseAndAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class BitwiseXorAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class BitwiseOrAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class LogicalAndAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}
+export class LogicalOrAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/BlockStmt.d.ts

@@ -0,0 +1,8 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { BodyStmt } from "./PebbleStmt.js";
+export declare class BlockStmt implements HasSourceRange {
+    readonly stmts: BodyStmt[];
+    readonly range: SourceRange;
+    constructor(stmts: BodyStmt[], range: SourceRange);
+}

package/dist/ast/nodes/statements/BlockStmt.js

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

package/dist/ast/nodes/statements/BreakStmt.d.ts

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

package/dist/ast/nodes/statements/BreakStmt.js

@@ -0,0 +1,6 @@
+export class BreakStmt {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/ContinueStmt.d.ts

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

package/dist/ast/nodes/statements/ContinueStmt.js

@@ -0,0 +1,6 @@
+export class ContinueStmt {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/DecrStmt.d.ts

@@ -0,0 +1,11 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { Identifier } from "../common/Identifier.js";
+/**
+ * both `--i` and `i--`
+ */
+export declare class DecrStmt implements HasSourceRange {
+    readonly varIdentifier: Identifier;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, range: SourceRange);
+}

package/dist/ast/nodes/statements/DecrStmt.js

@@ -0,0 +1,11 @@
+/**
+ * both `--i` and `i--`
+ */
+export class DecrStmt {
+    varIdentifier;
+    range;
+    constructor(varIdentifier, range) {
+        this.varIdentifier = varIdentifier;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/DoWhileStmt.d.ts

@@ -0,0 +1,10 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { PebbleExpr } from "../expr/PebbleExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { BodyStmt } from "./PebbleStmt.js";
+export declare class DoWhileStmt implements HasSourceRange {
+    readonly body: BodyStmt;
+    readonly condition: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(body: BodyStmt, condition: PebbleExpr, range: SourceRange);
+}

package/dist/ast/nodes/statements/DoWhileStmt.js

@@ -0,0 +1,10 @@
+export class DoWhileStmt {
+    body;
+    condition;
+    range;
+    constructor(body, condition, range) {
+        this.body = body;
+        this.condition = condition;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/EmptyStmt.d.ts

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

package/dist/ast/nodes/statements/EmptyStmt.js

@@ -0,0 +1,6 @@
+export class EmptyStmt {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/ExportImportStmt.d.ts

@@ -0,0 +1,15 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { LitStrExpr } from "../expr/litteral/LitStrExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { ImportDecl } from "./ImportStmt.js";
+/**
+ * ```ts
+ * export { ... } from "module";
+ * ```
+ */
+export declare class ExportImportStmt implements HasSourceRange {
+    readonly members: ImportDecl[];
+    readonly path: LitStrExpr;
+    readonly range: SourceRange;
+    constructor(members: ImportDecl[], path: LitStrExpr, range: SourceRange);
+}

package/dist/ast/nodes/statements/ExportImportStmt.js

@@ -0,0 +1,15 @@
+/**
+ * ```ts
+ * export { ... } from "module";
+ * ```
+ */
+export class ExportImportStmt {
+    members;
+    path;
+    range;
+    constructor(members, path, range) {
+        this.members = members;
+        this.path = path;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/ExportStarStmt.d.ts

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

package/dist/ast/nodes/statements/ExportStarStmt.js

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

package/dist/ast/nodes/statements/ExportStmt.d.ts

@@ -0,0 +1,13 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { BodyStmt } from "./PebbleStmt.js";
+/**
+ * ```ts
+ * export <PebbleStmt>
+ * ```
+ */
+export declare class ExportStmt implements HasSourceRange {
+    readonly stmt: BodyStmt;
+    readonly range: SourceRange;
+    constructor(stmt: BodyStmt, range: SourceRange);
+}

package/dist/ast/nodes/statements/ExportStmt.js

@@ -0,0 +1,13 @@
+/**
+ * ```ts
+ * export <PebbleStmt>
+ * ```
+ */
+export class ExportStmt {
+    stmt;
+    range;
+    constructor(stmt, range) {
+        this.stmt = stmt;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/ExprStmt.d.ts

@@ -0,0 +1,8 @@
+export {};
+/**
+ * usually expressions with side effects
+ *
+ * includes `increment` and `decrement` expressions (i++, i--, etc.)
+ * and function calls that do have side effects
+ * (traces (if allowed), assertions and failing operations)
+**/

package/dist/ast/nodes/statements/ExprStmt.js

@@ -0,0 +1,18 @@
+export {};
+/**
+ * usually expressions with side effects
+ *
+ * includes `increment` and `decrement` expressions (i++, i--, etc.)
+ * and function calls that do have side effects
+ * (traces (if allowed), assertions and failing operations)
+**/
+/*
+export class ExprStmt
+    implements HasSourceRange
+{
+    constructor(
+        readonly expr: PebbleExpr,
+        readonly range: SourceRange
+    ) {}
+}
+    //*/ 

package/dist/ast/nodes/statements/FailStmt.d.ts

@@ -0,0 +1,11 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { PebbleExpr } from "../expr/PebbleExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+export declare class FailStmt implements HasSourceRange {
+    /** must be string (or utf8 bytes) */
+    readonly value: PebbleExpr | undefined;
+    readonly range: SourceRange;
+    constructor(
+    /** must be string (or utf8 bytes) */
+    value: PebbleExpr | undefined, range: SourceRange);
+}

package/dist/ast/nodes/statements/FailStmt.js

@@ -0,0 +1,10 @@
+export class FailStmt {
+    value;
+    range;
+    constructor(
+    /** must be string (or utf8 bytes) */
+    value, range) {
+        this.value = value;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/ForOfStmt.d.ts

@@ -0,0 +1,16 @@
+import { PebbleAst } from "../../PebbleAst.js";
+import { SourceRange } from "../../Source/SourceRange.js";
+import { PebbleExpr } from "../expr/PebbleExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { VarDecl } from "./declarations/VarDecl/VarDecl.js";
+import { VarStmt } from "./VarStmt.js";
+/**
+ * for( `elemDeclaration` of iterable ) body
+ */
+export declare class ForOfStmt implements HasSourceRange {
+    readonly elemDeclaration: VarStmt<[VarDecl]>;
+    readonly iterable: PebbleExpr;
+    readonly body: PebbleAst;
+    readonly range: SourceRange;
+    constructor(elemDeclaration: VarStmt<[VarDecl]>, iterable: PebbleExpr, body: PebbleAst, range: SourceRange);
+}

package/dist/ast/nodes/statements/ForOfStmt.js

@@ -0,0 +1,15 @@
+/**
+ * for( `elemDeclaration` of iterable ) body
+ */
+export class ForOfStmt {
+    elemDeclaration;
+    iterable;
+    body;
+    range;
+    constructor(elemDeclaration, iterable, body, range) {
+        this.elemDeclaration = elemDeclaration;
+        this.iterable = iterable;
+        this.body = body;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/ForStmt.d.ts

@@ -0,0 +1,19 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { PebbleExpr } from "../expr/PebbleExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { AssignmentStmt } from "./AssignmentStmt.js";
+import { BodyStmt } from "./PebbleStmt.js";
+import { VarStmt } from "./VarStmt.js";
+/**
+ * ***NOT*** for...of loop
+ *
+ * for( init; condition; update ) body
+ */
+export declare class ForStmt implements HasSourceRange {
+    readonly init: VarStmt | undefined;
+    readonly condition: PebbleExpr | undefined;
+    readonly updates: AssignmentStmt[];
+    readonly body: BodyStmt;
+    readonly range: SourceRange;
+    constructor(init: VarStmt | undefined, condition: PebbleExpr | undefined, updates: AssignmentStmt[], body: BodyStmt, range: SourceRange);
+}

package/dist/ast/nodes/statements/ForStmt.js

@@ -0,0 +1,19 @@
+/**
+ * ***NOT*** for...of loop
+ *
+ * for( init; condition; update ) body
+ */
+export class ForStmt {
+    init;
+    condition;
+    updates;
+    body;
+    range;
+    constructor(init, condition, updates, body, range) {
+        this.init = init;
+        this.condition = condition;
+        this.updates = updates;
+        this.body = body;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/IfStmt.d.ts

@@ -0,0 +1,11 @@
+import { PebbleAst } from "../../PebbleAst.js";
+import { SourceRange } from "../../Source/SourceRange.js";
+import { PebbleExpr } from "../expr/PebbleExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+export declare class IfStmt implements HasSourceRange {
+    readonly condition: PebbleExpr;
+    readonly thenBranch: PebbleAst;
+    readonly elseBranch: PebbleAst | undefined;
+    readonly range: SourceRange;
+    constructor(condition: PebbleExpr, thenBranch: PebbleAst, elseBranch: PebbleAst | undefined, range: SourceRange);
+}

package/dist/ast/nodes/statements/IfStmt.js

@@ -0,0 +1,12 @@
+export class IfStmt {
+    condition;
+    thenBranch;
+    elseBranch;
+    range;
+    constructor(condition, thenBranch, elseBranch, range) {
+        this.condition = condition;
+        this.thenBranch = thenBranch;
+        this.elseBranch = elseBranch;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/ImportStarStmt.d.ts

@@ -0,0 +1,15 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { Identifier } from "../common/Identifier.js";
+import { LitStrExpr } from "../expr/litteral/LitStrExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+/**
+ * ```ts
+ * import * as module from "module";
+ * ```
+ */
+export declare class ImportStarStmt implements HasSourceRange {
+    readonly anIdentifier: Identifier;
+    readonly fromPath: LitStrExpr;
+    readonly range: SourceRange;
+    constructor(anIdentifier: Identifier, fromPath: LitStrExpr, range: SourceRange);
+}

package/dist/ast/nodes/statements/ImportStarStmt.js

@@ -0,0 +1,15 @@
+/**
+ * ```ts
+ * import * as module from "module";
+ * ```
+ */
+export class ImportStarStmt {
+    anIdentifier;
+    fromPath;
+    range;
+    constructor(anIdentifier, fromPath, range) {
+        this.anIdentifier = anIdentifier;
+        this.fromPath = fromPath;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/ImportStmt.d.ts

@@ -0,0 +1,21 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { Identifier } from "../common/Identifier.js";
+import { LitStrExpr } from "../expr/litteral/LitStrExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+/**
+ * ```ts
+ * export { ... } from "module";
+ * ```
+ */
+export declare class ImportStmt implements HasSourceRange {
+    readonly members: ImportDecl[];
+    readonly fromPath: LitStrExpr;
+    readonly range: SourceRange;
+    constructor(members: ImportDecl[], fromPath: LitStrExpr, range: SourceRange);
+}
+export declare class ImportDecl implements HasSourceRange {
+    readonly identifier: Identifier;
+    readonly asIdentifier: Identifier | undefined;
+    readonly range: SourceRange;
+    constructor(identifier: Identifier, asIdentifier: Identifier | undefined, range: SourceRange);
+}

package/dist/ast/nodes/statements/ImportStmt.js

@@ -0,0 +1,25 @@
+/**
+ * ```ts
+ * export { ... } from "module";
+ * ```
+ */
+export class ImportStmt {
+    members;
+    fromPath;
+    range;
+    constructor(members, fromPath, range) {
+        this.members = members;
+        this.fromPath = fromPath;
+        this.range = range;
+    }
+}
+export class ImportDecl {
+    identifier;
+    asIdentifier;
+    range;
+    constructor(identifier, asIdentifier, range) {
+        this.identifier = identifier;
+        this.asIdentifier = asIdentifier;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/IncrStmt.d.ts

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

package/dist/ast/nodes/statements/IncrStmt.js

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