jass 0.9.1

data/lib/jass/errors.rb

@@ -0,0 +1,29 @@
+module Jass
+  class Error < StandardError; end
+  
+  class JavaScriptError < Error
+    attr_reader :attributes
+    
+    def initialize(attributes = {})
+      @attributes = attributes || {}
+      if stack = attributes['stack']
+        set_backtrace stack.split("\n")
+      end
+    end
+    
+    def to_s
+      generate_message
+    end
+    
+    private
+    
+    def generate_message
+      message = "#{attributes['message'] || 'Unknown error'}"
+      if loc = attributes['loc']
+        message << loc.inject(' in') { |s, (key, value)| s << " #{key}: #{value}" }
+      end
+    end
+  end
+  
+  class DependencyError < JavaScriptError; end
+end

data/lib/jass/es6_processor.rb

@@ -0,0 +1,17 @@
+module Jass
+  class ES6Processor
+    class << self
+      def instance
+        @instance ||= new
+      end
+      
+      def call(input)
+        instance.call(input)
+      end
+    end
+    
+    def call(input)
+      { data: Compiler.compile(input[:data]) }
+    end
+  end
+end

data/lib/jass/function.rb

@@ -0,0 +1,13 @@
+module Jass
+  class Function
+    attr_reader :name, :code
+    
+    def initialize(name, code)
+      @name, @code = name, code
+    end
+    
+    def to_js
+      "__methods__[#{name.to_json}] = (#{code});\n"
+    end
+  end
+end

data/lib/jass/global_directive_processor.rb

@@ -0,0 +1,12 @@
+module Jass
+  class GlobalDirectiveProcessor < Sprockets::DirectiveProcessor
+    def process_global_directive(package, variable)
+      @globals[package] = variable
+    end
+    
+    def _call(input)
+      @globals = (input[:metadata][:globals] ||= {})
+      super
+    end
+  end
+end

data/lib/jass/plugin.rb

@@ -0,0 +1,13 @@
+module Jass
+  class Plugin
+    attr_reader :name, :arguments, :root
+    
+    def initialize(name, arguments = nil, root = nil)
+      @name, @arguments, @root = name, arguments, root
+    end
+    
+    def to_js
+      "__plugins__.push(#{name}(#{arguments}));\n"
+    end
+  end
+end

data/lib/jass/railtie.rb

@@ -0,0 +1,12 @@
+require 'rails/railtie'
+require 'active_support'
+
+module Jass
+  class Railtie < Rails::Railtie
+    config.jass = ActiveSupport::OrderedOptions.new
+
+    initializer 'jass' do |app|
+      Jass.vendor_modules_root = Rails.root.join('vendor')
+    end
+  end
+end

data/lib/jass/version.rb

@@ -0,0 +1,3 @@
+module Jass
+  VERSION = '0.9.1'
+end

data/vendor/node_modules/@types/acorn/index.d.ts

@@ -0,0 +1,256 @@
+// Type definitions for Acorn 4.0
+// Project: https://github.com/marijnh/acorn
+// Definitions by: RReverser <https://github.com/RReverser>, e-cloud <https://github.com/e-cloud>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export as namespace acorn;
+export = acorn;
+import * as ESTree from 'estree';
+
+declare namespace acorn {
+    interface PlainObject {
+        [name: string]: any;
+    }
+
+    interface PluginsObject {
+        [name: string]: (p: Parser, config: any) => void;
+    }
+
+    interface Options {
+        ecmaVersion?: 3 | 5 | 6 | 7 | 8 | 2015 | 2016 | 2017;
+        sourceType?: 'script' | 'module';
+        onInsertedSemicolon?: (lastTokEnd: number, lastTokEndLoc?: ESTree.Position) => void;
+        onTrailingComma?: (lastTokEnd: number, lastTokEndLoc?: ESTree.Position) => void;
+        allowReserved?: boolean;
+        allowReturnOutsideFunction?: boolean;
+        allowImportExportEverywhere?: boolean;
+        allowHashBang?: boolean;
+        locations?: boolean;
+        onToken?: ((token: Token) => any) | Token[];
+        onComment?: ((
+            isBlock: boolean, text: string, start: number, end: number, startLoc?: ESTree.Position,
+            endLoc?: ESTree.Position
+        ) => void) | Comment[];
+        ranges?: boolean;
+        program?: ESTree.Program;
+        sourceFile?: string;
+        directSourceFile?: string;
+        preserveParens?: boolean;
+        plugins?: PlainObject;
+    }
+
+    class Parser {
+        constructor(options: Options, input: string, startPos?: number);
+
+        parse(): ESTree.Program;
+    }
+
+    const plugins: PluginsObject;
+
+    const defaultOptions: Options;
+
+    class Position implements ESTree.Position {
+        line: number;
+        column: number;
+
+        constructor(line: number, col: number);
+
+        offset(n: number): Position;
+    }
+
+    class SourceLocation implements ESTree.SourceLocation {
+        start: Position;
+        end: Position;
+        source?: string | null;
+
+        constructor(p: Parser, start: Position, end: Position);
+    }
+
+    function getLineInfo(input: string, offset: number): ESTree.Position;
+
+    class Node {
+        type: string;
+        start: number;
+        end: number;
+        loc?: ESTree.SourceLocation;
+        sourceFile?: string;
+        range?: [number, number];
+
+        constructor(parser: Parser, pos: number, loc: number);
+    }
+
+    interface TokeTypeConfig {
+        keyword: string;
+        beforeExpr?: boolean;
+        startsExpr?: boolean;
+        isLoop?: boolean;
+        isAssign?: boolean;
+        prefix?: boolean;
+        postfix?: boolean;
+        binop?: number;
+    }
+
+    class TokenType {
+        label: string;
+        keyword: string;
+        beforeExpr: boolean;
+        startsExpr: boolean;
+        isLoop: boolean;
+        isAssign: boolean;
+        prefix: boolean;
+        postfix: boolean;
+        binop: number;
+        updateContext: (prevType: TokenType) => void;
+
+        constructor(label: string, conf?: TokeTypeConfig);
+    }
+
+    const tokTypes: {
+        num: TokenType;
+        regexp: TokenType;
+        string: TokenType;
+        name: TokenType;
+        eof: TokenType;
+        bracketL: TokenType;
+        bracketR: TokenType;
+        braceL: TokenType;
+        braceR: TokenType;
+        parenL: TokenType;
+        parenR: TokenType;
+        comma: TokenType;
+        semi: TokenType;
+        colon: TokenType;
+        dot: TokenType;
+        question: TokenType;
+        arrow: TokenType;
+        template: TokenType;
+        ellipsis: TokenType;
+        backQuote: TokenType;
+        dollarBraceL: TokenType;
+        eq: TokenType;
+        assign: TokenType;
+        incDec: TokenType;
+        prefix: TokenType;
+        logicalOR: TokenType;
+        logicalAND: TokenType;
+        bitwiseOR: TokenType;
+        bitwiseXOR: TokenType;
+        bitwiseAND: TokenType;
+        equality: TokenType;
+        relational: TokenType;
+        bitShift: TokenType;
+        plusMin: TokenType;
+        modulo: TokenType;
+        star: TokenType;
+        slash: TokenType;
+        starstar: TokenType;
+        _break: TokenType;
+        _case: TokenType;
+        _catch: TokenType;
+        _continue: TokenType;
+        _debugger: TokenType;
+        _default: TokenType;
+        _do: TokenType;
+        _else: TokenType;
+        _finally: TokenType;
+        _for: TokenType;
+        _function: TokenType;
+        _if: TokenType;
+        _return: TokenType;
+        _switch: TokenType;
+        _throw: TokenType;
+        _try: TokenType;
+        _var: TokenType;
+        _const: TokenType;
+        _while: TokenType;
+        _with: TokenType;
+        _new: TokenType;
+        _this: TokenType;
+        _super: TokenType;
+        _class: TokenType;
+        _extends: TokenType;
+        _export: TokenType;
+        _import: TokenType;
+        _null: TokenType;
+        _true: TokenType;
+        _false: TokenType;
+        _in: TokenType;
+        _instanceof: TokenType;
+        _typeof: TokenType;
+        _void: TokenType;
+        _delete: TokenType;
+    };
+
+    class TokContext {
+        constructor(token: string, isExpr: boolean, preserveSpace: boolean, override: (p: Parser) => void);
+    }
+
+    const tokContexts: {
+        b_stat: TokContext;
+        b_expr: TokContext;
+        b_tmpl: TokContext;
+        p_stat: TokContext;
+        p_expr: TokContext;
+        q_tmpl: TokContext;
+        f_expr: TokContext;
+    };
+
+    function isIdentifierStart(code: number, astral?: boolean): boolean;
+
+    function isIdentifierChar(code: number, astral?: boolean): boolean;
+
+    interface AbstractToken {
+        start: number;
+        end: number;
+        loc?: SourceLocation;
+        range?: [number, number];
+    }
+
+    interface Comment extends AbstractToken {
+        type: string;
+        value: string;
+    }
+
+    class Token {
+        constructor(p: Parser);
+    }
+
+    interface Token extends AbstractToken {
+        type: TokenType;
+        value: any;
+    }
+
+    function isNewLine(code: number): boolean;
+
+    const lineBreak: RegExp;
+
+    const lineBreakG: RegExp;
+
+    const version: string;
+
+    // TODO: rename type.
+    type IParse = (input: string, options?: Options) => ESTree.Program;
+
+    const parse: IParse;
+
+    function parseExpressionAt(input: string, pos?: number, options?: Options): ESTree.Expression;
+
+    interface ITokenizer {
+      getToken(): Token;
+      [Symbol.iterator](): Iterator<Token>;
+    }
+
+    function tokenizer(input: string, options: Options): ITokenizer;
+
+    let parse_dammit: IParse | undefined;
+    let LooseParser: ILooseParserClass | undefined;
+    let pluginsLoose: PluginsObject | undefined;
+
+    interface ILooseParserClass {
+        new (input: string, options?: Options): ILooseParser;
+    }
+
+    interface ILooseParser {}
+
+    function addLooseExports(parse: IParse, parser: ILooseParserClass, plugins: PluginsObject): void;
+}

data/vendor/node_modules/@types/acorn/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "@types/acorn",
+    "version": "4.0.3",
+    "description": "TypeScript definitions for Acorn",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "RReverser",
+            "url": "https://github.com/RReverser",
+            "githubUsername": "RReverser"
+        },
+        {
+            "name": "e-cloud",
+            "url": "https://github.com/e-cloud",
+            "githubUsername": "e-cloud"
+        }
+    ],
+    "main": "",
+    "repository": {
+        "type": "git",
+        "url": "https://www.github.com/DefinitelyTyped/DefinitelyTyped.git"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/estree": "*"
+    },
+    "typesPublisherContentHash": "0e6b6ce448ffe2e23033a5fa7511f4474885c5abbbd8d862c29b28fc9ad53a25",
+    "typeScriptVersion": "2.0"
+}

data/vendor/node_modules/@types/estree/index.d.ts

@@ -0,0 +1,546 @@
+// Type definitions for ESTree AST specification
+// Project: https://github.com/estree/estree
+// Definitions by: RReverser <https://github.com/RReverser>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inhereted fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+
+interface BaseNodeWithoutComments {
+  // Every leaf interface that extends BaseNode must specify a type property.
+  // The type property should be a string literal. For example, Identifier
+  // has: `type: "Identifier"`
+  type: string;
+  loc?: SourceLocation | null;
+  range?: [number, number];
+}
+
+interface BaseNode extends BaseNodeWithoutComments {
+  leadingComments?: Array<Comment>;
+  trailingComments?: Array<Comment>;
+}
+
+export type Node =
+    Identifier | Literal | Program | Function | SwitchCase | CatchClause |
+    VariableDeclarator | Statement | Expression | Property |
+    AssignmentProperty | Super | TemplateElement | SpreadElement | Pattern |
+    ClassBody | Class | MethodDefinition | ModuleDeclaration | ModuleSpecifier;
+
+export interface Comment extends BaseNodeWithoutComments {
+  type: "Line" | "Block";
+  value: string;
+}
+
+interface SourceLocation {
+  source?: string | null;
+  start: Position;
+  end: Position;
+}
+
+export interface Position {
+  /** >= 1 */
+  line: number;
+  /** >= 0 */
+  column: number;
+}
+
+export interface Program extends BaseNode {
+  type: "Program";
+  sourceType: "script" | "module";
+  body: Array<Statement | ModuleDeclaration>;
+  comments?: Array<Comment>;
+}
+
+interface BaseFunction extends BaseNode {
+  params: Array<Pattern>;
+  generator?: boolean;
+  async?: boolean;
+  // The body is either BlockStatement or Expression because arrow functions
+  // can have a body that's either. FunctionDeclarations and
+  // FunctionExpressions have only BlockStatement bodies.
+  body: BlockStatement | Expression;
+}
+
+export type Function =
+    FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+
+export type Statement =
+    ExpressionStatement | BlockStatement | EmptyStatement |
+    DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement |
+    BreakStatement | ContinueStatement | IfStatement | SwitchStatement |
+    ThrowStatement | TryStatement | WhileStatement | DoWhileStatement |
+    ForStatement | ForInStatement | ForOfStatement | Declaration;
+
+interface BaseStatement extends BaseNode { }
+
+export interface EmptyStatement extends BaseStatement {
+  type: "EmptyStatement";
+}
+
+export interface BlockStatement extends BaseStatement {
+  type: "BlockStatement";
+  body: Array<Statement>;
+  innerComments?: Array<Comment>;
+}
+
+export interface ExpressionStatement extends BaseStatement {
+  type: "ExpressionStatement";
+  expression: Expression;
+}
+
+export interface IfStatement extends BaseStatement {
+  type: "IfStatement";
+  test: Expression;
+  consequent: Statement;
+  alternate?: Statement | null;
+}
+
+export interface LabeledStatement extends BaseStatement {
+  type: "LabeledStatement";
+  label: Identifier;
+  body: Statement;
+}
+
+export interface BreakStatement extends BaseStatement {
+  type: "BreakStatement";
+  label?: Identifier | null;
+}
+
+export interface ContinueStatement extends BaseStatement {
+  type: "ContinueStatement";
+  label?: Identifier | null;
+}
+
+export interface WithStatement extends BaseStatement {
+  type: "WithStatement";
+  object: Expression;
+  body: Statement;
+}
+
+export interface SwitchStatement extends BaseStatement {
+  type: "SwitchStatement";
+  discriminant: Expression;
+  cases: Array<SwitchCase>;
+}
+
+export interface ReturnStatement extends BaseStatement {
+  type: "ReturnStatement";
+  argument?: Expression | null;
+}
+
+export interface ThrowStatement extends BaseStatement {
+  type: "ThrowStatement";
+  argument: Expression;
+}
+
+export interface TryStatement extends BaseStatement {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler?: CatchClause | null;
+  finalizer?: BlockStatement | null;
+}
+
+export interface WhileStatement extends BaseStatement {
+  type: "WhileStatement";
+  test: Expression;
+  body: Statement;
+}
+
+export interface DoWhileStatement extends BaseStatement {
+  type: "DoWhileStatement";
+  body: Statement;
+  test: Expression;
+}
+
+export interface ForStatement extends BaseStatement {
+  type: "ForStatement";
+  init?: VariableDeclaration | Expression | null;
+  test?: Expression | null;
+  update?: Expression | null;
+  body: Statement;
+}
+
+interface BaseForXStatement extends BaseStatement {
+  left: VariableDeclaration | Pattern;
+  right: Expression;
+  body: Statement;
+}
+
+export interface ForInStatement extends BaseForXStatement {
+  type: "ForInStatement";
+}
+
+export interface DebuggerStatement extends BaseStatement {
+  type: "DebuggerStatement";
+}
+
+export type Declaration =
+      FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+
+interface BaseDeclaration extends BaseStatement { }
+
+export interface FunctionDeclaration extends BaseFunction, BaseDeclaration {
+  type: "FunctionDeclaration";
+  id: Identifier;
+  body: BlockStatement;
+}
+
+export interface VariableDeclaration extends BaseDeclaration {
+  type: "VariableDeclaration";
+  declarations: Array<VariableDeclarator>;
+  kind: "var" | "let" | "const";
+}
+
+export interface VariableDeclarator extends BaseNode {
+  type: "VariableDeclarator";
+  id: Pattern;
+  init?: Expression | null;
+}
+
+type Expression =
+    ThisExpression | ArrayExpression | ObjectExpression | FunctionExpression |
+    ArrowFunctionExpression | YieldExpression | Literal | UnaryExpression |
+    UpdateExpression | BinaryExpression | AssignmentExpression |
+    LogicalExpression | MemberExpression | ConditionalExpression |
+    CallExpression | NewExpression | SequenceExpression | TemplateLiteral |
+    TaggedTemplateExpression | ClassExpression | MetaProperty | Identifier |
+    AwaitExpression;
+
+export interface BaseExpression extends BaseNode { }
+
+export interface ThisExpression extends BaseExpression {
+  type: "ThisExpression";
+}
+
+export interface ArrayExpression extends BaseExpression {
+  type: "ArrayExpression";
+  elements: Array<Expression | SpreadElement>;
+}
+
+export interface ObjectExpression extends BaseExpression {
+  type: "ObjectExpression";
+  properties: Array<Property>;
+}
+
+export interface Property extends BaseNode {
+  type: "Property";
+  key: Expression;
+  value: Expression | Pattern; // Could be an AssignmentProperty
+  kind: "init" | "get" | "set";
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+}
+
+export interface FunctionExpression extends BaseFunction, BaseExpression {
+  id?: Identifier | null;
+  type: "FunctionExpression";
+  body: BlockStatement;
+}
+
+export interface SequenceExpression extends BaseExpression {
+  type: "SequenceExpression";
+  expressions: Array<Expression>;
+}
+
+export interface UnaryExpression extends BaseExpression {
+  type: "UnaryExpression";
+  operator: UnaryOperator;
+  prefix: true;
+  argument: Expression;
+}
+
+export interface BinaryExpression extends BaseExpression {
+  type: "BinaryExpression";
+  operator: BinaryOperator;
+  left: Expression;
+  right: Expression;
+}
+
+export interface AssignmentExpression extends BaseExpression {
+  type: "AssignmentExpression";
+  operator: AssignmentOperator;
+  left: Pattern | MemberExpression;
+  right: Expression;
+}
+
+export interface UpdateExpression extends BaseExpression {
+  type: "UpdateExpression";
+  operator: UpdateOperator;
+  argument: Expression;
+  prefix: boolean;
+}
+
+export interface LogicalExpression extends BaseExpression {
+  type: "LogicalExpression";
+  operator: LogicalOperator;
+  left: Expression;
+  right: Expression;
+}
+
+export interface ConditionalExpression extends BaseExpression {
+  type: "ConditionalExpression";
+  test: Expression;
+  alternate: Expression;
+  consequent: Expression;
+}
+
+interface BaseCallExpression extends BaseExpression {
+  callee: Expression | Super;
+  arguments: Array<Expression | SpreadElement>;
+}
+export type CallExpression = SimpleCallExpression | NewExpression;
+
+export interface SimpleCallExpression extends BaseCallExpression {
+  type: "CallExpression";
+}
+
+export interface NewExpression extends BaseCallExpression {
+  type: "NewExpression";
+}
+
+export interface MemberExpression extends BaseExpression, BasePattern {
+  type: "MemberExpression";
+  object: Expression | Super;
+  property: Expression;
+  computed: boolean;
+}
+
+export type Pattern =
+    Identifier | ObjectPattern | ArrayPattern | RestElement |
+    AssignmentPattern | MemberExpression;
+
+interface BasePattern extends BaseNode { }
+
+export interface SwitchCase extends BaseNode {
+  type: "SwitchCase";
+  test?: Expression | null;
+  consequent: Array<Statement>;
+}
+
+export interface CatchClause extends BaseNode {
+  type: "CatchClause";
+  param: Pattern;
+  body: BlockStatement;
+}
+
+export interface Identifier extends BaseNode, BaseExpression, BasePattern {
+  type: "Identifier";
+  name: string;
+}
+
+export type Literal = SimpleLiteral | RegExpLiteral;
+
+export interface SimpleLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value: string | boolean | number | null;
+  raw?: string;
+}
+
+export interface RegExpLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: RegExp | null;
+  regex: {
+    pattern: string;
+    flags: string;
+  };
+  raw?: string;
+}
+
+export type UnaryOperator =
+    "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+
+export type BinaryOperator =
+    "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" |
+    ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" |
+    "instanceof";
+
+export type LogicalOperator = "||" | "&&";
+
+export type AssignmentOperator =
+    "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" |
+    "|=" | "^=" | "&=";
+
+export type UpdateOperator = "++" | "--";
+
+export interface ForOfStatement extends BaseForXStatement {
+  type: "ForOfStatement";
+}
+
+export interface Super extends BaseNode {
+  type: "Super";
+}
+
+export interface SpreadElement extends BaseNode {
+  type: "SpreadElement";
+  argument: Expression;
+}
+
+export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  body: BlockStatement | Expression;
+}
+
+export interface YieldExpression extends BaseExpression {
+  type: "YieldExpression";
+  argument?: Expression | null;
+  delegate: boolean;
+}
+
+export interface TemplateLiteral extends BaseExpression {
+  type: "TemplateLiteral";
+  quasis: Array<TemplateElement>;
+  expressions: Array<Expression>;
+}
+
+export interface TaggedTemplateExpression extends BaseExpression {
+  type: "TaggedTemplateExpression";
+  tag: Expression;
+  quasi: TemplateLiteral;
+}
+
+export interface TemplateElement extends BaseNode {
+  type: "TemplateElement";
+  tail: boolean;
+  value: {
+    cooked: string;
+    raw: string;
+  };
+}
+
+export interface AssignmentProperty extends Property {
+  value: Pattern;
+  kind: "init";
+  method: boolean; // false
+}
+
+export interface ObjectPattern extends BasePattern {
+  type: "ObjectPattern";
+  properties: Array<AssignmentProperty>;
+}
+
+export interface ArrayPattern extends BasePattern {
+  type: "ArrayPattern";
+  elements: Array<Pattern>;
+}
+
+export interface RestElement extends BasePattern {
+  type: "RestElement";
+  argument: Pattern;
+}
+
+export interface AssignmentPattern extends BasePattern {
+  type: "AssignmentPattern";
+  left: Pattern;
+  right: Expression;
+}
+
+export type Class = ClassDeclaration | ClassExpression;
+interface BaseClass extends BaseNode {
+  superClass?: Expression | null;
+  body: ClassBody;
+}
+
+export interface ClassBody extends BaseNode {
+  type: "ClassBody";
+  body: Array<MethodDefinition>;
+}
+
+export interface MethodDefinition extends BaseNode {
+  type: "MethodDefinition";
+  key: Expression;
+  value: FunctionExpression;
+  kind: "constructor" | "method" | "get" | "set";
+  computed: boolean;
+  static: boolean;
+}
+
+export interface ClassDeclaration extends BaseClass, BaseDeclaration {
+  type: "ClassDeclaration";
+  id: Identifier;
+}
+
+export interface ClassExpression extends BaseClass, BaseExpression {
+  type: "ClassExpression";
+  id?: Identifier | null;
+}
+
+export interface MetaProperty extends BaseExpression {
+  type: "MetaProperty";
+  meta: Identifier;
+  property: Identifier;
+}
+
+export type ModuleDeclaration =
+    ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration |
+    ExportAllDeclaration;
+interface BaseModuleDeclaration extends BaseNode { }
+
+export type ModuleSpecifier =
+    ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier |
+    ExportSpecifier;
+interface BaseModuleSpecifier extends BaseNode {
+  local: Identifier;
+}
+
+export interface ImportDeclaration extends BaseModuleDeclaration {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+  source: Literal;
+}
+
+export interface ImportSpecifier extends BaseModuleSpecifier {
+  type: "ImportSpecifier";
+  imported: Identifier;
+}
+
+export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+  type: "ImportDefaultSpecifier";
+}
+
+export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+  type: "ImportNamespaceSpecifier";
+}
+
+export interface ExportNamedDeclaration extends BaseModuleDeclaration {
+  type: "ExportNamedDeclaration";
+  declaration?: Declaration | null;
+  specifiers: Array<ExportSpecifier>;
+  source?: Literal | null;
+}
+
+export interface ExportSpecifier extends BaseModuleSpecifier {
+  type: "ExportSpecifier";
+  exported: Identifier;
+}
+
+export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+  type: "ExportDefaultDeclaration";
+  declaration: Declaration | Expression;
+}
+
+export interface ExportAllDeclaration extends BaseModuleDeclaration {
+  type: "ExportAllDeclaration";
+  source: Literal;
+}
+
+export interface AwaitExpression extends BaseExpression {
+  type: "AwaitExpression";
+  argument: Expression;
+}