@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev4

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

@@ -0,0 +1,17 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { VarDecl } from "./declarations/VarDecl/VarDecl.js";
+import { PebbleExpr } from "../expr/PebbleExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { BodyStmt } from "./PebbleStmt.js";
+export declare class MatchStmt implements HasSourceRange {
+    readonly matchExpr: PebbleExpr;
+    readonly cases: MatchStmtCase[];
+    readonly range: SourceRange;
+    constructor(matchExpr: PebbleExpr, cases: MatchStmtCase[], range: SourceRange);
+}
+export declare class MatchStmtCase implements HasSourceRange {
+    readonly pattern: VarDecl;
+    readonly body: BodyStmt;
+    readonly range: SourceRange;
+    constructor(pattern: VarDecl, body: BodyStmt, range: SourceRange);
+}

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

@@ -0,0 +1,20 @@
+export class MatchStmt {
+    matchExpr;
+    cases;
+    range;
+    constructor(matchExpr, cases, range) {
+        this.matchExpr = matchExpr;
+        this.cases = cases;
+        this.range = range;
+    }
+}
+export class MatchStmtCase {
+    pattern;
+    body;
+    range;
+    constructor(pattern, body, range) {
+        this.pattern = pattern;
+        this.body = body;
+        this.range = range;
+    }
+}

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

@@ -0,0 +1,29 @@
+import { AssertStmt } from "./AssertStmt.js";
+import { BlockStmt } from "./BlockStmt.js";
+import { BreakStmt } from "./BreakStmt.js";
+import { ContinueStmt } from "./ContinueStmt.js";
+import { PebbleTypeDecl } from "./declarations/PebbleTypeDecl.js";
+import { EmptyStmt } from "./EmptyStmt.js";
+import { TypeImplementsStmt } from "./TypeImplementsStmt.js";
+import { ExportStarStmt } from "./ExportStarStmt.js";
+import { ExportImportStmt } from "./ExportImportStmt.js";
+import { FailStmt } from "./FailStmt.js";
+import { ForOfStmt } from "./ForOfStmt.js";
+import { ForStmt } from "./ForStmt.js";
+import { IfStmt } from "./IfStmt.js";
+import { ImportStarStmt } from "./ImportStarStmt.js";
+import { ImportStmt } from "./ImportStmt.js";
+import { MatchStmt } from "./MatchStmt.js";
+import { ReturnStmt } from "./ReturnStmt.js";
+import { TestStmt } from "./TestStmt.js";
+import { VarStmt } from "./VarStmt.js";
+import { WhileStmt } from "./WhileStmt.js";
+import { AssignmentStmt } from "./AssignmentStmt.js";
+import { UsingStmt } from "./UsingStmt.js";
+import { FuncDecl } from "./declarations/FuncDecl.js";
+import { ExportStmt } from "./ExportStmt.js";
+import { InterfaceDecl } from "./declarations/InterfaceDecl.js";
+export type TopLevelStmt = EmptyStmt | VarStmt | PebbleTypeDecl | InterfaceDecl | FuncDecl | TestStmt | ExportStmt | ExportStarStmt | ExportImportStmt | ImportStmt | ImportStarStmt | TypeImplementsStmt | UsingStmt;
+export declare function isTopLevelStmt(stmt: any): stmt is TopLevelStmt;
+export type BodyStmt = IfStmt | VarStmt | ForStmt | ForOfStmt | WhileStmt | ReturnStmt | BlockStmt | BreakStmt | ContinueStmt | EmptyStmt | FailStmt | AssertStmt | MatchStmt | AssignmentStmt | UsingStmt;
+export declare function isBodyStmt(stmt: any): stmt is BodyStmt;

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

@@ -0,0 +1,62 @@
+import { AssertStmt } from "./AssertStmt.js";
+import { BlockStmt } from "./BlockStmt.js";
+import { BreakStmt } from "./BreakStmt.js";
+import { ContinueStmt } from "./ContinueStmt.js";
+import { isPebbleTypeDecl } from "./declarations/PebbleTypeDecl.js";
+import { DoWhileStmt } from "./DoWhileStmt.js";
+import { EmptyStmt } from "./EmptyStmt.js";
+import { TypeImplementsStmt } from "./TypeImplementsStmt.js";
+import { ExportStarStmt } from "./ExportStarStmt.js";
+import { ExportImportStmt } from "./ExportImportStmt.js";
+import { FailStmt } from "./FailStmt.js";
+import { ForOfStmt } from "./ForOfStmt.js";
+import { ForStmt } from "./ForStmt.js";
+import { IfStmt } from "./IfStmt.js";
+import { ImportStarStmt } from "./ImportStarStmt.js";
+import { ImportStmt } from "./ImportStmt.js";
+import { MatchStmt } from "./MatchStmt.js";
+import { ReturnStmt } from "./ReturnStmt.js";
+import { TestStmt } from "./TestStmt.js";
+import { VarStmt } from "./VarStmt.js";
+import { WhileStmt } from "./WhileStmt.js";
+import { isAssignmentStmt } from "./AssignmentStmt.js";
+import { IncrStmt } from "./IncrStmt.js";
+import { DecrStmt } from "./DecrStmt.js";
+import { UsingStmt } from "./UsingStmt.js";
+import { FuncDecl } from "./declarations/FuncDecl.js";
+import { ExportStmt } from "./ExportStmt.js";
+export function isTopLevelStmt(stmt) {
+    return (stmt instanceof EmptyStmt
+        || stmt instanceof VarStmt
+        || isPebbleTypeDecl(stmt)
+        || stmt instanceof FuncDecl
+        || stmt instanceof TestStmt
+        || stmt instanceof ExportStmt
+        || stmt instanceof ExportStarStmt
+        || stmt instanceof ExportImportStmt
+        || stmt instanceof ImportStmt
+        || stmt instanceof ImportStarStmt
+        || stmt instanceof TypeImplementsStmt
+        || stmt instanceof UsingStmt);
+}
+export function isBodyStmt(stmt) {
+    return (stmt instanceof IfStmt
+        || stmt instanceof VarStmt
+        || stmt instanceof ForStmt
+        || stmt instanceof ForOfStmt
+        || stmt instanceof WhileStmt
+        || stmt instanceof DoWhileStmt
+        || stmt instanceof ReturnStmt
+        || stmt instanceof BlockStmt
+        || stmt instanceof BreakStmt
+        || stmt instanceof ContinueStmt
+        || stmt instanceof EmptyStmt
+        || stmt instanceof FailStmt
+        || stmt instanceof AssertStmt
+        || stmt instanceof MatchStmt
+        || isAssignmentStmt(stmt)
+        // || stmt instanceof ExprStmt
+        || stmt instanceof IncrStmt
+        || stmt instanceof DecrStmt
+        || stmt instanceof UsingStmt);
+}

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { LitStrExpr } from "../expr/litteral/LitStrExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { BlockStmt } from "./BlockStmt.js";
+export declare class TestStmt implements HasSourceRange {
+    readonly testName: LitStrExpr | undefined;
+    readonly body: BlockStmt;
+    readonly range: SourceRange;
+    constructor(testName: LitStrExpr | undefined, body: BlockStmt, range: SourceRange);
+}

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

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

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

@@ -0,0 +1,21 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { Identifier } from "../common/Identifier.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { AstFuncType } from "../types/AstNativeTypeExpr.js";
+import { AstTypeExpr } from "../types/AstTypeExpr.js";
+import { BlockStmt } from "./BlockStmt.js";
+export declare class TypeImplementsStmt implements HasSourceRange {
+    readonly typeIdentifier: AstTypeExpr;
+    readonly interfaceType: AstTypeExpr | undefined;
+    readonly methodImplementations: InterfaceMethodImpl[];
+    readonly range: SourceRange;
+    constructor(typeIdentifier: AstTypeExpr, interfaceType: AstTypeExpr | undefined, methodImplementations: InterfaceMethodImpl[], range: SourceRange);
+}
+export declare class InterfaceMethodImpl implements HasSourceRange {
+    readonly methodName: Identifier;
+    readonly typeParameters: Identifier[];
+    readonly signature: AstFuncType;
+    readonly body: BlockStmt;
+    readonly range: SourceRange;
+    constructor(methodName: Identifier, typeParameters: Identifier[], signature: AstFuncType, body: BlockStmt, range: SourceRange);
+}

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

@@ -0,0 +1,26 @@
+export class TypeImplementsStmt {
+    typeIdentifier;
+    interfaceType;
+    methodImplementations;
+    range;
+    constructor(typeIdentifier, interfaceType, methodImplementations, range) {
+        this.typeIdentifier = typeIdentifier;
+        this.interfaceType = interfaceType;
+        this.methodImplementations = methodImplementations;
+        this.range = range;
+    }
+}
+export class InterfaceMethodImpl {
+    methodName;
+    typeParameters;
+    signature;
+    body;
+    range;
+    constructor(methodName, typeParameters, signature, body, range) {
+        this.methodName = methodName;
+        this.typeParameters = typeParameters;
+        this.signature = signature;
+        this.body = body;
+        this.range = range;
+    }
+}

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

@@ -0,0 +1,16 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { Identifier } from "../common/Identifier.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { AstTypeExpr } from "../types/AstTypeExpr.js";
+export declare class UsingStmt implements HasSourceRange {
+    readonly constructorNames: UsingStmtDeclaredConstructor[];
+    readonly structTypeExpr: AstTypeExpr;
+    readonly range: SourceRange;
+    constructor(constructorNames: UsingStmtDeclaredConstructor[], structTypeExpr: AstTypeExpr, range: SourceRange);
+}
+export declare class UsingStmtDeclaredConstructor implements HasSourceRange {
+    readonly constructorName: Identifier;
+    readonly renamedConstructorName: Identifier | undefined;
+    readonly range: SourceRange;
+    constructor(constructorName: Identifier, renamedConstructorName: Identifier | undefined, range: SourceRange);
+}

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

@@ -0,0 +1,20 @@
+export class UsingStmt {
+    constructorNames;
+    structTypeExpr;
+    range;
+    constructor(constructorNames, structTypeExpr, range) {
+        this.constructorNames = constructorNames;
+        this.structTypeExpr = structTypeExpr;
+        this.range = range;
+    }
+}
+export class UsingStmtDeclaredConstructor {
+    constructorName;
+    renamedConstructorName;
+    range;
+    constructor(constructorName, renamedConstructorName, range) {
+        this.constructorName = constructorName;
+        this.renamedConstructorName = renamedConstructorName;
+        this.range = range;
+    }
+}

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

@@ -0,0 +1,10 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { VarDecl } from "./declarations/VarDecl/VarDecl.js";
+export type AtLeastOneDecl = [VarDecl, ...VarDecl[]];
+export declare class VarStmt<Decls extends AtLeastOneDecl = AtLeastOneDecl> implements HasSourceRange {
+    readonly declarations: Decls;
+    readonly range: SourceRange;
+    constructor(declarations: Decls, range: SourceRange);
+}
+export declare function isVarStmt(node: any): node is VarStmt;

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

@@ -0,0 +1,11 @@
+export class VarStmt {
+    declarations;
+    range;
+    constructor(declarations, range) {
+        this.declarations = declarations;
+        this.range = range;
+    }
+}
+export function isVarStmt(node) {
+    return node instanceof VarStmt;
+}

package/dist/ast/nodes/statements/WhileStmt.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 WhileStmt implements HasSourceRange {
+    readonly condition: PebbleExpr;
+    readonly body: BodyStmt;
+    readonly range: SourceRange;
+    constructor(condition: PebbleExpr, body: BodyStmt, range: SourceRange);
+}

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

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

package/dist/ast/nodes/statements/declarations/EnumDecl.d.ts

@@ -0,0 +1,18 @@
+import { CommonFlags } from "../../../../common.js";
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { Identifier } from "../../common/Identifier.js";
+import { PebbleExpr } from "../../expr/PebbleExpr.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+export declare class EnumDecl implements HasSourceRange {
+    readonly name: Identifier;
+    readonly members: EnumValueDecl[];
+    readonly range: SourceRange;
+    constructor(name: Identifier, members: EnumValueDecl[], range: SourceRange);
+}
+export declare class EnumValueDecl implements HasSourceRange {
+    readonly name: Identifier;
+    readonly flags: CommonFlags;
+    readonly value: PebbleExpr | undefined;
+    readonly range: SourceRange;
+    constructor(name: Identifier, flags: CommonFlags, value: PebbleExpr | undefined, range: SourceRange);
+}

package/dist/ast/nodes/statements/declarations/EnumDecl.js

@@ -0,0 +1,22 @@
+export class EnumDecl {
+    name;
+    members;
+    range;
+    constructor(name, members, range) {
+        this.name = name;
+        this.members = members;
+        this.range = range;
+    }
+}
+export class EnumValueDecl {
+    name;
+    flags;
+    value;
+    range;
+    constructor(name, flags, value, range) {
+        this.name = name;
+        this.flags = flags;
+        this.value = value;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/declarations/FuncDecl.d.ts

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

package/dist/ast/nodes/statements/declarations/FuncDecl.js

@@ -0,0 +1,9 @@
+export class FuncDecl {
+    expr;
+    get range() {
+        return this.expr.range;
+    }
+    constructor(expr) {
+        this.expr = expr;
+    }
+}

package/dist/ast/nodes/statements/declarations/InterfaceDecl.d.ts

@@ -0,0 +1,19 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { Identifier } from "../../common/Identifier.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { BlockStmt } from "../BlockStmt.js";
+import { AstFuncType } from "../../types/AstNativeTypeExpr.js";
+export declare class InterfaceDecl implements HasSourceRange {
+    readonly name: Identifier;
+    readonly typeParams: Identifier[];
+    readonly methods: InterfaceDeclMethod[];
+    readonly range: SourceRange;
+    constructor(name: Identifier, typeParams: Identifier[], methods: InterfaceDeclMethod[], range: SourceRange);
+}
+export declare class InterfaceDeclMethod implements HasSourceRange {
+    readonly name: Identifier;
+    readonly signature: AstFuncType;
+    readonly body: BlockStmt | undefined;
+    readonly range: SourceRange;
+    constructor(name: Identifier, signature: AstFuncType, body: BlockStmt | undefined, range: SourceRange);
+}

package/dist/ast/nodes/statements/declarations/InterfaceDecl.js

@@ -0,0 +1,26 @@
+export class InterfaceDecl {
+    name;
+    typeParams;
+    methods;
+    range;
+    constructor(name, typeParams, methods, range) {
+        this.name = name;
+        this.typeParams = typeParams;
+        this.methods = methods;
+        this.range = range;
+    }
+}
+export class InterfaceDeclMethod {
+    name;
+    signature;
+    body;
+    range;
+    constructor(name, 
+    // readonly typeParams: AstTypeExpr[],
+    signature, body, range) {
+        this.name = name;
+        this.signature = signature;
+        this.body = body;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/declarations/PebbleTypeDecl.d.ts

@@ -0,0 +1,5 @@
+import { EnumDecl } from "./EnumDecl.js";
+import { StructDecl } from "./StructDecl.js";
+import { TypeAliasDecl } from "./TypeAliasDecl.js";
+export type PebbleTypeDecl = StructDecl | EnumDecl | TypeAliasDecl;
+export declare function isPebbleTypeDecl(thing: any): thing is PebbleTypeDecl;

package/dist/ast/nodes/statements/declarations/PebbleTypeDecl.js

@@ -0,0 +1,8 @@
+import { EnumDecl } from "./EnumDecl.js";
+import { StructDecl } from "./StructDecl.js";
+import { TypeAliasDecl } from "./TypeAliasDecl.js";
+export function isPebbleTypeDecl(thing) {
+    return (thing instanceof StructDecl
+        || thing instanceof EnumDecl
+        || thing instanceof TypeAliasDecl);
+}

package/dist/ast/nodes/statements/declarations/StructDecl.d.ts

@@ -0,0 +1,25 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { Identifier } from "../../common/Identifier.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { SimpleVarDecl } from "./VarDecl/SimpleVarDecl.js";
+export declare enum StructDeclAstFlags {
+    none = 0,
+    untaggedSingleConstructor = 1,
+    onlyDataEncoding = 2,
+    onlySopEncoding = 4
+}
+export declare class StructDecl implements HasSourceRange {
+    readonly name: Identifier;
+    readonly typeParams: Identifier[];
+    readonly constrs: StructConstrDecl[];
+    readonly flags: StructDeclAstFlags;
+    readonly range: SourceRange;
+    constructor(name: Identifier, typeParams: Identifier[], constrs: StructConstrDecl[], flags: StructDeclAstFlags, range: SourceRange);
+    hasFlag(flag: StructDeclAstFlags): boolean;
+}
+export declare class StructConstrDecl implements HasSourceRange {
+    readonly name: Identifier;
+    readonly fields: SimpleVarDecl[];
+    readonly range: SourceRange;
+    constructor(name: Identifier, fields: SimpleVarDecl[], range: SourceRange);
+}

package/dist/ast/nodes/statements/declarations/StructDecl.js

@@ -0,0 +1,36 @@
+export var StructDeclAstFlags;
+(function (StructDeclAstFlags) {
+    StructDeclAstFlags[StructDeclAstFlags["none"] = 0] = "none";
+    StructDeclAstFlags[StructDeclAstFlags["untaggedSingleConstructor"] = 1] = "untaggedSingleConstructor";
+    StructDeclAstFlags[StructDeclAstFlags["onlyDataEncoding"] = 2] = "onlyDataEncoding";
+    StructDeclAstFlags[StructDeclAstFlags["onlySopEncoding"] = 4] = "onlySopEncoding";
+})(StructDeclAstFlags || (StructDeclAstFlags = {}));
+export class StructDecl {
+    name;
+    typeParams;
+    constrs;
+    flags;
+    range;
+    constructor(name, typeParams, constrs, flags, range) {
+        this.name = name;
+        this.typeParams = typeParams;
+        this.constrs = constrs;
+        this.flags = flags;
+        this.range = range;
+    }
+    hasFlag(flag) {
+        return (this.flags & flag) !== 0;
+    }
+}
+export class StructConstrDecl {
+    name;
+    fields;
+    range;
+    constructor(name, 
+    // name and type
+    fields, range) {
+        this.name = name;
+        this.fields = fields;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/declarations/TypeAliasDecl.d.ts

@@ -0,0 +1,11 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { Identifier } from "../../common/Identifier.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { AstTypeExpr } from "../../types/AstTypeExpr.js";
+export declare class TypeAliasDecl implements HasSourceRange {
+    readonly name: Identifier;
+    readonly typeParams: Identifier[];
+    readonly aliasedType: AstTypeExpr;
+    readonly range: SourceRange;
+    constructor(name: Identifier, typeParams: Identifier[], aliasedType: AstTypeExpr, range: SourceRange);
+}

package/dist/ast/nodes/statements/declarations/TypeAliasDecl.js

@@ -0,0 +1,12 @@
+export class TypeAliasDecl {
+    name;
+    typeParams;
+    aliasedType;
+    range;
+    constructor(name, typeParams, aliasedType, range) {
+        this.name = name;
+        this.typeParams = typeParams;
+        this.aliasedType = aliasedType;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/declarations/VarDecl/ArrayLikeDeconstr.d.ts

@@ -0,0 +1,19 @@
+import { CommonFlags } from "../../../../../common.js";
+import { SourceRange } from "../../../../Source/SourceRange.js";
+import { Identifier } from "../../../common/Identifier.js";
+import { PebbleExpr } from "../../../expr/PebbleExpr.js";
+import { HasSourceRange } from "../../../HasSourceRange.js";
+import { AstTypeExpr } from "../../../types/AstTypeExpr.js";
+import { HasInitExpr } from "./HasInit.js";
+import { VarDecl } from "./VarDecl.js";
+export declare class ArrayLikeDeconstr implements HasSourceRange, HasInitExpr {
+    readonly elements: VarDecl[];
+    readonly rest: Identifier | undefined;
+    type: AstTypeExpr | undefined;
+    readonly initExpr: PebbleExpr | undefined;
+    flags: CommonFlags;
+    readonly range: SourceRange;
+    constructor(elements: VarDecl[], rest: Identifier | undefined, type: AstTypeExpr | undefined, // just for the type checker, or func params, usually this is inferred
+    initExpr: PebbleExpr | undefined, flags: CommonFlags, range: SourceRange);
+    isConst(): boolean;
+}

package/dist/ast/nodes/statements/declarations/VarDecl/ArrayLikeDeconstr.js

@@ -0,0 +1,19 @@
+import { CommonFlags } from "../../../../../common.js";
+export class ArrayLikeDeconstr {
+    elements;
+    rest;
+    type;
+    initExpr;
+    flags;
+    range;
+    constructor(elements, rest, type, // just for the type checker, or func params, usually this is inferred
+    initExpr, flags, range) {
+        this.elements = elements;
+        this.rest = rest;
+        this.type = type;
+        this.initExpr = initExpr;
+        this.flags = flags;
+        this.range = range;
+    }
+    isConst() { return (this.flags & CommonFlags.Const) !== 0; }
+}

package/dist/ast/nodes/statements/declarations/VarDecl/HasInit.d.ts

@@ -0,0 +1,5 @@
+import { PebbleExpr } from "../../../expr/PebbleExpr.js";
+export interface HasInitExpr {
+    readonly initExpr: PebbleExpr | undefined;
+}
+export declare function hasInitExpr(thing: any): thing is HasInitExpr;

package/dist/ast/nodes/statements/declarations/VarDecl/HasInit.js

@@ -0,0 +1,7 @@
+import { hasOwn, isObject } from "@harmoniclabs/obj-utils";
+import { isPebbleExpr } from "../../../expr/PebbleExpr.js";
+export function hasInitExpr(thing) {
+    return isObject(thing) && (isPebbleExpr(thing.initExpr) ||
+        (hasOwn(thing, "initExpr") &&
+            typeof thing.initExpr === "undefined"));
+}

package/dist/ast/nodes/statements/declarations/VarDecl/NamedDeconstructVarDecl.d.ts

@@ -0,0 +1,24 @@
+import { CommonFlags } from "../../../../../common.js";
+import { SourceRange } from "../../../../Source/SourceRange.js";
+import { Identifier } from "../../../common/Identifier.js";
+import { PebbleExpr } from "../../../expr/PebbleExpr.js";
+import { HasSourceRange } from "../../../HasSourceRange.js";
+import { AstTypeExpr } from "../../../types/AstTypeExpr.js";
+import { ISingleDeconstructVarDecl, SingleDeconstructVarDecl } from "./SingleDeconstructVarDecl.js";
+import { VarDecl } from "./VarDecl.js";
+export declare class NamedDeconstructVarDecl implements HasSourceRange, ISingleDeconstructVarDecl {
+    /** constructorName */
+    readonly name: Identifier;
+    readonly fields: Map<Identifier, VarDecl>;
+    readonly rest: Identifier | undefined;
+    type: AstTypeExpr | undefined;
+    readonly initExpr: PebbleExpr | undefined;
+    flags: CommonFlags;
+    readonly range: SourceRange;
+    constructor(
+    /** constructorName */
+    name: Identifier, fields: Map<Identifier, VarDecl>, rest: Identifier | undefined, type: AstTypeExpr | undefined, initExpr: PebbleExpr | undefined, // can be undefined when use ad function parameter
+    flags: CommonFlags, range: SourceRange);
+    isConst(): boolean;
+    static fromSingleDeconstruct(name: Identifier, unnamed: SingleDeconstructVarDecl, range?: SourceRange | undefined): NamedDeconstructVarDecl;
+}

package/dist/ast/nodes/statements/declarations/VarDecl/NamedDeconstructVarDecl.js

@@ -0,0 +1,30 @@
+import { CommonFlags } from "../../../../../common.js";
+import { SourceRange } from "../../../../Source/SourceRange.js";
+export class NamedDeconstructVarDecl {
+    name;
+    fields;
+    rest;
+    type;
+    initExpr;
+    flags;
+    range;
+    constructor(
+    /** constructorName */
+    name, fields, rest, type, initExpr, // can be undefined when use ad function parameter
+    flags, range) {
+        this.name = name;
+        this.fields = fields;
+        this.rest = rest;
+        this.type = type;
+        this.initExpr = initExpr;
+        this.flags = flags;
+        this.range = range;
+    }
+    isConst() {
+        return (this.flags & CommonFlags.Const) !== 0;
+    }
+    static fromSingleDeconstruct(name, unnamed, range = undefined) {
+        range = range instanceof SourceRange ? range.clone() : SourceRange.join(name, unnamed);
+        return new NamedDeconstructVarDecl(name, unnamed.fields, unnamed.rest, unnamed.type, unnamed.initExpr, unnamed.flags, range);
+    }
+}