json-as 0.9.29 → 1.0.0-alpha.1

package/transform/src/linker.ts

@@ -0,0 +1,21 @@
+import { ClassDeclaration, ImportStatement, NodeKind, Parser, Source } from "assemblyscript/dist/assemblyscript.js";
+
+export function getImports(source: Source): ImportStatement[] {
+  return source.statements.filter((v) => v.kind === NodeKind.Import) as ImportStatement[];
+}
+
+export function getImportedClass(name: string, source: Source, parser: Parser): ClassDeclaration | null {
+  for (const stmt of getImports(source)) {
+    const externalSource = parser.sources.find((src) => src.internalPath === stmt.internalPath);
+    if (!externalSource) continue;
+
+    const classDeclaration = externalSource.statements.find((s) => s.kind === NodeKind.ClassDeclaration && (<ClassDeclaration>s).name.text === name) as ClassDeclaration | null;
+
+    if (classDeclaration) return classDeclaration;
+  }
+  return null;
+}
+
+export function getClasses(source: Source): ClassDeclaration[] {
+  return source.statements.filter((v) => v.kind === NodeKind.ClassDeclaration) as ClassDeclaration[];
+}

package/transform/src/types.ts

@@ -0,0 +1,27 @@
+import { ClassDeclaration, Expression, FieldDeclaration } from "assemblyscript/dist/assemblyscript.js";
+
+export enum PropertyFlags {
+  OmitNull,
+  OmitIf,
+  Raw,
+}
+
+export class Property {
+  public name: string = "";
+  public alias: string | null = null;
+  public type: string = "";
+  public value: string | null = null;
+  public flags: Map<PropertyFlags, Expression | null> = new Map<PropertyFlags, Expression | null>();
+  public node!: FieldDeclaration;
+  public byteSize: number = 0;
+}
+
+export class Schema {
+  public static: boolean = true;
+  public name: string = "";
+  public members: Property[] = [];
+  public parent: Schema | null = null;
+  public node!: ClassDeclaration;
+  public needsLink: string | null = null;
+  public byteSize: number = 0;
+}

package/transform/src/util.ts

@@ -0,0 +1,56 @@
+// Taken from https://github.com/as-pect/visitor-as/blob/master/src/simpleParser.ts
+import { Parser, Tokenizer, Source, SourceKind, Expression, Statement, NamespaceDeclaration, ClassDeclaration, DeclarationStatement, Range, Node } from "assemblyscript/dist/assemblyscript.js";
+import { ASTBuilder } from "./builder.js";
+
+export class SimpleParser {
+  private static get parser(): Parser {
+    return new Parser();
+  }
+
+  private static getTokenizer(s: string, file: string = "index.ts"): Tokenizer {
+    return new Tokenizer(new Source(SourceKind.User, file, s));
+  }
+
+  static parseExpression(s: string): Expression {
+    const res = this.parser.parseExpression(this.getTokenizer(s));
+    if (res == null) {
+      throw new Error("Failed to parse the expression: '" + s + "'");
+    }
+    return res;
+  }
+
+  static parseStatement(s: string, topLevel = false): Statement {
+    const res = this.parser.parseStatement(this.getTokenizer(s), topLevel);
+    if (res == null) {
+      throw new Error("Failed to parse the statement: '" + s + "'");
+    }
+    return res;
+  }
+
+  static parseTopLevelStatement(s: string, namespace?: NamespaceDeclaration | null): Statement {
+    const res = this.parser.parseTopLevelStatement(this.getTokenizer(s), namespace);
+    if (res == null) {
+      throw new Error("Failed to parse the top level statement: '" + s + "'");
+    }
+    return res;
+  }
+
+  static parseClassMember(s: string, _class: ClassDeclaration): DeclarationStatement {
+    let res = this.parser.parseClassMember(this.getTokenizer(s, _class.range.source.normalizedPath), _class);
+    if (res == null) {
+      throw new Error("Failed to parse the class member: '" + s + "'");
+    }
+    return <DeclarationStatement>res;
+  }
+}
+
+let isStdlibRegex = /\~lib\/(?:array|arraybuffer|atomics|builtins|crypto|console|compat|dataview|date|diagnostics|error|function|iterator|map|math|number|object|process|reference|regexp|set|staticarray|string|symbol|table|typedarray|vector|rt\/?|bindings\/|shared\/typeinfo)|util\/|uri|polyfills|memory/;
+
+export function isStdlib(s: Source | { range: Range }): boolean {
+  let source = s instanceof Source ? s : s.range.source;
+  return isStdlibRegex.test(source.internalPath);
+}
+
+export function toString(node: Node): string {
+  return ASTBuilder.build(node);
+}

package/transform/src/visitor.ts

@@ -0,0 +1,531 @@
+import { ArrayLiteralExpression, AssertionExpression, BinaryExpression, CallExpression, ElementAccessExpression, FloatLiteralExpression, FunctionTypeNode, IdentifierExpression, NamedTypeNode, Node, ObjectLiteralExpression, Source, TypeParameterNode, BlockStatement, BreakStatement, ClassDeclaration, ClassExpression, CommaExpression, ContinueStatement, DecoratorNode, DoStatement, EmptyStatement, EnumDeclaration, EnumValueDeclaration, ExportDefaultStatement, ExportImportStatement, ExportMember, ExportStatement, ExpressionStatement, FieldDeclaration, ForStatement, FunctionDeclaration, FunctionExpression, IfStatement, ImportDeclaration, ImportStatement, IndexSignatureNode, InstanceOfExpression, IntegerLiteralExpression, InterfaceDeclaration, LiteralExpression, MethodDeclaration, NamespaceDeclaration, NewExpression, ParameterNode, ParenthesizedExpression, PropertyAccessExpression, RegexpLiteralExpression, ReturnStatement, StringLiteralExpression, SwitchCase, SwitchStatement, TemplateLiteralExpression, TernaryExpression, ThrowStatement, TryStatement, TypeDeclaration, TypeName, UnaryPostfixExpression, UnaryPrefixExpression, VariableDeclaration, VariableStatement, WhileStatement, NodeKind, TypeNode, Expression, LiteralKind, UnaryExpression, SuperExpression, FalseExpression, TrueExpression, ThisExpression, NullExpression, ConstructorExpression, Statement, VoidStatement, CompiledExpression, CommentNode, Module, OmittedExpression, ForOfStatement, ModuleDeclaration } from "assemblyscript/dist/assemblyscript.js";
+import { toString } from "./util.js";
+
+export class Visitor {
+  public currentSource: Source | null = null;
+  visit(node: Node | Node[], ref: Node | null = null): void {
+    if (node == null) return;
+    if (node instanceof Array) {
+      for (const n of node) {
+        this._visit(n, ref);
+      }
+    } else {
+      // @ts-ignore
+      this._visit(node, ref);
+    }
+  }
+  _visit(node: Node, ref: Node | null): void {
+    switch (node.kind) {
+      case NodeKind.Source:
+        this.visitSource(node as Source, ref);
+        break;
+      case NodeKind.NamedType:
+        this.visitNamedTypeNode(node as NamedTypeNode, ref);
+        break;
+      case NodeKind.FunctionType:
+        this.visitFunctionTypeNode(node as FunctionTypeNode, ref);
+        break;
+      case NodeKind.TypeName:
+        this.visitTypeName(node as TypeName, ref);
+        break;
+      case NodeKind.TypeParameter:
+        this.visitTypeParameter(node as TypeParameterNode, ref);
+        break;
+      case NodeKind.Identifier:
+        this.visitIdentifierExpression(node as IdentifierExpression, ref);
+        break;
+      case NodeKind.Assertion:
+        this.visitAssertionExpression(node as AssertionExpression, ref);
+        break;
+      case NodeKind.Binary:
+        this.visitBinaryExpression(node as BinaryExpression, ref);
+        break;
+      case NodeKind.Call:
+        this.visitCallExpression(node as CallExpression, ref);
+        break;
+      case NodeKind.Class:
+        this.visitClassExpression(node as ClassExpression, ref);
+        break;
+      case NodeKind.Comma:
+        this.visitCommaExpression(node as CommaExpression, ref);
+        break;
+      case NodeKind.ElementAccess:
+        this.visitElementAccessExpression(node as ElementAccessExpression, ref);
+        break;
+      case NodeKind.Function:
+        this.visitFunctionExpression(node as FunctionExpression, ref);
+        break;
+      case NodeKind.InstanceOf:
+        this.visitInstanceOfExpression(node as InstanceOfExpression, ref);
+        break;
+      case NodeKind.Literal:
+        this.visitLiteralExpression(node as LiteralExpression, ref);
+        break;
+      case NodeKind.New:
+        this.visitNewExpression(node as NewExpression, ref);
+        break;
+      case NodeKind.Parenthesized:
+        this.visitParenthesizedExpression(node as ParenthesizedExpression, ref);
+        break;
+      case NodeKind.PropertyAccess:
+        this.visitPropertyAccessExpression(node as PropertyAccessExpression, ref);
+        break;
+      case NodeKind.Ternary:
+        this.visitTernaryExpression(node as TernaryExpression, ref);
+        break;
+      case NodeKind.UnaryPostfix:
+        this.visitUnaryPostfixExpression(node as UnaryPostfixExpression, ref);
+        break;
+      case NodeKind.UnaryPrefix:
+        this.visitUnaryPrefixExpression(node as UnaryPrefixExpression, ref);
+        break;
+      case NodeKind.Block:
+        this.visitBlockStatement(node as BlockStatement, ref);
+        break;
+      case NodeKind.Break:
+        this.visitBreakStatement(node as BreakStatement, ref);
+        break;
+      case NodeKind.Continue:
+        this.visitContinueStatement(node as ContinueStatement, ref);
+        break;
+      case NodeKind.Do:
+        this.visitDoStatement(node as DoStatement, ref);
+        break;
+      case NodeKind.Empty:
+        this.visitEmptyStatement(node as EmptyStatement, ref);
+        break;
+      case NodeKind.Export:
+        this.visitExportStatement(node as ExportStatement, ref);
+        break;
+      case NodeKind.ExportDefault:
+        this.visitExportDefaultStatement(node as ExportDefaultStatement, ref);
+        break;
+      case NodeKind.ExportImport:
+        this.visitExportImportStatement(node as ExportImportStatement, ref);
+        break;
+      case NodeKind.Expression:
+        this.visitExpressionStatement(node as ExpressionStatement, ref);
+        break;
+      case NodeKind.For:
+        this.visitForStatement(node as ForStatement, ref);
+        break;
+      case NodeKind.If:
+        this.visitIfStatement(node as IfStatement, ref);
+        break;
+      case NodeKind.Import:
+        this.visitImportStatement(node as ImportStatement, ref);
+        break;
+      case NodeKind.Return:
+        this.visitReturnStatement(node as ReturnStatement, ref);
+        break;
+      case NodeKind.Switch:
+        this.visitSwitchStatement(node as SwitchStatement, ref);
+        break;
+      case NodeKind.Throw:
+        this.visitThrowStatement(node as ThrowStatement, ref);
+        break;
+      case NodeKind.Try:
+        this.visitTryStatement(node as TryStatement, ref);
+        break;
+      case NodeKind.Variable:
+        this.visitVariableStatement(node as VariableStatement, ref);
+        break;
+      case NodeKind.While:
+        this.visitWhileStatement(node as WhileStatement, ref);
+        break;
+      case NodeKind.ClassDeclaration:
+        this.visitClassDeclaration(node as ClassDeclaration, false, ref);
+        break;
+      case NodeKind.EnumDeclaration:
+        this.visitEnumDeclaration(node as EnumDeclaration, false, ref);
+        break;
+      case NodeKind.EnumValueDeclaration:
+        this.visitEnumValueDeclaration(node as EnumValueDeclaration, ref);
+        break;
+      case NodeKind.FieldDeclaration:
+        this.visitFieldDeclaration(node as FieldDeclaration, ref);
+        break;
+      case NodeKind.FunctionDeclaration:
+        this.visitFunctionDeclaration(node as FunctionDeclaration, false, ref);
+        break;
+      case NodeKind.ImportDeclaration:
+        this.visitImportDeclaration(node as ImportDeclaration, ref);
+        break;
+      case NodeKind.InterfaceDeclaration:
+        this.visitInterfaceDeclaration(node as InterfaceDeclaration, false, ref);
+        break;
+      case NodeKind.MethodDeclaration:
+        this.visitMethodDeclaration(node as MethodDeclaration, ref);
+        break;
+      case NodeKind.NamespaceDeclaration:
+        this.visitNamespaceDeclaration(node as NamespaceDeclaration, false, ref);
+        break;
+      case NodeKind.TypeDeclaration:
+        this.visitTypeDeclaration(node as TypeDeclaration, ref);
+        break;
+      case NodeKind.VariableDeclaration:
+        this.visitVariableDeclaration(node as VariableDeclaration, ref);
+        break;
+      case NodeKind.Decorator:
+        this.visitDecoratorNode(node as DecoratorNode, ref);
+        break;
+      case NodeKind.ExportMember:
+        this.visitExportMember(node as ExportMember, ref);
+        break;
+      case NodeKind.SwitchCase:
+        this.visitSwitchCase(node as SwitchCase, ref);
+        break;
+      case NodeKind.IndexSignature:
+        this.visitIndexSignature(node as IndexSignatureNode, ref);
+        break;
+      case NodeKind.Null:
+        this.visitNullExpression(node as NullExpression, ref);
+        break;
+      case NodeKind.True: {
+        this.visitTrueExpression(node as TrueExpression, ref);
+        break;
+      }
+      case NodeKind.False: {
+        this.visitFalseExpression(node as FalseExpression, ref);
+        break;
+      }
+      case NodeKind.Compiled: {
+        this.visitCompiledExpression(node as CompiledExpression, ref);
+        break;
+      }
+      case NodeKind.Constructor: {
+        this.visitConstructorExpression(node as ConstructorExpression, ref);
+        break;
+      }
+      case NodeKind.Comment: {
+        this.visitComment(node as CommentNode, ref);
+        break;
+      }
+      case NodeKind.ForOf: {
+        this.visitForOfStatement(node as ForOfStatement, ref);
+        break;
+      }
+      case NodeKind.Module: {
+        this.visitModuleDeclaration(node as ModuleDeclaration, ref);
+        break;
+      }
+      case NodeKind.Omitted: {
+        this.visitOmittedExpression(node as OmittedExpression, ref);
+        break;
+      }
+      case NodeKind.Parameter: {
+        this.visitParameter(node as ParameterNode, ref);
+        break;
+      }
+      case NodeKind.Super: {
+        this.visitSuperExpression(node as SuperExpression, ref);
+        break;
+      }
+      case NodeKind.This: {
+        this.visitThisExpression(node as ThisExpression, ref);
+        break;
+      }
+      case NodeKind.Void: {
+        this.visitVoidStatement(node as VoidStatement, ref);
+        break;
+      }
+      default:
+        throw new Error("Could not visit invalid type!");
+    }
+  }
+  visitSource(node: Source, ref: Node | null = null): void {
+    this.currentSource = node;
+    this.visit(node.statements, node);
+    this.currentSource = null;
+  }
+  visitTypeNode(node: TypeNode, ref: Node | null = null): void {}
+  visitTypeName(node: TypeName, ref: Node | null = null): void {
+    this.visit(node.identifier, node);
+    this.visit(node.next, node);
+  }
+  visitNamedTypeNode(node: NamedTypeNode, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.typeArguments, node);
+  }
+  visitFunctionTypeNode(node: FunctionTypeNode, ref: Node | null = null): void {
+    this.visit(node.parameters, node);
+    this.visit(node.returnType, node);
+    this.visit(node.explicitThisType, node);
+  }
+  visitTypeParameter(node: TypeParameterNode, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.extendsType, node);
+    this.visit(node.defaultType, node);
+  }
+  visitIdentifierExpression(node: IdentifierExpression, ref: Node | null = null): void {}
+  visitArrayLiteralExpression(node: ArrayLiteralExpression, ref: Node | null = null): void {
+    this.visit(node.elementExpressions, node);
+  }
+  visitObjectLiteralExpression(node: ObjectLiteralExpression, ref: Node | null = null): void {
+    this.visit(node.names, node);
+    this.visit(node.values, node);
+  }
+  visitAssertionExpression(node: AssertionExpression, ref: Node | null = null): void {
+    this.visit(node.toType, node);
+    this.visit(node.expression, node);
+  }
+  visitBinaryExpression(node: BinaryExpression, ref: Node | null = null): void {
+    this.visit(node.left, node);
+    this.visit(node.right, node);
+  }
+  visitCallExpression(node: CallExpression, ref: Node | null = null): void {
+    this.visit(node.expression, node);
+    this.visit(node.typeArguments, node);
+    this.visit(node.args, node);
+  }
+  visitClassExpression(node: ClassExpression, ref: Node | null = null): void {
+    this.visit(node.declaration, node);
+  }
+  visitCommaExpression(node: CommaExpression, ref: Node | null = null): void {
+    this.visit(node.expressions, node);
+  }
+  visitElementAccessExpression(node: ElementAccessExpression, ref: Node | null = null): void {
+    this.visit(node.elementExpression, node);
+    this.visit(node.expression, node);
+  }
+  visitFunctionExpression(node: FunctionExpression, ref: Node | null = null): void {
+    this.visit(node.declaration, node);
+  }
+  visitLiteralExpression(node: LiteralExpression, ref: Node | null = null): void {
+    switch (node.literalKind) {
+      case LiteralKind.Float:
+        this.visitFloatLiteralExpression(node as FloatLiteralExpression);
+        break;
+      case LiteralKind.Integer:
+        this.visitIntegerLiteralExpression(node as IntegerLiteralExpression);
+        break;
+      case LiteralKind.String:
+        this.visitStringLiteralExpression(node as StringLiteralExpression);
+        break;
+      case LiteralKind.Template:
+        this.visitTemplateLiteralExpression(node as TemplateLiteralExpression);
+        break;
+      case LiteralKind.RegExp:
+        this.visitRegexpLiteralExpression(node as RegexpLiteralExpression);
+        break;
+      case LiteralKind.Array:
+        this.visitArrayLiteralExpression(node as ArrayLiteralExpression);
+        break;
+      case LiteralKind.Object:
+        this.visitObjectLiteralExpression(node as ObjectLiteralExpression);
+        break;
+      default:
+        throw new Error("Invalid LiteralKind at visitLiteralExpression(): " + node.literalKind);
+    }
+  }
+  visitFloatLiteralExpression(node: FloatLiteralExpression, ref: Node | null = null): void {}
+  visitInstanceOfExpression(node: InstanceOfExpression, ref: Node | null = null): void {
+    this.visit(node.expression, node);
+    this.visit(node.isType, node);
+  }
+  visitIntegerLiteralExpression(node: IntegerLiteralExpression, ref: Node | null = null): void {}
+  visitStringLiteralExpression(node: StringLiteralExpression, ref: Node | null = null): void {}
+  visitTemplateLiteralExpression(node: TemplateLiteralExpression, ref: Node | null = null): void {}
+  visitRegexpLiteralExpression(node: RegexpLiteralExpression, ref: Node | null = null): void {}
+  visitNewExpression(node: NewExpression, ref: Node | null = null): void {
+    this.visit(node.typeName, node);
+    this.visit(node.typeArguments, node);
+    this.visit(node.args, node);
+  }
+  visitParenthesizedExpression(node: ParenthesizedExpression, ref: Node | null = null): void {
+    this.visit(node.expression, node);
+  }
+  visitPropertyAccessExpression(node: PropertyAccessExpression, ref: Node | null = null): void {
+    this.visit(node.property, node);
+    this.visit(node.expression, node);
+  }
+  visitTernaryExpression(node: TernaryExpression, ref: Node | null = null): void {
+    this.visit(node.condition, node);
+    this.visit(node.ifThen, node);
+    this.visit(node.ifElse, node);
+  }
+  visitUnaryExpression(node: UnaryExpression, ref: Node | null = null): void {
+    this.visit(node.operand, node);
+  }
+  visitUnaryPostfixExpression(node: UnaryPostfixExpression, ref: Node | null = null): void {
+    this.visit(node.operand, node);
+  }
+  visitUnaryPrefixExpression(node: UnaryPrefixExpression, ref: Node | null = null): void {
+    this.visit(node.operand, node);
+  }
+  visitSuperExpression(node: SuperExpression, ref: Node | null = null): void {}
+  visitFalseExpression(node: FalseExpression, ref: Node | null = null): void {}
+  visitTrueExpression(node: TrueExpression, ref: Node | null = null): void {}
+  visitThisExpression(node: ThisExpression, ref: Node | null = null): void {}
+  visitNullExpression(node: NullExpression, ref: Node | null = null): void {}
+  visitConstructorExpression(node: ConstructorExpression, ref: Node | null = null): void {}
+  visitNodeAndTerminate(statement: Statement, ref: Node | null = null): void {}
+  visitBlockStatement(node: BlockStatement, ref: Node | null = null): void {
+    this.visit(node.statements, node);
+  }
+  visitBreakStatement(node: BreakStatement, ref: Node | null = null): void {
+    this.visit(node.label, node);
+  }
+  visitContinueStatement(node: ContinueStatement, ref: Node | null = null): void {
+    this.visit(node.label, node);
+  }
+  visitClassDeclaration(node: ClassDeclaration, isDefault: boolean = false, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.decorators, node);
+    if (node.isGeneric ? node.typeParameters != null : node.typeParameters == null) {
+      this.visit(node.typeParameters, node);
+      this.visit(node.extendsType, node);
+      this.visit(node.implementsTypes, node);
+      this.visit(node.members, node);
+    } else {
+      throw new Error("Expected to type parameters to match class declaration, but found type mismatch instead!");
+    }
+  }
+  visitDoStatement(node: DoStatement, ref: Node | null = null): void {
+    this.visit(node.condition, node);
+    this.visit(node.body, node);
+  }
+  visitEmptyStatement(node: EmptyStatement, ref: Node | null = null): void {}
+  visitEnumDeclaration(node: EnumDeclaration, isDefault: boolean = false, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.decorators, node);
+    this.visit(node.values, node);
+  }
+  visitEnumValueDeclaration(node: EnumValueDeclaration, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.initializer, node);
+  }
+  visitExportImportStatement(node: ExportImportStatement, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.externalName, node);
+  }
+  visitExportMember(node: ExportMember, ref: Node | null = null): void {
+    this.visit(node.localName, node);
+    this.visit(node.exportedName, node);
+  }
+  visitExportStatement(node: ExportStatement, ref: Node | null = null): void {
+    this.visit(node.path, node);
+    this.visit(node.members, node);
+  }
+  visitExportDefaultStatement(node: ExportDefaultStatement, ref: Node | null = null): void {
+    this.visit(node.declaration, node);
+  }
+  visitExpressionStatement(node: ExpressionStatement, ref: Node | null = null): void {
+    this.visit(node.expression, ref);
+  }
+  visitFieldDeclaration(node: FieldDeclaration, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.type, node);
+    this.visit(node.initializer, node);
+    this.visit(node.decorators, node);
+  }
+  visitForStatement(node: ForStatement, ref: Node | null = null): void {
+    this.visit(node.initializer, node);
+    this.visit(node.condition, node);
+    this.visit(node.incrementor, node);
+    this.visit(node.body, node);
+  }
+  visitFunctionDeclaration(node: FunctionDeclaration, isDefault: boolean = false, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.decorators, node);
+    this.visit(node.typeParameters, node);
+    this.visit(node.signature, node);
+    this.visit(node.body, node);
+  }
+  visitIfStatement(node: IfStatement, ref: Node | null = null): void {
+    this.visit(node.condition, node);
+    this.visit(node.ifTrue, node);
+    this.visit(node.ifFalse, node);
+  }
+  visitImportDeclaration(node: ImportDeclaration, ref: Node | null = null): void {
+    this.visit(node.foreignName, node);
+    this.visit(node.name, node);
+    this.visit(node.decorators, node);
+  }
+  visitImportStatement(node: ImportStatement, ref: Node | null = null): void {
+    this.visit(node.namespaceName, node);
+    this.visit(node.declarations, node);
+  }
+  visitIndexSignature(node: IndexSignatureNode, ref: Node | null = null): void {
+    this.visit(node.keyType, node);
+    this.visit(node.valueType, node);
+  }
+  visitInterfaceDeclaration(node: InterfaceDeclaration, isDefault: boolean = false, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.typeParameters, node);
+    this.visit(node.implementsTypes, node);
+    this.visit(node.extendsType, node);
+    this.visit(node.members, node);
+  }
+  visitMethodDeclaration(node: MethodDeclaration, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.typeParameters, node);
+    this.visit(node.signature, node);
+    this.visit(node.decorators, node);
+    this.visit(node.body, node);
+  }
+  visitNamespaceDeclaration(node: NamespaceDeclaration, isDefault: boolean = false, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.decorators, node);
+    this.visit(node.members, node);
+  }
+  visitReturnStatement(node: ReturnStatement, ref: Node | null = null): void {
+    this.visit(node.value, node);
+  }
+  visitSwitchCase(node: SwitchCase, ref: Node | null = null): void {
+    this.visit(node.label, node);
+    this.visit(node.statements, node);
+  }
+  visitSwitchStatement(node: SwitchStatement, ref: Node | null = null): void {
+    this.visit(node.condition, node);
+    this.visit(node.cases, node);
+  }
+  visitThrowStatement(node: ThrowStatement, ref: Node | null = null): void {
+    this.visit(node.value, node);
+  }
+  visitTryStatement(node: TryStatement, ref: Node | null = null): void {
+    this.visit(node.bodyStatements, node);
+    this.visit(node.catchVariable, node);
+    this.visit(node.catchStatements, node);
+    this.visit(node.finallyStatements, node);
+  }
+  visitTypeDeclaration(node: TypeDeclaration, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.decorators, node);
+    this.visit(node.type, node);
+    this.visit(node.typeParameters, node);
+  }
+  visitVariableDeclaration(node: VariableDeclaration, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.type, node);
+    this.visit(node.initializer, node);
+  }
+  visitVariableStatement(node: VariableStatement, ref: Node | null = null): void {
+    this.visit(node.decorators, node);
+    this.visit(node.declarations, node);
+  }
+  visitWhileStatement(node: WhileStatement, ref: Node | null = null): void {
+    this.visit(node.condition, node);
+    this.visit(node.body, node);
+  }
+  visitVoidStatement(node: VoidStatement, ref: Node | null = null): void {}
+  visitComment(node: CommentNode, ref: Node | null = null): void {}
+  visitDecoratorNode(node: DecoratorNode, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.args, node);
+  }
+  visitParameter(node: ParameterNode, ref: Node | null = null): void {
+    this.visit(node.name, node);
+    this.visit(node.implicitFieldDeclaration, node);
+    this.visit(node.initializer, node);
+    this.visit(node.type, node);
+  }
+  visitCompiledExpression(node: CompiledExpression, ref: Node | null = null): void {}
+  visitForOfStatement(node: ForOfStatement, ref: Node | null = null): void {
+    this.visit(node.body, node);
+    this.visit(node.variable, node);
+    this.visit(node.iterable, node);
+  }
+  visitModuleDeclaration(node: ModuleDeclaration, ref: Node | null = null): void {}
+  visitOmittedExpression(node: OmittedExpression, ref: Node | null = null): void {}
+}

package/transform/tsconfig.json

@@ -4,7 +4,9 @@
     "module": "ES2020",
     "moduleResolution": "Node",
     "removeComments": true,
+    "types": ["node"],
     "outDir": "./lib",
     "sourceMap": true
-  }
+  },
+  "include": ["./src/*.ts"]
 }

package/assembly/__benches__/as-tral.d.ts

@@ -1 +0,0 @@
-/// <reference types="@as-tral/cli/as-tral" />

package/assembly/__tests__/date.spec.ts

@@ -1,12 +0,0 @@
-import { JSON } from "json-as";
-import { describe, expect, run } from "as-test/assembly";
-
-describe("Should serialize dates", () => {
-  expect(JSON.stringify(new Date(1767184496789))).toBe('"2025-12-31T12:34:56.789Z"');
-});
-
-describe("Should deserialize dates", () => {
-  expect(JSON.parse<Date>('"2025-12-31T12:34:56.789Z"').getTime()).toBe(1767184496789);
-});
-
-run();