@neo-one/smart-contract-compiler/dist/index.es.js

import Ast, { TypeGuards, SyntaxKind, TypeFlags, DiagnosticCategory, Symbol as Symbol$1, ts, Scope } from 'ts-simple-ast';
import stringify from 'safe-stable-stringify';
import _ from 'lodash';
import { BYTECODE_TO_BYTECODE_BUFFER, OPCODE_TO_BYTECODE, BinaryWriter, UnknownOpError, utils, ScriptBuilder } from '@neo-one/client-core';
import BN from 'bn.js';
import path__default, { sep, join, dirname } from 'path';
import 'app-root-dir';
import { pathExists, readFileSync, existsSync } from 'fs-extra';
import Blockchain from '@neo-one/node-blockchain';
import levelup from 'levelup';
import levelUpStorage from '@neo-one/node-storage-levelup';
import memdown from 'memdown';
import { test } from '@neo-one/node-neo-settings';
import vm from '@neo-one/node-vm';

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function _objectSpread(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};
    var ownKeys = Object.keys(source);

    if (typeof Object.getOwnPropertySymbols === 'function') {
      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
      }));
    }

    ownKeys.forEach(function (key) {
      _defineProperty(target, key, source[key]);
    });
  }

  return target;
}

class JumpTable {
  constructor() {
    Object.defineProperty(this, "jumpNumber", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 0
    });
    Object.defineProperty(this, "table", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: []
    });
  }

  add(sb, node, body) {
    const jumpNumber = this.jumpNumber;
    this.jumpNumber += 1;
    const {
      bytecode
    } = sb.capture(() => {
      body();
    });
    this.table.push({
      jumpNumber,
      node,
      bytecode
    });
    return jumpNumber;
  }

  emitTable(sb, outerNode) {
    // TODO: Binary search over table - O(logn) ops vs O(n) currently
    this.table.forEach(({
      node,
      jumpNumber,
      bytecode
    }) => {
      sb.emitHelper(node, {}, sb.helpers.if({
        condition: () => {
          sb.emitOp(node, 'DUP');
          sb.emitPushInt(node, jumpNumber);
          sb.emitOp(node, 'NUMEQUAL');
        },
        whenTrue: () => {
          sb.emitOp(node, 'DROP');
          sb.emitBytecode(bytecode);
        }
      }));
    });
    sb.emitOp(outerNode, 'THROW');
  }

}

class ProgramCounter {}

class DeferredProgramCounter extends ProgramCounter {
  constructor(offset) {
    super();
    this.offset = offset;
    Object.defineProperty(this, "pc", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
  }

  plus(offset) {
    return new DeferredProgramCounter((this.offset || 0) + offset);
  }

  equals(other) {
    return this === other;
  }

  setPC(pc) {
    this.pc = pc;
  }

  getPC() {
    if (this.pc == null) {
      throw new Error('Unknown PC');
    }

    return this.pc.getPC() + (this.offset || 0);
  }

}

class Jump {
  constructor(op, pc) {
    this.op = op;
    this.pc = pc;
  }

}

class Call extends Jump {
  constructor(pc) {
    super('CALL', pc);
  }

  plus(pc) {
    return new Call(this.pc.plus(pc));
  }

}

class Jmp extends Jump {
  constructor(op, pc) {
    super(op, pc);
  }

  plus(pc) {
    return new Jmp(this.op, this.pc.plus(pc));
  }

}

class KnownProgramCounter extends ProgramCounter {
  constructor(pc) {
    super();
    this.pc = pc;
  }

  plus(offset) {
    return new KnownProgramCounter(this.pc + offset);
  }

  equals(other) {
    return other instanceof KnownProgramCounter && this.pc === other.pc;
  }

  getPC() {
    return this.pc;
  }

}

class LastProgramCounter extends ProgramCounter {
  constructor(startPC, offset) {
    super();
    this.startPC = startPC;
    this.offset = offset;
    Object.defineProperty(this, "pc", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "children", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: []
    });
  }

  plus(offset) {
    const pc = new LastProgramCounter(this.startPC, (this.offset || 0) + offset);
    this.children.push(pc);

    if (this.pc != null) {
      pc.setPC(this.pc);
    }

    return pc;
  }

  equals(other) {
    return other instanceof LastProgramCounter && this.startPC === other.startPC && this.offset === other.offset;
  }

  setPC(pc) {
    this.pc = pc;
    this.children.forEach(child => {
      child.setPC(pc);
    });
  }

  getPC() {
    if (this.pc == null) {
      throw new Error('Unknown PC');
    }

    return this.pc + (this.offset || 0);
  }

}

class ProgramCounterHelper {
  constructor(pc) {
    Object.defineProperty(this, "pc", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "first", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "last", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.pc = pc;
    this.first = new KnownProgramCounter(this.pc());
    this.last = new LastProgramCounter(this.pc());
  }

  getFirst() {
    return this.first;
  }

  getCurrent() {
    return new KnownProgramCounter(this.pc());
  }

  getLast() {
    return this.last;
  }

  setLast() {
    this.last.setPC(this.pc());
  }

}

class NodeCompiler {
  constructor() {
    Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
  }

}

class Helper {
  emitGlobal(sb, node, options) {// do nothing
  }

}

// Input: [array]
// Output: [array]
class ArrFilterHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "map", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "withIndex", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.map = options.map;
    this.withIndex = options.withIndex || false;
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [size, ...array]


    sb.emitOp(node, 'UNPACK'); // [0, size, ...array]

    sb.emitPushInt(node, 0); // [arr, size, ...array]

    sb.emitOp(node, 'NEWARRAY'); // [size, arr, ...array]

    sb.emitOp(node, 'SWAP'); // [idx, size, arr, ...array]

    sb.emitPushInt(node, 0);
    sb.emitHelper(node, options, sb.helpers.forLoop({
      condition: () => {
        // [size, idx, arr, ...array]
        sb.emitOp(node, 'SWAP'); // [size, idx, size, arr, ...array]

        sb.emitOp(node, 'TUCK'); // [idx, size, idx, size, arr, ...array]

        sb.emitOp(node, 'OVER'); // size > idx
        // [size > idx, idx, size, arr, ...array]

        sb.emitOp(node, 'GT');
      },
      each: () => {
        // [arr, idx, size, ...array]
        sb.emitOp(node, 'ROT'); // [idx, arr, idx, size, ...array]

        sb.emitOp(node, 'OVER');

        if (this.withIndex) {
          // [4, idx, arr, idx, size, ...array]
          sb.emitPushInt(node, 4); // [value, idx, arr, idx, size, ...array]

          sb.emitOp(node, 'ROLL'); // [value, idx, value, arr, idx, size, ...array]

          sb.emitOp(node, 'TUCK');
        } else {
          // [3, arr, idx, size, ...array]
          sb.emitPushInt(node, 3); // [value, arr, idx, size, ...array]

          sb.emitOp(node, 'ROLL'); // [value, value, arr, idx, size, ...array]

          sb.emitOp(node, 'DUP');
        }

        sb.emitHelper(node, options, sb.helpers.if({
          condition: () => {
            // [keepVal, value, arr, idx, size, ...array]
            this.map(); // TODO: This should be toBoolean
            // [keep, value, arr, idx, size, ...array]

            sb.emitHelper(node, options, sb.helpers.getBoolean);
          },
          whenTrue: () => {
            // [arr, value, arr, idx, size, ...array]
            sb.emitOp(node, 'OVER'); // [value, arr, arr, idx, size, ...array]

            sb.emitOp(node, 'SWAP'); // [arr, idx, size, ...array]

            sb.emitOp(node, 'APPEND');
          },
          whenFalse: () => {
            // [arr, idx, size, ...array]
            sb.emitOp(node, 'DROP');
          }
        })); // [size, arr, idx, ...array]

        sb.emitOp(node, 'ROT'); // [idx, size, arr, ...array]

        sb.emitOp(node, 'ROT');
      },
      incrementor: () => {
        // [idx, size, arr, ...array]
        sb.emitOp(node, 'INC');
      }
    })); // [size, arr]

    sb.emitOp(node, 'DROP'); // [arr]

    sb.emitOp(node, 'DROP');
  }

}

// Input: [array]
// Output: []
class ArrForEachHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "each", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "withIndex", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.each = options.each;
    this.withIndex = options.withIndex || false;
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [size, ...array]


    sb.emitOp(node, 'UNPACK'); // [idx, size, ...array]

    sb.emitPushInt(node, 0);
    sb.emitHelper(node, options, sb.helpers.forLoop({
      condition: () => {
        // [size, idx, ...array]
        sb.emitOp(node, 'SWAP'); // [size, idx, size, ...array]

        sb.emitOp(node, 'TUCK'); // [idx, size, idx, size, ...array]

        sb.emitOp(node, 'OVER'); // size > idx
        // [size > idx, idx, size, ...array]

        sb.emitOp(node, 'GT');
      },
      each: () => {
        // [value, idx, size, ...array]
        sb.emitOp(node, 'ROT');

        if (this.withIndex) {
          // [idx, value, idx, size, ...array]
          sb.emitOp(node, 'OVER'); // [value, idx, idx, size, ...array]

          sb.emitOp(node, 'SWAP');
        } // [idx, size, ...array]


        this.each();
      },
      incrementor: () => {
        // [idx, size, ...array]
        sb.emitOp(node, 'INC');
      }
    })); // [size]

    sb.emitOp(node, 'DROP'); // []

    sb.emitOp(node, 'DROP');
  }

}

// Input: [array]
// Output: [array]
class ArrMapHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "map", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "withIndex", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.map = options.map;
    this.withIndex = options.withIndex || false;
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [size, ...array]


    sb.emitOp(node, 'UNPACK'); // [idx, size, ...array]

    sb.emitPushInt(node, 0);
    sb.emitHelper(node, options, sb.helpers.forLoop({
      condition: () => {
        // [size, idx, ...array]
        sb.emitOp(node, 'SWAP'); // [size, idx, size, ...array]

        sb.emitOp(node, 'TUCK'); // [idx, size, idx, size, ...array]

        sb.emitOp(node, 'OVER'); // size > idx
        // [size > idx, idx, size, ...array]

        sb.emitOp(node, 'GT');
      },
      each: () => {
        // [idx, idx, size, ...array]
        sb.emitOp(node, 'DUP'); // [3, idx, idx, size, ...array]

        sb.emitPushInt(node, 3); // [idx + 3, idx, size, ...array]

        sb.emitOp(node, 'ADD');

        if (this.withIndex) {
          // [idx, idx + 3, idx, size, ...array]
          sb.emitOp(node, 'OVER'); // [idx, idx, idx + 3, idx, size, ...array]

          sb.emitOp(node, 'DUP'); // [4, idx, idx, idx + 3, idx, size, ...array]

          sb.emitPushInt(node, 4); // [idx + 4, idx, idx + 3, idx, size, ...array]

          sb.emitOp(node, 'ADD'); // [value, idx, idx + 3, idx, size, ...array]

          sb.emitOp(node, 'ROLL');
        } else {
          // [idx + 3, idx + 3, idx, size, ...array]
          sb.emitOp(node, 'DUP'); // [value, idx + 3, idx, size, ...array]

          sb.emitOp(node, 'ROLL');
        } // [value, idx + 3, idx, size, ...array]


        this.map(); // [idx + 3, value, idx, size, ...array]

        sb.emitOp(node, 'SWAP'); // [value, idx, size, ...array]

        sb.emitOp(node, 'XTUCK'); // [idx, size, ...array]

        sb.emitOp(node, 'DROP');
      },
      incrementor: () => {
        // [idx, size, ...array]
        sb.emitOp(node, 'INC');
      }
    })); // [size, ...array]

    sb.emitOp(node, 'DROP'); // [array]

    sb.emitOp(node, 'PACK');
  }

}

// Input: [array]
// Output: [array]
class CloneArrayHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [array]


    sb.emitOp(node, 'UNPACK'); // [...array]

    sb.emitOp(node, 'PACK');
  }

}

// Input: [length, arr]
// Output: []
class ExtendArrayHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [arr, length, arr]

    sb.emitOp(node, 'OVER'); // [currentLength, length, arr]

    sb.emitOp(node, 'ARRAYSIZE');
    sb.emitHelper(node, options, sb.helpers.forLoop({
      condition: () => {
        // [currentLength, length, currentLength, arr]
        sb.emitOp(node, 'TUCK'); // [length, currentLength, length, currentLength, arr]

        sb.emitOp(node, 'OVER'); // [expectedLengthGTCurrentLength, length, currentLength, arr]

        sb.emitOp(node, 'LT');
      },
      each: () => {
        // [arr, length, currentLength]
        sb.emitOp(node, 'ROT'); // [arr, arr, length, currentLength]

        sb.emitOp(node, 'DUP'); // [undefinedVal, arr, arr, length, currentLength]

        sb.emitHelper(node, options, sb.helpers.createUndefined); // [arr, length, currentLength]

        sb.emitOp(node, 'APPEND');
      },
      incrementor: () => {
        // [currentLength, arr, length]
        sb.emitOp(node, 'ROT'); // [currentLength, arr, length]

        sb.emitOp(node, 'INC'); // [length, currentLength, arr]

        sb.emitOp(node, 'ROT'); // [currentLength, length, arr]

        sb.emitOp(node, 'SWAP');
      }
    })); // [length, arr]

    sb.emitOp(node, 'DROP'); // [arr]

    sb.emitOp(node, 'DROP'); // []

    sb.emitOp(node, 'DROP');
  }

}

// Input: [val]
// Output: []
class ForTypeHelper extends Helper {
  constructor({
    types,
    defaultCase
  }) {
    super();
    Object.defineProperty(this, "types", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "defaultCase", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.types = types;
    this.defaultCase = defaultCase;
  }

  emit(sb, node, optionsIn) {
    const noCastOptions = sb.noCastOptions(optionsIn);
    const options = sb.pushValueOptions(sb.noCastOptions(optionsIn));
    let type = optionsIn.cast;

    if (type == null) {
      type = sb.getType(node);
    }

    const types = this.types.filter(testType => testType.isType(type));

    const defaultCase = this.defaultCase || (innerOptions => {
      sb.emitOp(node, 'DROP');
      sb.emitHelper(node, innerOptions, sb.helpers.throwTypeError);
    });

    if (types.length === 0) {
      defaultCase(noCastOptions);
    } else if (types.length === 1) {
      types[0].process(noCastOptions);
    } else {
      sb.emitHelper(node, options, sb.helpers.case(types.map(forType => ({
        condition: () => {
          sb.emitOp(node, 'DUP');
          forType.isRuntimeType(options);
        },
        whenTrue: () => {
          forType.process(noCastOptions);
        }
      })), () => {
        defaultCase(noCastOptions);
      }));
    }
  }

}

let SerializableType;

(function (SerializableType) {
  SerializableType[SerializableType["Array"] = 7] = "Array";
  SerializableType[SerializableType["Buffer"] = 8] = "Buffer";
})(SerializableType || (SerializableType = {}));

const invokeGlobal = (sb, node, options, name) => {
  // [1, val]
  sb.emitPushInt(node, 1); // [argsarr]

  sb.emitOp(node, 'PACK'); // [globalObjectVal, argsarr]

  sb.scope.getGlobal(sb, node, options); // [name, globalObjectVal, argsarr]

  sb.emitPushString(node, name); // [objectVal, argsarr]

  sb.emitHelper(node, options, sb.helpers.getInternalObjectProperty); // [val]

  sb.emitHelper(node, options, sb.helpers.invokeCall());
};

const SERIALIZE_NAME = 'genericSerialize';
const invokeSerialize = (sb, node, options) => invokeGlobal(sb, node, options, SERIALIZE_NAME);
const DESERIALIZE_NAME = 'genericDeserialize';
const invokeDeserialize = (sb, node, options) => invokeGlobal(sb, node, options, DESERIALIZE_NAME);
const serializeType = (sb, node, options, type) => {
  // [type, arr]
  sb.emitPushInt(node, type); // [2, type, arr]

  sb.emitPushInt(node, 2); // [arr]

  sb.emitOp(node, 'PACK');
};
const deserializeType = (sb, node, options) => {
  // [1, arr]
  sb.emitPushInt(node, 1); // [value]

  sb.emitOp(node, 'PICKITEM');
};

const isSerializedType = (sb, node, options, type) => {
  // [0, val]
  sb.emitPushInt(node, 0); // [type]

  sb.emitOp(node, 'PICKITEM'); // [type, type]

  sb.emitPushInt(node, type); // [isSerializedType]

  sb.emitOp(node, 'NUMEQUAL');
};

const getTypes = (sb, node, options) => [{
  isRuntimeType: () => {
    // [isBoolean]
    sb.emitHelper(node, options, sb.helpers.isBoolean);
  },
  serialize: () => {// do nothing
  },
  isSerializedType: () => {
    // [isBoolean]
    sb.emitHelper(node, options, sb.helpers.isBoolean);
  },
  deserialize: () => {// do nothing
  }
}, {
  isRuntimeType: () => {
    // [isString]
    sb.emitHelper(node, options, sb.helpers.isString);
  },
  serialize: () => {// do nothing
  },
  isSerializedType: () => {
    // [isString]
    sb.emitHelper(node, options, sb.helpers.isString);
  },
  deserialize: () => {// do nothing
  }
}, {
  isRuntimeType: () => {
    // [isNumber]
    sb.emitHelper(node, options, sb.helpers.isNumber);
  },
  serialize: () => {// do nothing
  },
  isSerializedType: () => {
    // [isNumber]
    sb.emitHelper(node, options, sb.helpers.isNumber);
  },
  deserialize: () => {// do nothing
  }
}, {
  isRuntimeType: () => {
    // [Array, val]
    sb.emitHelper(node, options, sb.helpers.getGlobalProperty({
      property: 'Buffer'
    })); // [val instanceof Array]

    sb.emitHelper(node, options, sb.helpers.instanceof);
  },
  serialize: () => {
    // [bytearray]
    sb.emitHelper(node, options, sb.helpers.unwrapBuffer); // [arr]

    serializeType(sb, node, options, SerializableType.Buffer);
  },
  isSerializedType: () => {
    isSerializedType(sb, node, options, SerializableType.Buffer);
  },
  deserialize: () => {
    deserializeType(sb, node, options); // [val]

    sb.emitHelper(node, options, sb.helpers.wrapBuffer);
  }
}, {
  isRuntimeType: () => {
    // [Array, val]
    sb.emitHelper(node, options, sb.helpers.getGlobalProperty({
      property: 'Array'
    })); // [val instanceof Array]

    sb.emitHelper(node, options, sb.helpers.instanceof);
  },
  serialize: () => {
    // [arr]
    sb.emitHelper(node, options, sb.helpers.unwrapArray); // [arr]

    sb.emitHelper(node, options, sb.helpers.arrMap({
      map: () => {
        invokeSerialize(sb, node, options);
      }
    })); // [value]

    serializeType(sb, node, options, SerializableType.Array);
  },
  isSerializedType: () => {
    isSerializedType(sb, node, options, SerializableType.Array);
  },
  deserialize: () => {
    // [arr]
    deserializeType(sb, node, options); // [arr]

    sb.emitHelper(node, options, sb.helpers.arrMap({
      map: () => {
        invokeDeserialize(sb, node, options);
      }
    })); // [val]

    sb.emitHelper(node, options, sb.helpers.wrapArray);
  }
}];

// Input: []
// Output: [argsArray]
class ArgumentsHelper extends Helper {
  emit(sb, node, options) {
    // Push the arguments
    const args = [...node.getArguments()].reverse();

    for (const arg of args) {
      sb.visit(arg, sb.pushValueOptions(options));
    } // [length, ...args]


    sb.emitPushInt(node, args.length); // [argsarr]

    sb.emitOp(node, 'PACK');
  }

}

let InternalFunctionProperties;

(function (InternalFunctionProperties) {
  InternalFunctionProperties["CALL"] = "call";
  InternalFunctionProperties["CONSTRUCT"] = "construct";
})(InternalFunctionProperties || (InternalFunctionProperties = {}));

// Output: [objectVal]

// Input: [objectVal, this]
// Output: [objectVal]
class BindFunctionObjectThisHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "property", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "both", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "overwrite", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });

    if (options.type === 'both') {
      this.property = InternalFunctionProperties.CALL;
      this.both = true;
    } else {
      this.property = options.property;
      this.both = false;
    }

    this.overwrite = options.overwrite;
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [objectVal, this]


    sb.emitHelper(node, options, sb.helpers.cloneFunctionObject(this.both ? {
      type: 'both'
    } : {
      type: 'single',
      property: this.property
    })); // [this, objectVal]

    sb.emitOp(node, 'SWAP');

    if (this.both) {
      this.bindThis(sb, node, options, InternalFunctionProperties.CALL);
      this.bindThis(sb, node, options, InternalFunctionProperties.CONSTRUCT);
    } else {
      this.bindThis(sb, node, options, this.property);
    }

    sb.emitOp(node, 'DROP');
  }

  bindThis(sb, node, options, property) {
    // [this, objectVal, this]
    sb.emitOp(node, 'TUCK'); // [objectVal, this, objectVal, this]

    sb.emitOp(node, 'OVER'); // [property, objectVal, this, objectVal, this]

    sb.emitPushString(node, property); // [func, this, objectVal, this]

    sb.emitHelper(node, options, sb.helpers.getInternalObjectProperty); // [func, objectVal, this]

    sb.emitHelper(node, options, sb.helpers.bindFunctionThis({
      overwrite: this.overwrite
    })); // [objectVal, this]

    sb.emitOp(node, 'DROP'); // [this, objectVal]

    sb.emitOp(node, 'SWAP');
  }

}

// Input: [func, this]
// Output: [func]
class BindFunctionThisHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "overwrite", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.overwrite = options.overwrite;
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      sb.emitOp(node, 'DROP');
      return;
    }

    let whenTrue;

    if (this.overwrite) {
      whenTrue = () => {
        // [this, func, func]
        sb.emitOp(node, 'SWAP'); // [2, this, func, func]

        sb.emitPushInt(node, 2); // [func]

        sb.emitOp(node, 'SETITEM');
      };
    } else {
      whenTrue = () => {
        // [this, func]
        sb.emitOp(node, 'DROP'); // [func]

        sb.emitOp(node, 'DROP');
      };
    } // [func, this]


    sb.emitHelper(node, options, sb.helpers.cloneFunction); // [func, this, func]

    sb.emitOp(node, 'TUCK'); // [func, func, this, func]

    sb.emitOp(node, 'DUP'); // [func]

    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [size, func, this, func]
        sb.emitOp(node, 'ARRAYSIZE'); // [3, size, func, this, func]

        sb.emitPushInt(node, 3); // [hasThis, func, this, func]

        sb.emitOp(node, 'NUMEQUAL');
      },
      whenTrue,
      whenFalse: () => {
        // [this, func, func]
        sb.emitOp(node, 'SWAP'); // [func]

        sb.emitOp(node, 'APPEND');
      }
    }));
  }

}

class CallHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // Push the scopes and this to the alt stack
    // [func, func]

    sb.emitOp(node, 'DUP'); // [1, func, func]

    sb.emitPushInt(node, 1); // [[scopes, this], func]

    sb.emitOp(node, 'PICKITEM'); // [[scopes, this], func]

    sb.emitHelper(node, options, sb.helpers.cloneArray); // [[scopes, this], [scopes, this], func]

    sb.emitOp(node, 'DUP'); // [0, [scopes, this], [scopes, this], func]

    sb.emitPushInt(node, 0); // [[scopes, this], 0, [scopes, this], [scopes, this], func]

    sb.emitOp(node, 'OVER'); // [0, [scopes, this], 0, [scopes, this], [scopes, this], func]

    sb.emitPushInt(node, 0); // [scopes, 0, [scopes, this], [scopes, this], func]

    sb.emitOp(node, 'PICKITEM'); // [scopes, 0, [scopes, this], [scopes, this], func]

    sb.emitHelper(node, options, sb.helpers.cloneArray); // [[scopes, this], func]

    sb.emitOp(node, 'SETITEM'); // [func, [scopes, this], func]

    sb.emitOp(node, 'OVER'); // [[scopes, this], func]

    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [size, [scopes, this], func]
        sb.emitOp(node, 'ARRAYSIZE'); // [3, size, [scopes, this], func]

        sb.emitPushInt(node, 3); // [size === 3, [scopes, this], func]

        sb.emitOp(node, 'NUMEQUAL');
      },
      whenTrue: () => {
        // [func, [scopes, this], func]
        sb.emitOp(node, 'OVER'); // [2, func, [scopes, this], func]

        sb.emitPushInt(node, 2); // [this, [scopes, this], func]

        sb.emitOp(node, 'PICKITEM'); // [[scopes, this], this, [scopes, this], func]

        sb.emitOp(node, 'OVER'); // [1, [scopes, this], this, [scopes, this], func]

        sb.emitPushInt(node, 1); // [this, 1, [scopes, this], [scopes, this], func]

        sb.emitOp(node, 'ROT'); // [[scopes, this], func]

        sb.emitOp(node, 'SETITEM');
      }
    })); // [func]

    sb.emitOp(node, 'TOALTSTACK'); // Push the target on the stack
    // [0, func]

    sb.emitPushInt(node, 0); // [target]

    sb.emitOp(node, 'PICKITEM'); // Call function

    sb.emitCall(node); // Remove scope

    sb.emitOp(node, 'FROMALTSTACK');
    sb.emitOp(node, 'DROP');

    if (optionsIn.pushValue) {
      sb.emitOp(node, 'DUP');
    }

    sb.emitHelper(node, options, sb.helpers.handleCompletion);

    if (optionsIn.pushValue) {
      sb.emitHelper(node, options, sb.helpers.getCompletionVal);
    }
  }

}

// Input: [func]
// Output: [func]
class CloneFunctionHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    sb.emitHelper(node, options, sb.helpers.cloneArray);
  }

}

// Input: [objectVal]
// Output: [objectVal]
class CloneFunctionObjectHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "property", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "both", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });

    if (options.type === 'both') {
      this.property = InternalFunctionProperties.CALL;
      this.both = true;
    } else {
      this.property = options.property;
      this.both = false;
    }
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [objectVal]


    sb.emitHelper(node, options, sb.helpers.shallowCloneObject);

    if (this.both) {
      // [objectVal]
      this.cloneFunction(sb, node, options, InternalFunctionProperties.CALL); // [objectVal]

      this.cloneFunction(sb, node, options, InternalFunctionProperties.CONSTRUCT);
    } else {
      // [objectVal]
      this.cloneFunction(sb, node, options, this.property);
    }
  }

  cloneFunction(sb, node, options, property) {
    // [objectVal, objectVal]
    sb.emitOp(node, 'DUP'); // [property, objectVal, objectVal]

    sb.emitPushString(node, property); // [func, objectVal]

    sb.emitHelper(node, options, sb.helpers.getInternalObjectProperty); // [func, objectVal]

    sb.emitHelper(node, options, sb.helpers.cloneFunction); // [objectVal, func, objectVal]

    sb.emitOp(node, 'OVER'); // [property, objectVal, func, objectVal]

    sb.emitPushString(node, property); // [func, property, objectVal, objectVal]

    sb.emitOp(node, 'ROT'); // [objectVal]

    sb.emitHelper(node, options, sb.helpers.setInternalObjectProperty);
  }

}

// Input: []
// Output: [farr]
class CreateCallArrayHelper extends Helper {
  emit(sb, node, outerOptions) {
    if (!outerOptions.pushValue) {
      return;
    }

    sb.emitHelper(node, outerOptions, sb.helpers.createFunctionArray({
      body: () => {
        sb.withScope(node, outerOptions, options => {
          sb.emitHelper(node, options, sb.helpers.parameters);
          let body;

          if (TypeGuards.isBodyableNode(node)) {
            body = node.getBodyOrThrow();
          } else {
            body = node.getBody();
          }

          if (TypeGuards.isExpression(body)) {
            // [val]
            sb.visit(body, options); // [completion]

            sb.emitHelper(node, options, sb.helpers.createNormalCompletion); // [completion]

            sb.emitOp(node, 'RET');
          } else {
            sb.visit(body, options); // [undefinedVal]

            sb.emitHelper(node, options, sb.helpers.createUndefined); // [completion]

            sb.emitHelper(node, options, sb.helpers.createNormalCompletion); // [completion]

            sb.emitOp(node, 'RET');
          }
        });
      }
    }));
  }

}

// Input: []
// Output: [farr]
class CreateConstructArrayHelper extends Helper {
  constructor({
    body,
    withoutScope
  }) {
    super();
    Object.defineProperty(this, "body", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "withoutScope", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.body = body;
    this.withoutScope = withoutScope || false;
  }

  emit(sb, node, outerOptions) {
    if (!outerOptions.pushValue) {
      return;
    }

    const emit = options => {
      // []
      this.body(); // [undefinedVal]

      sb.emitHelper(node, options, sb.helpers.createUndefined); // [completion]

      sb.emitHelper(node, options, sb.helpers.createNormalCompletion); // [completion]

      sb.emitOp(node, 'RET');
    };

    sb.emitHelper(node, outerOptions, sb.helpers.createFunctionArray({
      body: () => {
        if (this.withoutScope) {
          emit(outerOptions);
        } else {
          sb.withScope(node, outerOptions, options => {
            emit(options);
          });
        }
      }
    }));
  }

}

// Input: []
// Output: [farr]
class CreateFunctionArrayHelper extends Helper {
  constructor({
    body
  }) {
    super();
    Object.defineProperty(this, "body", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.body = body;
  }

  emit(sb, node, options) {
    if (options.pushValue) {
      // TODO: This might break if this/global change after copying?

      /* create function */
      // [[scopes, this]]
      sb.scope.pushAll(sb, node, options); // [[scopes, this]]

      sb.emitHelper(node, options, sb.helpers.cloneArray); // [[scopes, this], [scopes, this]]

      sb.emitOp(node, 'DUP'); // [0, [scopes, this], [scopes, this]]

      sb.emitPushInt(node, 0); // [[scopes, this], 0, [scopes, this], [scopes, this]]

      sb.emitOp(node, 'OVER'); // [0, [scopes, this], 0, [scopes, this], [scopes, this]]

      sb.emitOp(node, 'OVER'); // [scopes, 0, [scopes, this], [scopes, this]]

      sb.emitOp(node, 'PICKITEM'); // [scopes, 0, [scopes, this], [scopes, this]]

      sb.emitHelper(node, options, sb.helpers.cloneArray); // [[scopes, this]]

      sb.emitOp(node, 'SETITEM'); // [target, scopes]

      sb.emitHelper(node, options, sb.helpers.function({
        body: this.body
      })); // [2, target, scopes]

      sb.emitPushInt(node, 2); // [arr]

      sb.emitOp(node, 'PACK');
    }
  }

}

// Input: [farr]
// Output: [objectVal]
class CreateFunctionObjectHelper extends Helper {
  constructor({
    property
  }) {
    super();
    Object.defineProperty(this, "property", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.property = property;
  }

  emit(sb, node, options) {
    if (options.pushValue) {
      // [objectVal, farr]
      sb.emitHelper(node, options, sb.helpers.createObject); // [objectVal, farr, objectVal]

      sb.emitOp(node, 'TUCK'); // ['call', objectVal, farr, objectVal]

      sb.emitPushString(node, this.property); // [farr, 'call', objectVal, objectVal]

      sb.emitOp(node, 'ROT'); // [objectVal]

      sb.emitHelper(node, options, sb.helpers.setInternalObjectProperty);
    }
  }

}

// Input: []
// Output: [jumpTarget]
class FunctionHelper extends Helper {
  constructor({
    body
  }) {
    super();
    Object.defineProperty(this, "body", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.body = body;
  }

  emit(sb, node, options) {
    if (options.pushValue) {
      const jump = sb.jumpTable.add(sb, node, () => {
        this.body();
        sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.createUndefined);
        sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.createNormalCompletion);
        sb.emitOp(node, 'RET');
      });
      sb.emitPushInt(node, jump);
    }
  }

}

// Input: [objectVal, ?thisVal, ?argsarray]
// Output: [val]
class InvokeCallHelper extends Helper {
  static getKey(options = {
    bindThis: false,
    noArgs: false
  }) {
    const bindThis = options.bindThis || false;
    const overwriteThis = options.overwriteThis || false;
    const noArgs = options.noArgs || false;
    return stringify({
      bindThis,
      overwriteThis,
      noArgs
    });
  }

  constructor(options = {
    bindThis: false,
    noArgs: false
  }) {
    super();
    Object.defineProperty(this, "bindThis", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "overwriteThis", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "noArgs", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.bindThis = options.bindThis || false;
    this.overwriteThis = options.overwriteThis || false;
    this.noArgs = options.noArgs || false;
  }

  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // ['call', objectVal, ?thisVal, ?argsarray]

    sb.emitPushString(node, InternalFunctionProperties.CALL); // [func, ?thisVal, ?argsarray]

    sb.emitHelper(node, options, sb.helpers.getInternalObjectProperty);

    if (this.bindThis) {
      // [func, ?argsarray]
      sb.emitHelper(node, options, sb.helpers.bindFunctionThis({
        overwrite: this.overwriteThis
      }));
    }

    if (this.noArgs) {
      // [0, func]
      sb.emitPushInt(node, 0); // [argsarray, func]

      sb.emitOp(node, 'NEWARRAY'); // [func, argsarray]

      sb.emitOp(node, 'SWAP');
    } // [val]


    sb.emitHelper(node, optionsIn, sb.helpers.call);
  }

}

// Input: [objectVal, thisObjectVal, ?argsarray]
// Output: []
class InvokeConstructHelper extends Helper {
  constructor(options = {
    noArgs: false
  }) {
    super();
    Object.defineProperty(this, "noArgs", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.noArgs = options.noArgs || false;
  }

  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // ['construct', objectVal, thisObjectVal, ?argsarray]

    sb.emitPushString(node, InternalFunctionProperties.CONSTRUCT); // [func, thisObjectVal, ?argsarray]

    sb.emitHelper(node, options, sb.helpers.getInternalObjectProperty); // [func, ?argsarray]

    sb.emitHelper(node, options, sb.helpers.bindFunctionThis({
      overwrite: true
    }));

    if (this.noArgs) {
      // [0, func]
      sb.emitPushInt(node, 0); // [argsarray, func]

      sb.emitOp(node, 'NEWARRAY'); // [func, argsarray]

      sb.emitOp(node, 'SWAP');
    } // []


    sb.emitHelper(node, sb.noPushValueOptions(optionsIn), sb.helpers.call);
  }

}

// Input: [objectVal, ?argsarr]
// Output: [thisVal]
class NewHelper extends Helper {
  constructor(options = {
    noArgs: false
  }) {
    super();
    Object.defineProperty(this, "noArgs", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.noArgs = options.noArgs || false;
  }

  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [thisVal, objectVal, ?argsarr]

    sb.emitHelper(node, options, sb.helpers.createObject);

    if (this.noArgs) {
      // [thisVal, objectVal, thisVal]
      sb.emitOp(node, 'TUCK');
    } else {
      // [3, thisVal, objectVal, argsarr]
      sb.emitPushInt(node, 3); // [thisVal, objectVal, argsarr, thisVal]

      sb.emitOp(node, 'XTUCK');
    } // [thisVal, objectVal, thisVal, ?argsarr, thisVal]


    sb.emitOp(node, 'TUCK'); // [objectVal, thisVal, objectVal, thisVal, ?argsarr, thisVal]

    sb.emitOp(node, 'OVER'); // ['prototype', objectVal, thisVal, objectVal, thisVal, ?argsarr, thisVal]

    sb.emitPushString(node, 'prototype'); // [objectVal, 'prototype', thisVal, objectVal, thisVal, ?argsarr, thisVal]

    sb.emitOp(node, 'SWAP'); // ['prototype', objectVal, 'prototype', thisVal, objectVal, thisVal, ?argsarr, thisVal]

    sb.emitPushString(node, 'prototype'); // [prototype, 'prototype', thisVal, objectVal, thisVal, ?argsarr, thisVal]

    sb.emitHelper(node, options, sb.helpers.getPropertyObjectProperty); // [objectVal, thisVal, ?argsarr, thisVal]

    sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty); // [thisVal]

    sb.emitHelper(node, options, sb.helpers.invokeConstruct({
      noArgs: this.noArgs
    }));

    if (!optionsIn.pushValue) {
      // []
      sb.emitOp(node, 'DROP');
    }
  }

}

// Input: [argsArray]
// Output: []
class ParametersHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [argsarr]

    node.getParameters().forEach((param, idx) => {
      const name = sb.scope.add(param.getNameOrThrow());
      const initializer = param.getInitializer();

      if (param.isRestParameter()) {
        sb.reportUnsupported(param);
      } else if (initializer != null) {
        sb.emitHelper(param, sb.noPushValueOptions(options), sb.helpers.if({
          condition: () => {
            // [argsarr, argsarr]
            sb.emitOp(param, 'DUP'); // [size, argsarr]

            sb.emitOp(param, 'ARRAYSIZE'); // [idx, size, argsarr]

            sb.emitPushInt(param, idx); // [lt, argsarr]

            sb.emitOp(param, 'LTE');
          },
          whenTrue: () => {
            // [default, argsarr]
            sb.visit(initializer, sb.pushValueOptions(options));
          },
          whenFalse: () => {
            // [argsarr, argsarr]
            sb.emitOp(param, 'DUP'); // [idx, argsarr, argsarr]

            sb.emitPushInt(param, idx); // [arg, argsarr]

            sb.emitOp(param, 'PICKITEM'); // [arg, arg, argsarr]

            sb.emitOp(param, 'DUP');
            sb.emitHelper(param, sb.noPushValueOptions(options), sb.helpers.if({
              condition: () => {
                // [isUndefined, arg, argsarr]
                sb.emitHelper(param, sb.pushValueOptions(options), sb.helpers.isUndefined);
              },
              whenTrue: () => {
                // [argsarr]
                sb.emitOp(param, 'DROP'); // [default, argsarr]

                sb.visit(initializer, sb.pushValueOptions(options));
              }
            }));
          }
        }));
      } else if (param.isOptional()) {
        sb.emitHelper(param, sb.noPushValueOptions(options), sb.helpers.if({
          condition: () => {
            // [argsarr, argsarr]
            sb.emitOp(param, 'DUP'); // [size, argsarr]

            sb.emitOp(param, 'ARRAYSIZE'); // [idx, size, argsarr]

            sb.emitPushInt(param, idx); // [lt, argsarr]

            sb.emitOp(param, 'LT');
          },
          whenTrue: () => {
            // [undefinedVal, argsarr]
            sb.emitHelper(param, sb.pushValueOptions(options), sb.helpers.createUndefined);
          },
          whenFalse: () => {
            // [argsarr, argsarr]
            sb.emitOp(param, 'DUP'); // [idx, argsarr, argsarr]

            sb.emitPushInt(param, idx); // [arg, argsarr]

            sb.emitOp(param, 'PICKITEM');
          }
        }));
      } else {
        // [argsarr, argsarr]
        sb.emitOp(param, 'DUP'); // [idx, argsarr, argsarr]

        sb.emitPushInt(param, idx); // [arg, argsarr]

        sb.emitOp(param, 'PICKITEM');
      }

      const decorators = param.getDecorators();

      if (decorators.length > 0) {
        sb.reportUnsupported(param);
      } // [argsarr]


      sb.scope.set(sb, param, sb.plainOptions(options), name);
    }); // []

    sb.emitOp(node, 'DROP');
  }

}

// Output: []

class GenericDeserializeHelper extends Helper {
  emitGlobal(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [globalObjectVal]

    sb.scope.getGlobal(sb, node, options); // [name, globalObjectVal]

    sb.emitPushString(node, DESERIALIZE_NAME); // [farr, name, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createFunctionArray({
      body: () => {
        // [0, argsarr]
        sb.emitPushInt(node, 0); // [val]

        sb.emitOp(node, 'PICKITEM');
        sb.emitHelper(node, options, sb.helpers.case(getTypes(sb, node, options).map(forType => ({
          condition: () => {
            sb.emitOp(node, 'DUP');
            forType.isSerializedType();
          },
          whenTrue: () => {
            forType.deserialize();
            sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.createNormalCompletion);
            sb.emitOp(node, 'RET');
          }
        })), () => {
          sb.emitOp(node, 'DROP');
          sb.emitHelper(node, options, sb.helpers.throwTypeError);
        }));
      }
    })); // [objectVal, name, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createFunctionObject({
      property: InternalFunctionProperties.CALL
    })); // []

    sb.emitHelper(node, options, sb.helpers.setInternalObjectProperty);
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    invokeDeserialize(sb, node, options);
  }

}

// Output: []

class GenericSerializeHelper extends Helper {
  emitGlobal(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [globalObjectVal]

    sb.scope.getGlobal(sb, node, options); // [name, globalObjectVal]

    sb.emitPushString(node, SERIALIZE_NAME); // [farr, name, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createFunctionArray({
      body: () => {
        // [0, argsarr]
        sb.emitPushInt(node, 0); // [val]

        sb.emitOp(node, 'PICKITEM');
        sb.emitHelper(node, options, sb.helpers.case(getTypes(sb, node, options).map(forType => ({
          condition: () => {
            sb.emitOp(node, 'DUP');
            forType.isRuntimeType();
          },
          whenTrue: () => {
            forType.serialize();
            sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.createNormalCompletion);
            sb.emitOp(node, 'RET');
          }
        })), () => {
          sb.emitOp(node, 'DROP');
          sb.emitHelper(node, options, sb.helpers.throwTypeError);
        }));
      }
    })); // [objectVal, name, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createFunctionObject({
      property: InternalFunctionProperties.CALL
    })); // []

    sb.emitHelper(node, options, sb.helpers.setInternalObjectProperty);
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    invokeSerialize(sb, node, options);
  }

}

class TypedHelper extends Helper {
  constructor({
    knownType,
    type
  }) {
    super();
    Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "knownType", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.type = type;
    this.knownType = knownType;
  }

}

// Input: [val, errorVal]
// Output: [completion]
class CreateCompletionHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      sb.emitOp(node, 'DROP');
      return;
    } // [2, val, errorVal]


    sb.emitPushInt(node, 2); // [completion]

    sb.emitOp(node, 'PACK');
  }

}

// Input: [val]
// Output: [completion]
class CreateNormalCompletionHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [undefinedVal, val]


    sb.emitHelper(node, options, sb.helpers.createUndefined); // [val, undefinedVal]

    sb.emitOp(node, 'SWAP'); // [completion]

    sb.emitHelper(node, options, sb.helpers.createCompletion);
  }

}

// Input: [errorVal]
// Output: [completion]
class CreateThrowCompletionHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [undefinedVal, errorVal]


    sb.emitHelper(node, options, sb.helpers.createUndefined); // [completion]

    sb.emitHelper(node, options, sb.helpers.createCompletion);
  }

}

// Input: [completion]
// Output: [val]
class GetCompletionBaseHelper extends Helper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "index", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    }), _temp;
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [index, completion]


    sb.emitPushInt(node, this.index); // [val]

    sb.emitOp(node, 'PICKITEM');
  }

}

// Output: [errorVal]

class GetCompletionErrorHelper extends GetCompletionBaseHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "index", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 1
    }), _temp;
  }

}

// Output: [errorVal]

class GetCompletionValHelper extends GetCompletionBaseHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "index", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 0
    }), _temp;
  }

}

let DiagnosticCode;

(function (DiagnosticCode) {
  DiagnosticCode[DiagnosticCode["UNSUPPORTED_SYNTAX"] = 0] = "UNSUPPORTED_SYNTAX";
  DiagnosticCode[DiagnosticCode["UNKNOWN_TYPE"] = 1] = "UNKNOWN_TYPE";
  DiagnosticCode[DiagnosticCode["EXPECTED_NUMBER"] = 2] = "EXPECTED_NUMBER";
  DiagnosticCode[DiagnosticCode["EXPECTED_STRING"] = 3] = "EXPECTED_STRING";
  DiagnosticCode[DiagnosticCode["REFERENCE_ERROR"] = 4] = "REFERENCE_ERROR";
  DiagnosticCode[DiagnosticCode["SOMETHING_WENT_WRONG"] = 5] = "SOMETHING_WENT_WRONG";
  DiagnosticCode[DiagnosticCode["EXPECTED_PROPERTY"] = 6] = "EXPECTED_PROPERTY";
  DiagnosticCode[DiagnosticCode["EXPECTED_CAST"] = 7] = "EXPECTED_CAST";
  DiagnosticCode[DiagnosticCode["TRANSPILATION_ERROR"] = 8] = "TRANSPILATION_ERROR";
  DiagnosticCode[DiagnosticCode["INVALID_CONTRACT_PARAMETER"] = 9] = "INVALID_CONTRACT_PARAMETER";
  DiagnosticCode[DiagnosticCode["INVALID_CONTRACT_TYPE"] = 10] = "INVALID_CONTRACT_TYPE";
  DiagnosticCode[DiagnosticCode["INVALID_CONTRACT_METHOD"] = 11] = "INVALID_CONTRACT_METHOD";
  DiagnosticCode[DiagnosticCode["INVALID_VALUE_TYPE"] = 12] = "INVALID_VALUE_TYPE";
  DiagnosticCode[DiagnosticCode["INVALID_SYS_CALL"] = 13] = "INVALID_SYS_CALL";
  DiagnosticCode[DiagnosticCode["UNKNOWN_SYMBOL"] = 14] = "UNKNOWN_SYMBOL";
})(DiagnosticCode || (DiagnosticCode = {}));

const NORMAL_COMPLETION = 0;
const BREAK_COMPLETION = 1;
const CONTINUE_COMPLETION = 2;
const CATCH_COMPLETION = 3;
const ASSIGNMENT_OPERATORS = new Set([SyntaxKind.EqualsToken, SyntaxKind.PlusEqualsToken, SyntaxKind.MinusEqualsToken, SyntaxKind.AsteriskAsteriskEqualsToken, SyntaxKind.AsteriskEqualsToken, SyntaxKind.SlashEqualsToken, SyntaxKind.PercentEqualsToken, SyntaxKind.AmpersandEqualsToken, SyntaxKind.BarEqualsToken, SyntaxKind.CaretEqualsToken, SyntaxKind.LessThanLessThanEqualsToken, SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken, SyntaxKind.GreaterThanGreaterThanEqualsToken]);

const isValidParent = node => node != null && (TypeGuards.isTryStatement(node) || TypeGuards.isFunctionLikeDeclaration(node) || TypeGuards.isArrowFunction(node) || TypeGuards.isSourceFile(node)); // Input: [completion]
// Output: []


class HandleCompletionHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn);
    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [completion, completion]
        sb.emitOp(node, 'DUP'); // [errorVal, completion]

        sb.emitHelper(node, options, sb.helpers.getCompletionError); // [isUndefined, completion]

        sb.emitHelper(node, options, sb.helpers.isUndefined);
      },
      whenTrue: () => {
        sb.emitOp(node, 'DROP');
      },
      whenFalse: () => {
        let parent = node.getParent();

        if (!isValidParent(parent)) {
          parent = node.getParentWhile(parentNode => !isValidParent(parentNode));

          if (parent != null) {
            parent = parent.getParent();
          }
        }

        if (TypeGuards.isSourceFile(node) || parent != null && TypeGuards.isSourceFile(parent)) {
          // TODO: Add Error notification
          sb.emitOp(node, 'THROW');
        } else if (parent == null) {
          sb.reportError(node, 'Something went wrong, could not find a valid parent node.', DiagnosticCode.SOMETHING_WENT_WRONG);
        } else if (TypeGuards.isTryStatement(parent)) {
          if (options.catchPC == null) {
            sb.reportError(node, 'Something went wrong. Expected a catch jump location.', DiagnosticCode.SOMETHING_WENT_WRONG);
          } else {
            sb.emitPushInt(node, CATCH_COMPLETION);
            sb.emitJmp(node, 'JMP', options.catchPC);
          }
        } else {
          sb.emitOp(node, 'RET');
        }
      }
    }));
  }

}

// Input: [completion]
// Output: [val]
class PickCompletionValHelper extends Helper {
  emit(sb, node, options) {
    if (options.pushValue) {
      // [completion, completion]
      sb.emitOp(node, 'DUP');
    }

    sb.emitHelper(node, options, sb.helpers.handleCompletion);

    if (options.pushValue) {
      sb.emitHelper(node, options, sb.helpers.getCompletionVal);
    }
  }

}

// Input: [errorVal]
// Output: []
class ThrowHelper extends Helper {
  emit(sb, node, options) {
    // [throwCompletion]
    sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.createThrowCompletion); // []

    sb.emitHelper(node, options, sb.helpers.handleCompletion);
  }

}

// Input: []
// Output: []
class ThrowTypeErrorHelper extends Helper {
  emit(sb, node, options) {
    // TODO: Implement with global TypeError prototype
    // ['TypeError']
    sb.emitPushString(node, 'TypeError'); // [value]

    sb.emitHelper(node, options, sb.helpers.createString); // []

    sb.emitHelper(node, options, sb.helpers.throw);
  }

}

// Input: []
// Output: []
class CaseHelper extends Helper {
  constructor(cases, defaultCase) {
    super();
    Object.defineProperty(this, "cases", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "defaultCase", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.cases = cases;
    this.defaultCase = defaultCase;
  }

  emit(sb, node, options) {
    this.addCase(sb, node, options);
  }

  addCase(sb, node, options, idx = 0) {
    if (idx >= this.cases.length) {
      this.defaultCase();
    } else {
      sb.emitHelper(node, options, sb.helpers.if({
        condition: this.cases[idx].condition,
        whenTrue: this.cases[idx].whenTrue,
        whenFalse: () => this.addCase(sb, node, options, idx + 1)
      }));
    }
  }

}

class ForLoopHelper extends Helper {
  constructor({
    each,
    initializer,
    condition,
    incrementor,
    withScope
  }) {
    super();
    Object.defineProperty(this, "each", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "initializer", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "condition", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "incrementor", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "withScope", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.each = each;
    this.initializer = initializer;
    this.condition = condition;
    this.incrementor = incrementor;
    this.withScope = withScope == null ? true : withScope;
  }

  emit(sb, node, options) {
    if (this.withScope) {
      sb.withScope(node, options, innerOptions => {
        this.emitLoop(sb, node, innerOptions);
      });
    } else {
      this.emitLoop(sb, node, options);
    }
  } // TODO: Optimize to check for continue/break that refers to this loop in child.


  emitLoop(sb, node, options) {
    if (this.initializer != null) {
      this.initializer();
    }

    sb.withProgramCounter(loopPC => {
      if (this.condition != null) {
        this.condition();
      }

      if (!loopPC.getFirst().equals(loopPC.getCurrent())) {
        sb.emitJmp(node, 'JMPIFNOT', loopPC.getLast());
      }

      sb.withProgramCounter(breakPC => {
        sb.withProgramCounter(innerPC => {
          sb.withProgramCounter(continuePC => {
            this.each(sb.breakPCOptions(sb.continuePCOptions(options, continuePC.getLast()), breakPC.getLast()));
            sb.emitJmp(node, 'JMP', innerPC.getLast());
          }); // Drop continue completion

          sb.emitOp(node, 'DROP');
        });

        if (this.incrementor != null) {
          this.incrementor();
        }

        sb.emitJmp(node, 'JMP', loopPC.getFirst());
      }); // Drop break completion

      sb.emitOp(node, 'DROP');
    });
  }

}

class IfHelper extends Helper {
  constructor({
    condition,
    whenTrue,
    whenFalse
  }) {
    super();
    Object.defineProperty(this, "condition", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "whenTrue", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "whenFalse", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.condition = condition;
    this.whenTrue = whenTrue;
    this.whenFalse = whenFalse;
  }

  emit(sb, node, options) {
    this.condition();
    const {
      whenTrue,
      whenFalse
    } = this;

    if (whenTrue == null) {
      if (whenFalse == null) {
        throw new Error('If statement must have a true or false value');
      }

      sb.withProgramCounter(endPC => {
        sb.emitJmp(node, 'JMPIF', endPC.getLast());
        whenFalse();
      });
    } else {
      sb.withProgramCounter(whenFalsePC => {
        sb.withProgramCounter(whenTruePC => {
          sb.emitJmp(node, 'JMPIFNOT', whenTruePC.getLast());
          whenTrue();

          if (this.whenFalse != null) {
            sb.emitJmp(node, 'JMP', whenFalsePC.getLast());
          }
        });

        if (this.whenFalse != null) {
          this.whenFalse();
        }
      });
    }
  }

}

class ProcessStatementsHelper extends Helper {
  constructor({
    createScope
  }) {
    super();
    Object.defineProperty(this, "createScope", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.createScope = createScope;
  }

  emit(sb, node, options) {
    if (this.createScope) {
      sb.withScope(node, options, innerOptions => {
        this.emitStatements(sb, node, innerOptions);
      });
    } else {
      this.emitStatements(sb, node, options);
    }
  }

  emitStatements(sb, node, options) {
    node.getFunctions().forEach(func => {
      sb.scope.add(func.getName());
    });
    node.getVariableDeclarations().forEach(decl => {
      sb.scope.add(decl.getName());
    });
    const compilerStatements = node.compilerNode.statements;
    let statements;

    if (compilerStatements == null) {
      statements = node.getStatements();
    } else {
      statements = compilerStatements.map(statement => node.getNodeFromCompilerNode(statement));
    }

    statements.forEach(statement => {
      // TODO: Should functions be hoisted?
      sb.visit(statement, sb.noValueOptions(options));
    });
  }

}

// Input: [value]
// Output: [val]
class CreatePrimitiveHelper extends Helper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "length", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 2
    }), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    }), _temp;
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [type, value]


    sb.emitPushInt(node, this.type); // [2, type, value]

    sb.emitPushInt(node, this.length); // [[type, value]]

    sb.emitOp(node, 'PACK');
  }

}

let Types;

(function (Types) {
  Types[Types["Undefined"] = 0] = "Undefined";
  Types[Types["Null"] = 1] = "Null";
  Types[Types["Boolean"] = 2] = "Boolean";
  Types[Types["String"] = 3] = "String";
  Types[Types["Symbol"] = 4] = "Symbol";
  Types[Types["Number"] = 5] = "Number";
  Types[Types["Object"] = 6] = "Object";
})(Types || (Types = {}));

// Output: [booleanVal]

class CreateBooleanHelper extends CreatePrimitiveHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.Boolean
    }), _temp;
  }

}

// Input: [val]
// Output: [value]
class GetPrimitiveHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [1, val]


    sb.emitPushInt(node, 1); // [value]

    sb.emitOp(node, 'PICKITEM');
  }

}

// Output: [boolean]

class GetBooleanHelper extends GetPrimitiveHelper {}

// Input: [val]
// Output: [boolean]
class IsHelper extends Helper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    }), _temp;
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [0, value]


    sb.emitPushInt(node, 0); // [type]

    sb.emitOp(node, 'PICKITEM'); // [type, type]

    sb.emitPushInt(node, this.type); // [isType]

    sb.emitOp(node, 'EQUAL');
  }

}

// Output: [boolean]

class IsBooleanHelper extends IsHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.Boolean
    }), _temp;
  }

}

function getType(type) {
  if (type == null) {
    return undefined;
  }

  const constraint = type.getConstraint();
  return constraint == null ? type : constraint;
}

const hasUnionType = (type, isType) => getType(type).isUnionType() && getType(type).getUnionTypes().some(isType);
const hasIntersectionType = (type, isType) => getType(type).isIntersectionType() && getType(type).getIntersectionTypes().some(isType);
const hasType = (type, isType) => isType(type) || hasUnionType(type, isType) || hasIntersectionType(type, isType);
const isOnly = (type, isType) => type != null && !getType(type).isNullable() && (isType(type) || getType(type).isUnionType() && getType(type).getUnionTypes().every(unionType => isOnly(unionType, isType)) || getType(type).isIntersectionType() && getType(type).getIntersectionTypes().every(intersectionType => isOnly(intersectionType, isType)));
const isUndefined = type => type != null && getType(type).isUndefinedType();
const isOnlyUndefined = type => isOnly(type, isUndefined);
const hasUndefined = type => hasType(type, isUndefined);
const isNull = type => type != null && (getType(type).isNullType() || getType(type).isNullable());
const isOnlyNull = type => isOnly(type, isNull);
const hasNull = type => hasType(type, isNull) || getType(type).isNullable();
const isOnlyNumberLiteral = type => type != null && isOnly(type, tpe => tpe != null && tpe.isNumberLiteralType());
const isNumber = type => type != null && (getType(type).isNumberType() || getType(type).isNumberLiteralType());
const isOnlyNumber = type => isOnly(type, isNumber);
const hasNumber = type => hasType(type, isNumber);
const isString = type => type != null && (getType(type).isStringType() || getType(type).isStringLiteralType());
const isOnlyString = type => isOnly(type, isString);
const hasString = type => hasType(type, isString);
const isBoolean = type => type != null && (getType(type).isBooleanType() || getType(type).isBooleanLiteralType());
const isOnlyBoolean = type => isOnly(type, isBoolean);
const hasBoolean = type => hasType(type, isBoolean);

const hasTypeFlag = (type, flag // tslint:disable-next-line
) => (getType(type).compilerType.flags & flag) === flag;

const isSymbol = type => type != null && (hasTypeFlag(type, TypeFlags.ESSymbol) || hasTypeFlag(type, TypeFlags.ESSymbolLike));
const isOnlySymbol = type => isOnly(type, isSymbol);
const isPrimitive = type => isUndefined(type) || isNull(type) || isString(type) || isNumber(type) || isBoolean(type) || isSymbol(type);
const isOnlyPrimitive = type => isOnly(type, isPrimitive);
const isOnlyObject = type => isOnly(type, tpe => !isPrimitive(tpe));
const isArray = type => type != null && getType(type).isArrayType();
const isOnlyArray = type => isOnly(type, isArray);
const isTuple = type => type != null && getType(type).isTupleType();
const isOnlyTuple = type => isOnly(type, isTuple);
const isSame = (type0, type1) => type0 != null && type1 != null && (type0 === type1 || isOnlyBoolean(type0) && isOnlyBoolean(type1) || isOnlyNumber(type0) && isOnlyNumber(type1) || isOnlyString(type0) && isOnlyString(type1));
const isUnion = type => type != null && getType(type).isUnionType();
const isIntersection = type => type != null && getType(type).isIntersectionType();
const isLiteral = type => type != null && getType(type).isLiteralType();
const isAnyType = type => type != null && hasTypeFlag(type, TypeFlags.Any);
const isVoid = type => type != null && hasTypeFlag(type, TypeFlags.Void);

// Output: [boolean]

class ToBooleanHelper extends TypedHelper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    if (this.type != null) {
      this.convertType(sb, node, options, this.type);
    } else {
      this.convertUnknownType(sb, node, options);
    }
  }

  convertType(sb, node, options, type) {
    if (isOnlyUndefined(type) || isOnlyNull(type)) {
      sb.emitPushBoolean(node, false);
    } else if (isOnlyBoolean(type)) {
      this.convertBoolean(sb, node, options);
    } else if (isOnlyNumber(type)) {
      this.convertNumber(sb, node, options);
    } else if (isOnlyString(type)) {
      this.convertString(sb, node, options);
    } else if ( // It's a symbol or an object
    !hasUndefined(type) && !hasNull(type) && !hasBoolean(type) && !hasNumber(type) && !hasString(type)) {
      sb.emitPushBoolean(node, true);
    } else {
      this.convertUnknownType(sb, node, options);
    }
  }

  convertBoolean(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.getBoolean);
  }

  convertNumber(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.getNumber);
    sb.emitPushInt(node, 0);
    sb.emitOp(node, 'NUMNOTEQUAL');
  }

  convertString(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.getString);
    sb.emitPushString(node, '');
    sb.emitOp(node, 'EQUAL');
    sb.emitOp(node, 'NOT');
  }

  convertUnknownType(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.case([{
      condition: () => {
        // [value, value]
        sb.emitOp(node, 'DUP'); // [isBoolean, value]

        sb.emitHelper(node, options, sb.helpers.isBoolean);
      },
      whenTrue: () => {
        // [value]
        sb.emitHelper(node, options, sb.helpers.getBoolean);
      }
    }, {
      condition: () => {
        // [value, value]
        sb.emitOp(node, 'DUP'); // [isNull, value]

        sb.emitHelper(node, options, sb.helpers.isNull); // [value, isNull, value]

        sb.emitOp(node, 'OVER'); // [isUndefined, isNull, value]

        sb.emitHelper(node, options, sb.helpers.isUndefined); // [isUndefinedOrNull, value]

        sb.emitOp(node, 'OR');
      },
      whenTrue: () => {
        sb.emitPushBoolean(node, false);
      }
    }, {
      condition: () => {
        // [value, value]
        sb.emitOp(node, 'DUP'); // [isObject, value]

        sb.emitHelper(node, options, sb.helpers.isObject); // [value, isObject, value]

        sb.emitOp(node, 'OVER'); // [isSymbol, isObject, value]

        sb.emitHelper(node, options, sb.helpers.isSymbol); // [isSymbolOrObject, value]

        sb.emitOp(node, 'OR');
      },
      whenTrue: () => {
        sb.emitPushBoolean(node, true);
      }
    }, {
      condition: () => {
        // [value, value]
        sb.emitOp(node, 'DUP'); // [isNumber, value]

        sb.emitHelper(node, options, sb.helpers.isNumber);
      },
      whenTrue: () => {
        this.convertNumber(sb, node, options);
      }
    }], () => {
      this.convertString(sb, node, options);
    }));
  }

}

// Output: [nullVal]

class CreateNullHelper extends CreatePrimitiveHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "length", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 1
    }), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.Null
    }), _temp;
  }

}

// Output: [boolean]

class IsNullHelper extends IsHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.Null
    }), _temp;
  }

}

// Output: [numberVal]

class CreateNumberHelper extends CreatePrimitiveHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.Number
    }), _temp;
  }

}

// Output: [number]

class GetNumberHelper extends GetPrimitiveHelper {}

// Output: [boolean]

class IsNumberHelper extends IsHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.Number
    }), _temp;
  }

}

// be the result.
// Input: [val]
// Output: [number]

class ToNumberHelper extends TypedHelper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    if (this.type != null) {
      this.convertType(sb, node, options, this.type);
    } else {
      this.convertUnknown(sb, node, options);
    }
  }

  convertType(sb, node, options, type) {
    if (isOnlyUndefined(type)) {
      this.convertUndefined(sb, node, options);
    } else if (isOnlyNull(type)) {
      this.convertNull(sb, node, options);
    } else if (isOnlyBoolean(type)) {
      this.convertBoolean(sb, node, options);
    } else if (isOnlyNumber(type)) {
      this.convertNumber(sb, node, options);
    } else if (isOnlyString(type)) {
      this.convertString(sb, node, options);
    } else if (isOnlySymbol(type)) {
      this.convertSymbol(sb, node, options);
    } else if (isOnlyObject(type)) {
      this.convertObject(sb, node, options);
    } else {
      this.convertUnknown(sb, node, options);
    }
  }

  convertUndefined(sb, node, options) {
    // TODO: Should we support this?
    sb.emitHelper(node, options, sb.helpers.throwTypeError);
  }

  convertNull(sb, node, options) {
    // []
    sb.emitOp(node, 'DROP'); // [0]

    sb.emitPushInt(node, 0);
  }

  convertBoolean(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        sb.emitHelper(node, options, sb.helpers.getBoolean);
      },
      whenTrue: () => {
        // [1]
        sb.emitPushInt(node, 1);
      },
      whenFalse: () => {
        // [0]
        sb.emitPushInt(node, 0);
      }
    }));
  }

  convertNumber(sb, node, options) {
    // [value]
    sb.emitHelper(node, options, sb.helpers.getNumber);
  }

  convertString(sb, node, options) {
    // TODO: Should we support this?
    sb.emitHelper(node, options, sb.helpers.throwTypeError);
  }

  convertSymbol(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.throwTypeError);
  }

  convertObject(sb, node, options) {
    // [primitive]
    sb.emitHelper(node, options, sb.helpers.toPrimitive({
      type: this.type,
      knownType: Types.Object,
      preferredType: 'number'
    })); // [value]

    this.convertUnknown(sb, node, options, true);
  }

  convertUnknown(sb, node, options, shouldThrowOnObject = false) {
    const emitIf = (check, whenTrue, whenFalse) => sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [value, value]
        sb.emitOp(node, 'DUP'); // [isValue, value]

        sb.emitHelper(node, options, check);
      },
      whenTrue,
      whenFalse
    }));

    emitIf(sb.helpers.isNumber, () => this.convertNumber(sb, node, options), () => emitIf(sb.helpers.isUndefined, () => this.convertUndefined(sb, node, options), () => emitIf(sb.helpers.isNull, () => this.convertNull(sb, node, options), () => emitIf(sb.helpers.isBoolean, () => this.convertBoolean(sb, node, options), () => emitIf(sb.helpers.isString, () => this.convertString(sb, node, options), () => emitIf(sb.helpers.isSymbol, () => this.convertSymbol(sb, node, options), () => shouldThrowOnObject ? sb.emitHelper(node, options, sb.helpers.throwTypeError) : this.convertObject(sb, node, options)))))));
  }

}

// Output: [objectVal]

class CreateObjectHelper extends Helper {
  emit(sb, node, options) {
    if (options.pushValue) {
      /* create internal object */
      // [iobj]
      sb.emitOp(node, 'NEWMAP');
      /* create symbol obj */
      // [sobj, iobj]

      sb.emitOp(node, 'NEWMAP');
      /* create obj */
      // [pobj, sobj, iobj]

      sb.emitOp(node, 'NEWMAP'); // TODO: Consolidate with ShallowCloneObjectHelper

      /* create object array */
      // [3, pobj, sobj, iobj]

      sb.emitPushInt(node, 3); // [object]

      sb.emitOp(node, 'PACK'); // [objectType, object]

      sb.emitPushInt(node, Types.Object);
      /* create object */
      // [2, objectType, object]

      sb.emitPushInt(node, 2); // [objectVal]

      sb.emitOp(node, 'PACK');
    }
  }

}

// Input: [pobj]
// Output: [objectVal]
class CreatePropertyObjectHelper extends Helper {
  emit(sb, node, options) {
    if (options.pushValue) {
      // TODO: This could use some optimization.
      const obj = sb.scope.addUnique();
      const pobj = sb.scope.addUnique(); // [pobj, pobj]

      sb.emitOp(node, 'DUP'); // [pobj]

      sb.scope.set(sb, node, options, pobj); // [objectVal, pobj]

      sb.emitHelper(node, options, sb.helpers.createObject); // [objectVal, pobj, objectVal]

      sb.emitOp(node, 'TUCK'); // [pobj, objectVal]

      sb.scope.set(sb, node, options, obj); // [keysArr, objectVal]

      sb.emitOp(node, 'KEYS'); // [objectVal]

      sb.emitHelper(node, options, sb.helpers.arrForEach({
        each: () => {
          // [objectVal, key]
          sb.scope.get(sb, node, options, obj); // [pobj, objectVal, key]

          sb.scope.get(sb, node, options, pobj); // [key, pobj, objectVal]

          sb.emitOp(node, 'ROT'); // [key, pobj, key, objectVal]

          sb.emitOp(node, 'TUCK'); // [val, key, objectVal]

          sb.emitOp(node, 'PICKITEM'); // []

          sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty);
        }
      }));
    }
  }

}

// Output: [val]

class ElementAccessHelper extends Helper {
  emit(sb, expr, optionsIn) {
    const options = sb.pushValueOptions(sb.noSetValueOptions(optionsIn));
    const value = expr.getExpression();
    const valueType = sb.getType(value);
    const prop = expr.getArgumentExpressionOrThrow();
    const propType = sb.getType(prop); // [objectVal]

    sb.emitHelper(value, options, sb.helpers.toObject({
      type: sb.getType(value)
    })); // [propVal, objectVal]

    sb.visit(prop, options);

    if (optionsIn.setValue) {
      let valueIndex = 2;

      if (optionsIn.pushValue) {
        // [objectVal, propVal]
        sb.emitOp(expr, 'SWAP'); // [objectVal, propVal, objectVal]

        sb.emitOp(expr, 'TUCK'); // [propVal, objectVal, propVal, objectVal]

        sb.emitOp(expr, 'OVER');
        valueIndex = 4;
      }

      if (isOnlyString(propType)) {
        // [propString, objectVal]
        sb.emitHelper(prop, options, sb.helpers.getString); // []

        this.setProperty(sb, prop, options, valueIndex);
      } else if (isOnlyNumber(propType)) {
        // []
        this.setNumberProperty(sb, prop, options, propType, valueType, valueIndex);
      } else if (isOnlySymbol(propType)) {
        // [propString, objectVal]
        sb.emitHelper(prop, options, sb.helpers.getSymbol); // []

        this.setSymbol(sb, prop, options, valueIndex);
      } else {
        // []
        sb.emitHelper(prop, options, sb.helpers.case([{
          condition: () => {
            // [propVal, propVal, objectVal]
            sb.emitOp(prop, 'DUP'); // [isString, propVal, objectVal]

            sb.emitHelper(prop, options, sb.helpers.isString);
          },
          whenTrue: () => {
            // [propString, objectVal]
            sb.emitHelper(prop, options, sb.helpers.getString); // []

            this.setProperty(sb, prop, options, valueIndex);
          }
        }, {
          condition: () => {
            // [propVal, propVal, objectVal]
            sb.emitOp(prop, 'DUP'); // [isNumber, propVal, objectVal]

            sb.emitHelper(prop, options, sb.helpers.isNumber);
          },
          whenTrue: () => {
            // []
            this.setNumberProperty(sb, prop, options, propType, valueType, valueIndex);
          }
        }], () => {
          // [propString, objectVal]
          sb.emitHelper(prop, options, sb.helpers.getSymbol); // []

          this.setSymbol(sb, prop, options, valueIndex);
        }));
      }
    }

    if (optionsIn.pushValue || !optionsIn.setValue) {
      if (isOnlyString(propType)) {
        // [propString, objectVal]
        sb.emitHelper(prop, options, sb.helpers.getString); // [val]

        sb.emitHelper(expr, options, sb.helpers.getPropertyObjectProperty);
      } else if (isOnlyNumber(propType)) {
        // [val]
        this.getNumberProperty(sb, prop, options, propType, valueType);
      } else if (isOnlySymbol(propType)) {
        // [propString, objectVal]
        sb.emitHelper(prop, options, sb.helpers.getSymbol); // [val]

        sb.emitHelper(expr, options, sb.helpers.getSymbolObjectProperty);
      } else {
        // [val]
        sb.emitHelper(prop, options, sb.helpers.case([{
          condition: () => {
            // [propVal, propVal, objectVal]
            sb.emitOp(prop, 'DUP'); // [propVal, objectVal]

            sb.emitHelper(prop, options, sb.helpers.isString);
          },
          whenTrue: () => {
            // [propString, objectVal]
            sb.emitHelper(prop, options, sb.helpers.getString); // [val]

            sb.emitHelper(expr, options, sb.helpers.getPropertyObjectProperty);
          }
        }, {
          condition: () => {
            // [propVal, propVal, objectVal]
            sb.emitOp(prop, 'DUP'); // [propVal, objectVal]

            sb.emitHelper(prop, options, sb.helpers.isNumber);
          },
          whenTrue: () => {
            // [val]
            this.getNumberProperty(sb, prop, options, propType, valueType);
          }
        }], () => {
          // [propString, objectVal]
          sb.emitHelper(prop, options, sb.helpers.getSymbol); // [val]

          sb.emitHelper(expr, options, sb.helpers.getSymbolObjectProperty);
        }));
      }
    }

    if (!optionsIn.pushValue && !optionsIn.setValue) {
      sb.emitOp(expr, 'DROP');
    }
  }

  getNumberProperty(sb, node, options, propType, valueType) {
    if (isOnlyArray(valueType) || isOnlyTuple(valueType)) {
      sb.emitHelper(node, options, sb.helpers.getNumber);
      sb.emitHelper(node, options, sb.helpers.getArrayIndex);
    } else {
      sb.emitHelper(node, options, sb.helpers.if({
        condition: () => {
          // [isArray, propVal, objectVal]
          this.isArrayInstance(sb, node, options);
        },
        whenTrue: () => {
          // [propNumber, objectVal]
          sb.emitHelper(node, options, sb.helpers.getNumber); // [val]

          sb.emitHelper(node, options, sb.helpers.getArrayIndex);
        },
        whenFalse: () => {
          // [propString, objectVal]
          sb.emitHelper(node, options, sb.helpers.toString({
            type: propType
          })); // [val]

          sb.emitHelper(node, options, sb.helpers.getPropertyObjectProperty);
        }
      }));
    }
  }

  setProperty(sb, node, options, index) {
    // [val, propString, objectVal]
    this.pickValue(sb, node, options, index); // []

    sb.emitHelper(node, options, sb.helpers.setPropertyObjectProperty);
  }

  setNumberProperty(sb, node, options, propType, valueType, index) {
    if (isOnlyArray(valueType) || isOnlyTuple(valueType)) {
      sb.emitHelper(node, options, sb.helpers.getNumber);
      this.setArrayIndex(sb, node, options, index);
    } else {
      sb.emitHelper(node, options, sb.helpers.if({
        condition: () => {
          // [isArray, propVal, objectVal]
          this.isArrayInstance(sb, node, options);
        },
        whenTrue: () => {
          sb.emitHelper(node, options, sb.helpers.getNumber);
          this.setArrayIndex(sb, node, options, index);
        },
        whenFalse: () => {
          // [propString, objectVal]
          sb.emitHelper(node, options, sb.helpers.toString({
            type: propType
          })); // []

          this.setProperty(sb, node, options, index);
        }
      }));
    }
  }

  setArrayIndex(sb, node, options, index) {
    // [val, propNumber, objectVal]
    this.pickValue(sb, node, options, index); // []

    sb.emitHelper(node, options, sb.helpers.setArrayIndex);
  }

  setSymbol(sb, node, options, index) {
    // [val, propString, objectVal]
    this.pickValue(sb, node, options, index); // []

    sb.emitHelper(node, options, sb.helpers.setSymbolObjectProperty);
  }

  isArrayInstance(sb, node, options) {
    // [objectVal, propVal, objectVal]
    sb.emitOp(node, 'OVER'); // [Array, objectVal, propVal, objectVal]

    sb.emitHelper(node, options, sb.helpers.getGlobalProperty({
      property: 'Array'
    })); // [isArray, propVal, objectVal]

    sb.emitHelper(node, options, sb.helpers.instanceof);
  }

  pickValue(sb, node, options, index) {
    if (index === 2) {
      sb.emitOp(node, 'ROT');
    } else {
      // [index, ...]
      sb.emitPushInt(node, index); // [val, ...]

      sb.emitOp(node, 'ROLL');
    }
  }

}

// Input: [stringProp, objectVal]
// Output: [val]
class FindObjectPropertyHelper extends Helper {
  constructor({
    accessor,
    dataExists,
    data,
    getObject
  }) {
    super();
    Object.defineProperty(this, "accessor", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "dataExists", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "data", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "getObject", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.accessor = accessor;
    this.dataExists = dataExists;
    this.data = data;
    this.getObject = getObject;
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      sb.emitOp(node, 'DROP');
      return;
    } // [objectVal, prop]


    sb.emitOp(node, 'SWAP');

    const prepareLoop = () => {
      // [objectVal, objectVal, prop]
      sb.emitOp(node, 'DUP'); // [pobj, objectVal, prop]

      sb.emitHelper(node, options, sb.helpers.getPropertyObject); // [pobj, pobj, objectVal, prop]

      sb.emitOp(node, 'DUP'); // [objectVal, pobj, pobj, prop]

      sb.emitOp(node, 'ROT'); // [obj, pobj, pobj, prop]

      sb.emitHelper(node, options, this.getObject(sb)); // [obj, obj, pobj, pobj, prop]

      sb.emitOp(node, 'DUP'); // [4, obj, obj, pobj, pobj, prop]

      sb.emitPushInt(node, 4); // [prop, obj, obj, pobj, pobj, prop]

      sb.emitOp(node, 'PICK');
    }; // [prop, obj, obj, pobj, pobj, prop]


    prepareLoop();
    sb.emitHelper(node, options, sb.helpers.forLoop({
      condition: () => {
        // [hasKey, obj, pobj, pobj, prop]
        sb.emitOp(node, 'HASKEY'); // [notHasKey, obj, pobj, pobj, prop]

        sb.emitOp(node, 'NOT'); // [pobj, notHasKey, obj, pobj, prop]

        sb.emitOp(node, 'ROT'); // ['prototype', pobj, notHasKey, obj, pobj, prop]

        sb.emitPushString(node, 'prototype'); // [hasPrototypeKey, notHasKey, obj, pobj, prop]

        sb.emitOp(node, 'HASKEY'); // [condition, obj, pobj, prop]

        sb.emitOp(node, 'AND');
      },
      each: () => {
        // [pobj, prop]
        sb.emitOp(node, 'DROP'); // ['prototype', pobj, prop]

        sb.emitPushString(node, 'prototype'); // [propVal, prop]

        sb.emitOp(node, 'PICKITEM'); // [0, propVal, prop]

        sb.emitPushInt(node, 0); // [objectVal, prop]

        sb.emitOp(node, 'PICKITEM'); // [prop, obj, obj, pobj, pobj, prop]

        prepareLoop();
      },
      withScope: false
    })); // [obj, prop]

    sb.emitOp(node, 'NIP'); // [obj, prop, obj]

    sb.emitOp(node, 'TUCK'); // [prop, obj, prop, obj]

    sb.emitOp(node, 'OVER'); // [val]

    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [hasKey, prop, obj]
        sb.emitOp(node, 'HASKEY');
      },
      whenTrue: () => {
        // [propVal]
        sb.emitOp(node, 'PICKITEM'); // [propVal, propVal]

        sb.emitOp(node, 'DUP');
        sb.emitHelper(node, options, sb.helpers.if({
          condition: () => {
            // [size, propVal]
            sb.emitOp(node, 'ARRAYSIZE'); // [2, size, propVal]

            sb.emitPushInt(node, 2); // [size === 2, propVal]

            sb.emitOp(node, 'EQUAL');
          },
          whenTrue: () => {
            this.accessor();
          },
          whenFalse: () => {
            this.dataExists();
          }
        }));
      },
      whenFalse: () => {
        // [obj]
        sb.emitOp(node, 'DROP'); // []

        sb.emitOp(node, 'DROP');
        this.data();
      }
    }));
  }

}

// Input: [objectVal]
// Output: [obj]
class GetObjectHelperBase extends Helper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "index", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    }), _temp;
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [object]


    sb.emitHelper(node, options, sb.helpers.getObject); // [2, object]

    sb.emitPushInt(node, this.index); // [obj]

    sb.emitOp(node, 'PICKITEM');
  }

}

// Output: [iobj]

class GetInternalObjectHelper extends GetObjectHelperBase {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "index", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 2
    }), _temp;
  }

}

// Input: [stringProp, objectVal]
// Output: [val]
class GetInternalObjectPropertyHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      sb.emitOp(node, 'DROP');
      return;
    } // [objectVal, stringProp]


    sb.emitOp(node, 'SWAP'); // [iobj, stringProp]

    sb.emitHelper(node, options, sb.helpers.getInternalObject); // [stringProp, iobj]

    sb.emitOp(node, 'SWAP'); // [val]

    sb.emitOp(node, 'PICKITEM');
  }

}

// Output: [object]

class GetObjectHelper extends GetPrimitiveHelper {}

// Output: [pobj]

class GetPropertyObjectHelper extends GetObjectHelperBase {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "index", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 0
    }), _temp;
  }

}

// Input: [stringProp, objectVal]
// Output: [val]
class GetObjectPropertyHelperBase extends Helper {
  emit(sb, node, options) {
    // [objectVal, stringProp, objectVal]
    sb.emitOp(node, 'OVER'); // [stringProp, objectVal, objectVal]

    sb.emitOp(node, 'SWAP');
    sb.emitHelper(node, options, sb.helpers.findObjectProperty({
      accessor: () => {
        // [0, propVal, objectVal]
        sb.emitPushInt(node, 0); // [getObjectVal, objectVal]

        sb.emitOp(node, 'PICKITEM'); // [val]

        sb.emitHelper(node, options, sb.helpers.invokeCall({
          bindThis: true,
          noArgs: true
        }));
      },
      dataExists: () => {
        // [propVal]
        sb.emitOp(node, 'NIP');

        if (options.pushValue) {
          // [0, propVal]
          sb.emitPushInt(node, 0); // [val]

          sb.emitOp(node, 'PICKITEM');
        } else {
          // []
          sb.emitOp(node, 'DROP');
        }
      },
      data: () => {
        // []
        sb.emitOp(node, 'DROP');

        if (options.pushValue) {
          // [val]
          sb.emitHelper(node, options, sb.helpers.createUndefined);
        }
      },
      getObject: this.getObject.bind(this)
    }));
  }

}

// Output: [val]

class GetPropertyObjectPropertyHelper extends GetObjectPropertyHelperBase {
  getObject(sb) {
    return sb.helpers.getPropertyObject;
  }

}

// Output: [sobj]

class GetSymbolObjectHelper extends GetObjectHelperBase {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "index", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 1
    }), _temp;
  }

}

// Output: [val]

class GetSymbolObjectPropertyHelper extends GetObjectPropertyHelperBase {
  getObject(sb) {
    return sb.helpers.getSymbolObject;
  }

}

// Input: [constructorObjectVal, objectVal]
// Output: [boolean]
class InstanceofHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      sb.emitOp(node, 'DROP');
      return;
    } // ['prototype', constructorObjectVal, objectVal]


    sb.emitPushString(node, 'prototype'); // [prototypeVal, objectVal]

    sb.emitHelper(node, options, sb.helpers.getPropertyObjectProperty); // [objectVal, prototypeVal]

    sb.emitOp(node, 'SWAP');

    const prepareLoop = () => {
      // [objectVal, objectVal, prototypeVal]
      sb.emitOp(node, 'DUP'); // ['prototype', objectVal, objectVal, prototypeVal]

      sb.emitPushString(node, 'prototype'); // [nextPrototypeVal, objectVal, prototypeVal]

      sb.emitHelper(node, options, sb.helpers.getPropertyObjectProperty); // [nextPrototypeVal, nextPrototypeVal, objectVal, prototypeVal]

      sb.emitOp(node, 'DUP'); // [objectVal, nextPrototypeVal, nextPrototypeVal, prototypeVal]

      sb.emitOp(node, 'ROT'); // [3, objectVal, nextPrototypeVal, nextPrototypeVal, prototypeVal]

      sb.emitPushInt(node, 3); // [prototypeVal, objectVal, nextPrototypeVal, nextPrototypeVal, prototypeVal]

      sb.emitOp(node, 'PICK');
    }; // [prototypeVal, objectVal, nextPrototypeVal, nextPrototypeVal, prototypeVal]


    prepareLoop();
    sb.emitHelper(node, options, sb.helpers.forLoop({
      condition: () => {
        // [samePrototype, nextPrototypeVal, nextPrototypeVal, prototypeVal]
        sb.emitOp(node, 'EQUAL'); // [samePrototype, samePrototype, nextPrototypeVal, nextPrototypeVal, prototypeVal]

        sb.emitOp(node, 'DUP'); // [notSamePrototype, samePrototype, nextPrototypeVal, nextPrototypeVal, prototypeVal]

        sb.emitOp(node, 'NOT'); // [nextPrototypeVal, notSamePrototype, samePrototype, nextPrototypeVal, prototypeVal]

        sb.emitOp(node, 'ROT'); // [isUndefined, notSamePrototype, samePrototype, nextPrototypeVal, prototypeVal]

        sb.emitHelper(node, options, sb.helpers.isUndefined); // [hasPrototype, notSamePrototype, samePrototype, nextPrototypeVal, prototypeVal]

        sb.emitOp(node, 'NOT'); // [hasPrototypeAndNotSame, samePrototype, nextPrototypeVal, prototypeVal]

        sb.emitOp(node, 'AND');
      },
      each: () => {
        // [nextPrototypeVal, prototypeVal]
        sb.emitOp(node, 'DROP'); // [prototypeVal, objectVal, nextPrototypeVal, nextPrototypeVal, prototypeVal]

        prepareLoop();
      }
    })); // [samePrototype, prototypeVal]

    sb.emitOp(node, 'NIP'); // [samePrototype]

    sb.emitOp(node, 'NIP');
  }

}

// Output: [boolean]

class IsObjectHelper extends IsHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.Object
    }), _temp;
  }

}

// Input: [?getObjectVal, ?setObjectVal, stringProp, objectVal]
// Output: []
class SetObjectAccessorPropertyHelperBase extends Helper {
  constructor({
    hasSet,
    hasGet
  }) {
    super();
    Object.defineProperty(this, "hasSet", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "hasGet", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.hasSet = hasSet == null ? false : hasSet;
    this.hasGet = hasGet == null ? false : hasGet;

    if (!(this.hasSet || this.hasGet)) {
      throw new Error('Something went wrong. Must have either a getter or setter');
    }
  }

  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn);

    if (!(this.hasSet && this.hasGet)) {
      // [val, ?getObjectVal, ?setObjectVal, stringProp, objectVal]
      sb.emitHelper(node, options, sb.helpers.createUndefined);

      if (this.hasGet) {
        // [getObjectVal, setObjectVal, stringProp, objectVal]
        sb.emitOp(node, 'SWAP');
      }
    } // [2, getObjectVal, setObjectVal, stringProp, objectVal]


    sb.emitPushInt(node, 2); // [val, stringProp, objectVal]

    sb.emitOp(node, 'PACK'); // [objectVal, val, stringProp]

    sb.emitOp(node, 'ROT'); // [obj, val, stringProp]

    sb.emitHelper(node, options, this.getObject(sb)); // [stringProp, obj, val]

    sb.emitOp(node, 'ROT'); // [val, stringProp, obj]

    sb.emitOp(node, 'ROT'); // []

    sb.emitOp(node, 'SETITEM');
  }

}

// Output: []

class SetAccessorPropertyObjectPropertyHelper extends SetObjectAccessorPropertyHelperBase {
  getObject(sb) {
    return sb.helpers.getPropertyObject;
  }

}

// Output: []

class SetAccessorSymbolObjectPropertyHelper extends SetObjectAccessorPropertyHelperBase {
  getObject(sb) {
    return sb.helpers.getSymbolObject;
  }

}

// Input: [val, stringProp, objectVal]
// Output: []
class SetObjectDataPropertyHelperBase extends Helper {
  emit(sb, node, options) {
    // [objectVal, val, stringProp]
    sb.emitOp(node, 'ROT'); // [obj, val, stringProp]

    sb.emitHelper(node, sb.pushValueOptions(options), this.getObject(sb)); // [stringProp, obj, val]

    sb.emitOp(node, 'ROT'); // [val, stringProp, obj]

    sb.emitOp(node, 'ROT'); // [1, val, stringProp, obj]

    sb.emitPushInt(node, 1); // [propVal, stringProp, obj]

    sb.emitOp(node, 'PACK'); // []

    sb.emitOp(node, 'SETITEM');
  }

}

// Output: []

class SetDataPropertyObjectPropertyHelper extends SetObjectDataPropertyHelperBase {
  getObject(sb) {
    return sb.helpers.getPropertyObject;
  }

}

// Output: []

class SetDataSymbolObjectPropertyHelper extends SetObjectDataPropertyHelperBase {
  getObject(sb) {
    return sb.helpers.getSymbolObject;
  }

}

// Input: [val, stringProp, objectVal]
// Output: []
class SetInternalObjectPropertyHelper extends Helper {
  emit(sb, node, options) {
    // [objectVal, val, stringProp]
    sb.emitOp(node, 'ROT'); // [obj, val, stringProp]

    sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.getInternalObject); // [stringProp, obj, val]

    sb.emitOp(node, 'ROT'); // [val, stringProp, obj]

    sb.emitOp(node, 'ROT'); // []

    sb.emitOp(node, 'SETITEM');
  }

}

// Input: [val, stringProp, objectVal]
// Output: [val]
class SetObjectPropertyHelperBase extends Helper {
  emit(sb, node, options) {
    // [objectVal, val, stringProp]
    sb.emitOp(node, 'ROT'); // [stringProp, objectVal, val]

    sb.emitOp(node, 'ROT'); // [stringProp, objectVal, stringProp, val]

    sb.emitOp(node, 'TUCK'); // [objectVal, stringProp, objectVal, stringProp, val]

    sb.emitOp(node, 'OVER'); // [stringProp, objectVal, objectVal, stringProp, val]

    sb.emitOp(node, 'SWAP');
    sb.emitHelper(node, options, sb.helpers.findObjectProperty({
      accessor: () => {
        // [1, propVal, objectVal, stringProp, val]
        sb.emitPushInt(node, 1); // [setObjectVal, objectVal, stringProp, val]

        sb.emitOp(node, 'PICKITEM'); // [stringProp, setObjectVal, objectVal, val]

        sb.emitOp(node, 'ROT'); // [setObjectVal, objectVal, val]

        sb.emitOp(node, 'DROP'); // [val, setObjectVal, objectVal]

        sb.emitOp(node, 'ROT'); // [1, val, setObjectVal, objectVal]

        sb.emitPushInt(node, 1); // [argsarr, setObjectVal, objectVal]

        sb.emitOp(node, 'PACK'); // [objectVal, argsarr, setObjectVal]

        sb.emitOp(node, 'ROT'); // [setObjectVal, objectVal, argsarr]

        sb.emitOp(node, 'ROT'); // [val]

        sb.emitHelper(node, options, sb.helpers.invokeCall({
          bindThis: true,
          noArgs: false
        }));
      },
      dataExists: () => {
        // [propVal, stringProp, val]
        sb.emitOp(node, 'NIP'); // [propVal, val]

        sb.emitOp(node, 'NIP'); // [0, propVal, val]

        sb.emitPushInt(node, 0); // [val, 0, propVal]

        sb.emitOp(node, 'ROT'); // []

        sb.emitOp(node, 'SETITEM');
      },
      data: () => {
        // [stringProp, objectVal, val]
        sb.emitOp(node, 'SWAP'); // [val, stringProp, objectVal]

        sb.emitOp(node, 'ROT'); // []

        sb.emitHelper(node, options, this.setDataProperty(sb));
      },
      getObject: this.getObject.bind(this)
    }));
  }

}

// Output: []

class SetPropertyObjectPropertyHelper extends SetObjectPropertyHelperBase {
  getObject(sb) {
    return sb.helpers.getPropertyObject;
  }

  setDataProperty(sb) {
    return sb.helpers.setDataPropertyObjectProperty;
  }

}

// Output: []

class SetSymbolObjectPropertyHelper extends SetObjectPropertyHelperBase {
  getObject(sb) {
    return sb.helpers.getSymbolObject;
  }

  setDataProperty(sb) {
    return sb.helpers.setDataSymbolObjectProperty;
  }

}

// Output: [objectVal]

class ShallowCloneObjectHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [object]


    sb.emitHelper(node, options, sb.helpers.getObject); // [length, pobj, sobj, iobj, ...]

    sb.emitOp(node, 'UNPACK');

    const roll = () => {
      // [3, length, pobj, sobj, iobj, ...]
      sb.emitPushInt(node, 3); // [iobj, length, pobj, sobj, ...]

      sb.emitOp(node, 'ROLL');
    };

    const clone = () => {
      roll(); // [iobj, length, pobj, sobj, ...]

      sb.emitHelper(node, options, sb.helpers.shallowCloneObj);
    }; // [iobj, length, pobj, sobj, ...]


    clone(); // [sobj, iobj, length, pobj, ...]

    clone(); // [pobj, sobj, iobj, length, ...]

    clone(); // [length, pobj, sobj, iobj, ...]

    roll(); // [object]

    sb.emitOp(node, 'PACK'); // [objectType, object]

    sb.emitPushInt(node, Types.Object); // TODO: Consolidate with CreateObjectHelper

    /* create object */
    // [2, objectType, object]

    sb.emitPushInt(node, 2); // [objectVal]

    sb.emitOp(node, 'PACK');
  }

}

// Input: [obj]
// Output: [obj]
class ShallowCloneObjHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }
    /* create new obj */
    // [newObj, oldObj]


    sb.emitOp(node, 'NEWMAP'); // [oldObj, newObj]

    sb.emitOp(node, 'SWAP');
    /* get keys and values */
    // [oldObj, oldObj, newObj]

    sb.emitOp(node, 'DUP'); // [valuesArray, oldObj, newObj]

    sb.emitOp(node, 'VALUES'); // [oldObj, valuesArray, newObj]

    sb.emitOp(node, 'SWAP'); // [keysArray, valuesArray, newObj]

    sb.emitOp(node, 'KEYS');
    /* set keys/values on new obj */

    sb.withScope(node, options, scopeOptions => {
      const counter = sb.scope.addUnique();
      const length = sb.scope.addUnique();
      sb.emitHelper(node, scopeOptions, sb.helpers.forLoop({
        initializer: () => {
          // [keysArray, keysArray, valuesArray, newObj]
          sb.emitOp(node, 'DUP'); // [length, keysArray, valuesArray, newObj]

          sb.emitOp(node, 'ARRAYSIZE'); // [keysArray, valuesArray, newObj]

          sb.scope.set(sb, node, scopeOptions, length); // [counter, keysArray, valuesArray, newObj]

          sb.emitPushInt(node, 0); // [keysArray, valuesArray, newObj]

          sb.scope.set(sb, node, scopeOptions, counter);
        },
        condition: () => {
          // [counter]
          sb.scope.get(sb, node, scopeOptions, counter); // [length, counter]

          sb.scope.get(sb, node, scopeOptions, length); // [lt]

          sb.emitOp(node, 'LT');
        },
        incrementor: () => {
          // [counter]
          sb.scope.get(sb, node, scopeOptions, counter); // [counter]

          sb.emitOp(node, 'INC'); // []

          sb.scope.set(sb, node, scopeOptions, counter);
        },
        each: innerOptions => {
          // [keysArray, valuesArray, keysArray, newObj]
          sb.emitOp(node, 'TUCK'); // [valuesArray, keysArray, valuesArray, keysArray, newObj]

          sb.emitOp(node, 'OVER'); // [counter, valuesArray, keysArray, valuesArray, keysArray, newObj]

          sb.scope.get(sb, node, innerOptions, counter); // [counter, valuesArray, counter, keysArray, valuesArray, keysArray, newObj]

          sb.emitOp(node, 'TUCK'); // [value, counter, keysArray, valuesArray, keysArray, newObj]

          sb.emitOp(node, 'PICKITEM'); // [keysArray, value, counter, valuesArray, keysArray, newObj]

          sb.emitOp(node, 'ROT'); // [counter, keysArray, value, valuesArray, keysArray, newObj]

          sb.emitOp(node, 'ROT'); // [key, value, valuesArray, keysArray, newObj]

          sb.emitOp(node, 'PICKITEM'); // [4, key, value, valuesArray, keysArray, newObj]

          sb.emitPushInt(node, 4); // [newObj, key, value, valuesArray, keysArray, newObj]

          sb.emitOp(node, 'PICK'); // [key, newObj, value, valuesArray, keysArray, newObj]

          sb.emitOp(node, 'SWAP'); // [value, key, newObj, valuesArray, keysArray, newObj]

          sb.emitOp(node, 'ROT'); // [valuesArray, keysArray, newObj]

          sb.emitOp(node, 'SETITEM');
        }
      }));
    }); // [keysArray, newObj]

    sb.emitOp(node, 'DROP'); // [newObj]

    sb.emitOp(node, 'DROP');
  }

}

// Output: [objectVal]

class ToObjectHelper extends TypedHelper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    const type = this.type;

    if (isOnlyBoolean(type)) {
      this.convertPrimitive(sb, node, options, 'Boolean');
    } else if (isOnlyNumber(type)) {
      this.convertPrimitive(sb, node, options, 'Number');
    } else if (isOnlyString(type)) {
      this.convertPrimitive(sb, node, options, 'String');
    } else if (isOnlySymbol(type)) {
      this.convertPrimitive(sb, node, options, 'Symbol');
    } else if (isOnlyObject(type)) {
      return;
    } else {
      sb.emitHelper(node, options, sb.helpers.case([{
        condition: () => {
          // [val, val]
          sb.emitOp(node, 'DUP'); // [isObject, val]

          sb.emitHelper(node, options, sb.helpers.isObject);
        },
        whenTrue: () => {// do nothing
        }
      }].concat([{
        helper: sb.helpers.isBoolean,
        primitive: 'Boolean'
      }, {
        helper: sb.helpers.isNumber,
        primitive: 'Number'
      }, {
        helper: sb.helpers.isString,
        primitive: 'String'
      }, {
        helper: sb.helpers.isSymbol,
        primitive: 'Symbol'
      }].map(({
        helper,
        primitive
      }) => ({
        condition: () => {
          // [val, val]
          sb.emitOp(node, 'DUP'); // [isObject, val]

          sb.emitHelper(node, options, sb.helpers.isObject);
        },
        whenTrue: () => {
          this.convertPrimitive(sb, node, options, primitive);
        }
      }))), () => {
        sb.emitHelper(node, options, sb.helpers.throwTypeError);
      }));
    }
  }

  convertPrimitive(sb, node, options, primitive) {
    // [1, val]
    sb.emitPushInt(node, 1); // [valArgsArray]

    sb.emitOp(node, 'PACK'); // [globalObjectVal, valArgsArray]

    sb.scope.getGlobal(sb, node, options); // [primitiveString, globalObjectVal, valArgsArray]

    sb.emitPushString(node, primitive); // [primitiveObjectVal, valArgsArray]

    sb.emitHelper(node, options, sb.helpers.getPropertyObjectProperty); // [val]

    sb.emitHelper(node, options, sb.helpers.invokeCall());
  }

}

// Output: [stringVal]

class CreateStringHelper extends CreatePrimitiveHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.String
    }), _temp;
  }

}

// Output: [string]

class GetStringHelper extends GetPrimitiveHelper {}

// Output: [boolean]

class IsStringHelper extends IsHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.String
    }), _temp;
  }

}

// Output: [string]

class ToStringHelper extends TypedHelper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    if (this.type != null) {
      this.convertType(sb, node, options, this.type);
    } else {
      this.convertUnknown(sb, node, options);
    }
  }

  convertType(sb, node, options, type) {
    if (isOnlyUndefined(type)) {
      this.convertUndefined(sb, node, options);
    } else if (isOnlyNull(type)) {
      this.convertNull(sb, node, options);
    } else if (isOnlyBoolean(type)) {
      this.convertBoolean(sb, node, options);
    } else if (isOnlyNumber(type)) {
      this.convertNumber(sb, node, options);
    } else if (isOnlyString(type)) {
      this.convertString(sb, node, options);
    } else if (isOnlySymbol(type)) {
      this.convertSymbol(sb, node, options);
    } else if (isOnlyObject(type)) {
      this.convertObject(sb, node, options);
    } else {
      this.convertUnknown(sb, node, options);
    }
  }

  convertUndefined(sb, node, options) {
    sb.emitPushString(node, 'undefined');
  }

  convertNull(sb, node, options) {
    sb.emitPushString(node, 'null');
  }

  convertBoolean(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        sb.emitHelper(node, options, sb.helpers.getBoolean);
      },
      whenTrue: () => {
        sb.emitPushString(node, 'true');
      },
      whenFalse: () => {
        sb.emitPushString(node, 'false');
      }
    }));
  }

  convertNumber(sb, node, options) {
    // TODO: Try to support this
    sb.emitHelper(node, options, sb.helpers.throwTypeError);
  }

  convertString(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.getString);
  }

  convertSymbol(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.throwTypeError);
  }

  convertObject(sb, node, options) {
    // [primitive]
    sb.emitHelper(node, options, sb.helpers.toPrimitive({
      type: this.type,
      preferredType: 'string'
    })); // [value]

    this.convertUnknown(sb, node, options, true);
  }

  convertUnknown(sb, node, options, shouldThrowOnObject = false) {
    const emitIf = (check, whenTrue, whenFalse) => sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [value, value]
        sb.emitOp(node, 'DUP'); // [isValue, value]

        sb.emitHelper(node, options, check);
      },
      whenTrue,
      whenFalse
    }));

    emitIf(sb.helpers.isString, () => this.convertString(sb, node, options), () => emitIf(sb.helpers.isUndefined, () => this.convertUndefined(sb, node, options), () => emitIf(sb.helpers.isNull, () => this.convertNull(sb, node, options), () => emitIf(sb.helpers.isBoolean, () => this.convertBoolean(sb, node, options), () => emitIf(sb.helpers.isNumber, () => this.convertNumber(sb, node, options), () => emitIf(sb.helpers.isSymbol, () => this.convertSymbol(sb, node, options), () => shouldThrowOnObject ? sb.emitHelper(node, options, sb.helpers.throwTypeError) : this.convertObject(sb, node, options)))))));
  }

}

// Output: [symbolVal]

class CreateSymbolHelper extends CreatePrimitiveHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.Symbol
    }), _temp;
  }

}

// Output: [string]

class GetSymbolHelper extends GetPrimitiveHelper {}

// Output: [boolean]

class IsSymbolHelper extends IsHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.Symbol
    }), _temp;
  }

}

// Output: [undefinedVal]

class CreateUndefinedHelper extends CreatePrimitiveHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "length", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 1
    }), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.Undefined
    }), _temp;
  }

}

// Output: [boolean]

class IsUndefinedHelper extends IsHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: Types.Undefined
    }), _temp;
  }

}

// Input: [val]
// Output: [boolean]
class IsNullOrUndefinedHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [val, val]


    sb.emitOp(node, 'DUP'); // [isNullBoolean, val]

    sb.emitHelper(node, options, sb.helpers.isNull); // [val, isNullBoolean]

    sb.emitOp(node, 'SWAP'); // [isUndefinedBoolean, isNullBoolean]

    sb.emitHelper(node, options, sb.helpers.isUndefined); // [boolean]

    sb.emitOp(node, 'BOOLOR');
  }

}

// Input: [val0, val1]
// Output: [boolean]
class IsSameTypeHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      sb.emitOp(node, 'DROP');
      return;
    } // [type0, val1]


    sb.emitHelper(node, options, sb.helpers.unwrapType); // [val1, type0]

    sb.emitOp(node, 'SWAP'); // [type1, type0]

    sb.emitHelper(node, options, sb.helpers.unwrapType); // [boolean]

    sb.emitOp(node, 'EQUAL');
  }

}

// NOTE: Unlike the other To* methods, this returns a wrapped value.
// Input: [val]
// Output: [val]
class ToPrimitiveHelper extends Helper {
  constructor({
    type,
    knownType,
    preferredType
  }) {
    super();
    Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "knownType", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "preferredType", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.type = type;
    this.knownType = knownType;
    this.preferredType = preferredType || 'default';
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    if (!isOnlyPrimitive(this.type)) {
      if (this.type == null && this.knownType !== Types.Object) {
        this.toPrimitive(sb, node, options);
      } else {
        this.toPrimitiveObject(sb, node, options);
      }
    }
  }

  toPrimitive(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [value, value]
        sb.emitOp(node, 'DUP'); // [isObject, value]

        sb.emitHelper(node, options, sb.helpers.isObject);
      },
      whenTrue: () => {
        this.toPrimitiveObject(sb, node, options);
      }
    }));
  }

  toPrimitiveObject(sb, node, options) {
    // [value, value]
    sb.emitOp(node, 'DUP'); // [symbol, value, value]

    sb.emitPushString(node, '@@toPrimitive'); // [toPrimitive, value]

    sb.emitHelper(node, options, sb.helpers.getSymbolObjectProperty);
    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [toPrimitive, toPrimitive, value]
        sb.emitOp(node, 'DUP'); // [isUndefined, toPrimitive, value]

        sb.emitHelper(node, options, sb.helpers.isUndefined);
      },
      whenTrue: () => {
        // [value]
        sb.emitOp(node, 'DROP'); // [value]

        this.tryConvert(sb, node, options, this.preferredType);
      },
      whenFalse: () => {
        // [preferredType, toPrimitiveVal, val]
        sb.emitPushString(node, this.preferredType); // [1, preferredType, toPrimitiveVal, val]

        sb.emitPushInt(node, 1); // [args, toPrimitiveVal, val]

        sb.emitOp(node, 'PACK'); // [val, args, toPrimitiveVal]

        sb.emitOp(node, 'ROT'); // [toPrimitiveVal, val, args]

        sb.emitOp(node, 'ROT'); // [val]

        sb.emitHelper(node, options, sb.helpers.invokeCall({
          bindThis: true
        }));
      }
    }));
  }

  tryConvert(sb, node, options, preferredType) {
    const methods = preferredType === 'string' ? ['toString', 'valueOf'] : ['valueOf', 'toString']; // [value, value]

    sb.emitOp(node, 'DUP'); // [method, value]

    sb.emitPushString(node, methods[0]); // [func, value]

    sb.emitHelper(node, options, sb.helpers.getPropertyObjectProperty);
    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [func, func, value]
        sb.emitOp(node, 'DUP'); // [isUndefined, func, value]

        sb.emitHelper(node, options, sb.helpers.isUndefined);
      },
      whenTrue: () => {
        // [value]
        sb.emitOp(node, 'DROP'); // [value, value]

        sb.emitOp(node, 'DUP'); // [method, value]

        sb.emitPushString(node, methods[1]); // [func, value]

        sb.emitHelper(node, options, sb.helpers.getPropertyObjectProperty);
        sb.emitHelper(node, options, sb.helpers.if({
          condition: () => {
            // [func, func, value]
            sb.emitOp(node, 'DUP'); // [isUndefined, func, value]

            sb.emitHelper(node, options, sb.helpers.isUndefined);
          },
          whenTrue: () => {
            // [value]
            sb.emitOp(node, 'DROP'); // []

            sb.emitOp(node, 'DROP'); // []

            sb.emitHelper(node, options, sb.helpers.throwTypeError);
          },
          whenFalse: () => {
            sb.emitHelper(node, options, sb.helpers.invokeCall({
              bindThis: true,
              noArgs: true
            }));
          }
        }));
      },
      whenFalse: () => {
        sb.emitHelper(node, options, sb.helpers.invokeCall({
          bindThis: true,
          noArgs: true
        }));
      }
    }));
  }

}

// Input: [val]
// Output: [type]
class UnwrapTypeHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [0, val]


    sb.emitPushInt(node, 0); // [value]

    sb.emitOp(node, 'PICKITEM');
  }

}

// Input: [val]
// Output: [value]
// Must not be undefined or null
class UnwrapValHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [1, val]


    sb.emitPushInt(node, 1); // [value]

    sb.emitOp(node, 'PICKITEM');
  }

}

// Input: []
// Output: [boolean]
class EqualsEqualsEqualsHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "left", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "right", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.left = options.left;
    this.right = options.right;
  }

  emit(sb, node, options) {
    sb.visit(this.left, options);
    sb.visit(this.right, options);

    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      sb.emitOp(node, 'DROP');
      return;
    }

    if (isSame(sb.getType(this.left), sb.getType(this.right))) {
      sb.emitHelper(node, options, sb.helpers.equalsEqualsEqualsSameType);
    } else {
      sb.emitHelper(node, options, sb.helpers.equalsEqualsEqualsUnknown);
    }
  }

}

// Input: [numberVal, numberVal]
// Output: [boolean]
class EqualsEqualsEqualsNumberHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      sb.emitOp(node, 'DROP');
      return;
    } // [number, numberVal]


    sb.emitHelper(node, options, sb.helpers.getNumber); // [numberVal, number]

    sb.emitOp(node, 'SWAP'); // [number, number]

    sb.emitHelper(node, options, sb.helpers.getNumber); // [boolean]

    sb.emitOp(node, 'NUMEQUAL');
  }

}

// Input: [val0, val1]
// Output: [boolean]
class EqualsEqualsEqualsSameTypeHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      sb.emitOp(node, 'DROP');
      return;
    }

    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [val0, val0, val1]
        sb.emitOp(node, 'DUP'); // [isNullOrUndefined]

        sb.emitHelper(node, options, sb.helpers.isNullOrUndefined);
      },
      whenTrue: () => {
        // [val1]
        sb.emitOp(node, 'DROP'); // []

        sb.emitOp(node, 'DROP'); // [boolean]

        sb.emitPushBoolean(node, true);
      },
      whenFalse: () => {
        // [value0, val1]
        sb.emitHelper(node, options, sb.helpers.unwrapVal); // [val1, value0]

        sb.emitOp(node, 'SWAP'); // [value1, value0]

        sb.emitHelper(node, options, sb.helpers.unwrapVal); // [boolean]

        sb.emitOp(node, 'EQUAL');
      }
    }));
  }

}

// Input: [val0, val1]
// Output: [boolean]
class EqualsEqualsEqualsUnknownHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      sb.emitOp(node, 'DROP');
      return;
    }

    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [val1, val0, val1]
        sb.emitOp(node, 'TUCK'); // [val0, val1, val0, val1]

        sb.emitOp(node, 'OVER');
        sb.emitHelper(node, options, sb.helpers.isSameType);
      },
      whenTrue: () => {
        // [boolean]
        sb.emitHelper(node, options, sb.helpers.equalsEqualsEqualsSameType);
      },
      whenFalse: () => {
        // [val1]
        sb.emitOp(node, 'DROP'); // []

        sb.emitOp(node, 'DROP'); // [boolean]

        sb.emitPushBoolean(node, false);
      }
    }));
  }

}

// Input: []
// Output: [boolean]
class EqualsEqualsHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "left", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "right", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.left = options.left;
    this.right = options.right;
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.visit(this.left, options);
      sb.visit(this.right, options);
      return;
    }

    const leftType = sb.getType(this.left);
    const rightType = sb.getType(this.right);

    if (leftType != null && rightType != null) {
      this.equalsEqualsType(sb, node, options, leftType, rightType);
    } else {
      this.equalsEqualsUnknown(sb, node, options);
    }
  }

  equalsEqualsType(sb, node, options, leftType, rightType) {
    if (isSame(leftType, rightType)) {
      sb.emitHelper(node, options, sb.helpers.equalsEqualsEquals({
        left: this.left,
        right: this.right
      }));
    } else if ((hasNull(leftType) || hasUndefined(leftType)) && (isOnlyUndefined(rightType) || isOnlyNull(rightType))) {
      // [left]
      sb.visit(this.left, options); // [right, left]

      sb.visit(this.right, options); // [left]

      sb.emitOp(this.right, 'DROP'); // [equals]

      sb.emitHelper(node, options, sb.helpers.isNullOrUndefined);
    } else if (isOnlyNumber(leftType) && (isOnlyString(rightType) || isOnlyBoolean(rightType))) {
      // [left]
      sb.visit(this.left, options); // [right, left]

      sb.visit(this.right, options); // [equals]

      this.equalsEqualsLeftNumberRightBooleanOrString(sb, node, options);
    } else if (isOnlyBoolean(leftType) && (isOnlyString(rightType) || isOnlyBoolean(rightType))) {
      // [left]
      sb.visit(this.left, options); // [leftNumber]

      sb.emitHelper(this.left, options, sb.helpers.toNumber({
        type: sb.getType(this.left)
      })); // [leftNumberVal]

      sb.emitHelper(this.left, options, sb.helpers.createNumber); // [right, leftNumberVal]

      sb.visit(this.right, options); // [equals]

      this.equalsEqualsLeftNumberRightBooleanOrString(sb, node, options);
    } else if ((isOnlyString(leftType) || isOnlyBoolean(leftType)) && isOnlyNumber(rightType)) {
      // [left]
      sb.visit(this.left, options); // [right, left]

      sb.visit(this.right, options); // [equals]

      this.equalsEqualsRightNumberLeftBooleanOrString(sb, node, options);
    } else if ((isOnlyString(leftType) || isOnlyBoolean(leftType)) && isOnlyBoolean(rightType)) {
      // [left]
      sb.visit(this.left, options); // [right, left]

      sb.visit(this.right, options); // [rightNumber, left]

      sb.emitHelper(this.right, options, sb.helpers.toNumber({
        type: sb.getType(this.right)
      })); // [rightNumberVal, left]

      sb.emitHelper(this.right, options, sb.helpers.createNumber); // [equals]

      this.equalsEqualsRightNumberLeftBooleanOrString(sb, node, options);
    } else {
      this.equalsEqualsUnknown(sb, node, options);
    }
  }

  equalsEqualsLeftNumberRightBooleanOrString(sb, node, options) {
    // [rightNumber, left]
    sb.emitHelper(this.right, options, sb.helpers.toNumber({
      type: sb.getType(this.right)
    })); // [rightNumber, left]

    sb.emitHelper(this.right, options, sb.helpers.createNumber); // [equals]

    sb.emitHelper(node, options, sb.helpers.equalsEqualsEqualsNumber);
  }

  equalsEqualsRightNumberLeftBooleanOrString(sb, node, options) {
    // [left, right]
    sb.emitOp(node, 'SWAP'); // [leftNumber, right]

    sb.emitHelper(this.left, options, sb.helpers.toNumber({
      type: sb.getType(this.left)
    })); // [leftNumber, right]

    sb.emitHelper(this.left, options, sb.helpers.createNumber); // [right, leftNumber]

    sb.emitOp(node, 'SWAP'); // [equals]

    sb.emitHelper(node, options, sb.helpers.equalsEqualsEqualsNumber);
  }

  equalsEqualsUnknown(sb, node, options) {
    const copy = () => {
      // [right, left, right]
      sb.emitOp(this.right, 'TUCK'); // [left, right, left, right]

      sb.emitOp(this.right, 'OVER');
    }; // [left]


    sb.visit(this.left, options); // [right, left]

    sb.visit(this.right, options);
    const cases = [{
      condition: () => {
        copy(); // [right, left]

        sb.emitHelper(node, options, sb.helpers.isSameType);
      },
      whenTrue: () => {
        sb.emitHelper(node, options, sb.helpers.equalsEqualsEqualsSameType);
      }
    }, {
      condition: () => {
        copy(); // [rightIsNullOrUndefined, left, right, left]

        sb.emitHelper(node, options, sb.helpers.isNullOrUndefined); // [left, rightIsNullOrUndefined, right, left]

        sb.emitOp(node, 'SWAP'); // [leftIsNullOrUndefined, rightIsNullOrUndefined, right, left]

        sb.emitHelper(node, options, sb.helpers.isNullOrUndefined); // [equals, right, left]

        sb.emitOp(node, 'BOOLOR');
      },
      whenTrue: () => {
        // [left]
        sb.emitOp(node, 'DROP'); // []

        sb.emitOp(node, 'DROP'); // [equals]

        sb.emitPushBoolean(node, true);
      }
    }, {
      condition: () => {
        copy(); // [right, right, left, right, left]

        sb.emitOp(node, 'DUP'); // [isString, right, left, right, left]

        sb.emitHelper(this.right, options, sb.helpers.isString); // [right, isString, left, right, left]

        sb.emitOp(node, 'SWAP'); // [isBoolean, isString, left, right, left]

        sb.emitHelper(this.right, options, sb.helpers.isBoolean); // [isBooleanOrString, left, right, left]

        sb.emitOp(node, 'BOOLOR'); // [left, isBooleanOrString, right, left]

        sb.emitOp(node, 'SWAP'); // [left, left, isBooleanOrString, right, left]

        sb.emitOp(node, 'DUP'); // [isNumber, left, isBooleanOrString, right, left]

        sb.emitHelper(this.right, options, sb.helpers.isNumber); // [left, isNumber, isBooleanOrString, right, left]

        sb.emitOp(node, 'SWAP'); // [isBoolean, isNumber, isBooleanOrString, right, left]

        sb.emitHelper(this.right, options, sb.helpers.isBoolean); // [isBooleanOrNumber, isBooleanOrString, right, left]

        sb.emitOp(node, 'BOOLOR'); // [is(BooleanOrNumber)And(BooleanOrString), right, left]

        sb.emitOp(node, 'BOOLAND');
      },
      whenTrue: () => {
        // [left, right]
        sb.emitOp(node, 'SWAP'); // [leftNumber, right]

        sb.emitHelper(node, options, sb.helpers.toNumber({
          type: sb.getType(this.left)
        })); // [leftNumber, right]

        sb.emitHelper(node, options, sb.helpers.createNumber); // [right, leftNumber]

        sb.emitOp(node, 'SWAP');
        this.equalsEqualsLeftNumberRightBooleanOrString(sb, node, options);
      }
    }, {
      condition: () => {
        copy(); // [left, right, right, left]

        sb.emitOp(node, 'SWAP'); // [left, left, right, right, left]

        sb.emitOp(node, 'DUP'); // [isString, left, right, right, left]

        sb.emitHelper(this.right, options, sb.helpers.isString); // [left, isString, right, right, left]

        sb.emitOp(node, 'SWAP'); // [isBoolean, isString, right, right, left]

        sb.emitHelper(this.right, options, sb.helpers.isBoolean); // [isBooleanOrString, right, right, left]

        sb.emitOp(node, 'BOOLOR'); // [right, isBooleanOrString, right, left]

        sb.emitOp(node, 'SWAP'); // [right, right, isBooleanOrString, right, left]

        sb.emitOp(node, 'DUP'); // [isNumber, right, isBooleanOrString, right, left]

        sb.emitHelper(this.right, options, sb.helpers.isNumber); // [right, isNumber, isBooleanOrString, right, left]

        sb.emitOp(node, 'SWAP'); // [isBoolean, isNumber, isBooleanOrString, right, left]

        sb.emitHelper(this.right, options, sb.helpers.isBoolean); // [isBooleanOrNumber, isBooleanOrString, right, left]

        sb.emitOp(node, 'BOOLOR'); // [is(BooleanOrNumber)And(BooleanOrString), right, left]

        sb.emitOp(node, 'BOOLAND');
      },
      whenTrue: () => {
        // [rightNumber, left]
        sb.emitHelper(node, options, sb.helpers.toNumber({
          type: sb.getType(this.right)
        })); // [rightNumber, left]

        sb.emitHelper(node, options, sb.helpers.createNumber);
        this.equalsEqualsRightNumberLeftBooleanOrString(sb, node, options);
      }
    }];
    sb.emitHelper(node, options, sb.helpers.case(cases, () => {
      // [rightPrim, left]
      sb.emitHelper(node, options, sb.helpers.toPrimitive({
        type: sb.getType(this.right)
      })); // [left, rightPrim]

      sb.emitOp(node, 'SWAP'); // [leftPrim, rightPrim]

      sb.emitHelper(node, options, sb.helpers.toPrimitive({
        type: sb.getType(this.left)
      })); // [rightPrim, leftPrim]

      sb.emitOp(node, 'SWAP');
      sb.emitHelper(node, options, sb.helpers.case(cases, () => {
        // [leftPrim]
        sb.emitOp(node, 'DROP'); // []

        sb.emitOp(node, 'DROP'); // [equals]

        sb.emitPushBoolean(node, false);
      }));
    }));
  }

}

// Input: []
// Output: [boolean]
// TODO: Currently only supports numbers. Invalid to pass in a string.
class LessThanHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "leftFirst", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "left", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "right", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.leftFirst = options.leftFirst;
    this.left = options.left;
    this.right = options.right;
  }

  emit(sb, node, options) {
    if (!options.pushValue) {
      if (this.leftFirst) {
        sb.visit(this.left, options);
        sb.visit(this.right, options);
      } else {
        sb.visit(this.right, options);
        sb.visit(this.left, options);
      }

      return;
    }

    if (this.leftFirst) {
      // [left]
      sb.visit(this.left, options); // [leftPrim]

      sb.emitHelper(this.left, options, sb.helpers.toPrimitive({
        type: sb.getType(this.left),
        preferredType: 'number'
      })); // [right, leftPrim]

      sb.visit(this.right, options); // [rightPrim, leftPrim]

      sb.emitHelper(this.right, options, sb.helpers.toPrimitive({
        type: sb.getType(this.right),
        preferredType: 'number'
      }));
    } else {
      // [right]
      sb.visit(this.right, options); // [rightPrim]

      sb.emitHelper(this.right, options, sb.helpers.toPrimitive({
        type: sb.getType(this.right),
        preferredType: 'number'
      })); // [left, rightPrim]

      sb.visit(this.left, options); // [leftPrim, rightPrim]

      sb.emitHelper(this.left, options, sb.helpers.toPrimitive({
        type: sb.getType(this.left),
        preferredType: 'number'
      })); // [rightPrim, leftPrim]

      sb.emitOp(node, 'SWAP');
    }

    if (isOnlyString(sb.getType(this.left)) && isOnlyString(sb.getType(this.right))) {
      sb.reportUnsupported(node);
    } else {
      // [rightNumber, leftPrim]
      sb.emitHelper(this.right, options, sb.helpers.toNumber({
        type: sb.getType(this.right)
      })); // [leftPrim, rightNumber]

      sb.emitOp(node, 'SWAP'); // [leftNumber, rightNumber]

      sb.emitHelper(this.left, options, sb.helpers.toNumber({
        type: sb.getType(this.left)
      })); // [rightNumber, leftNumber]

      sb.emitOp(node, 'SWAP'); // [lt]

      sb.emitOp(node, 'LT');

      if (!options.pushValue) {
        sb.emitOp(node, 'DROP');
      }
    }
  }

}

const GLOBAL_PROPERTIES = new Set(['Array', 'Boolean', 'Buffer', 'Error', 'Number', 'Object', 'String', 'Symbol', 'process']);

let InternalGlobalProperties;

(function (InternalGlobalProperties) {
  InternalGlobalProperties["MODULES"] = "modules";
  InternalGlobalProperties["ARGUMENTS"] = "arguments";
})(InternalGlobalProperties || (InternalGlobalProperties = {}));

// Output: []

class AddArgumentsHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // ['arguments', argv, globalObjectVal]

    sb.emitPushString(node, InternalGlobalProperties.ARGUMENTS); // [argv, 'arguments', globalObjectVal]

    sb.emitOp(node, 'SWAP'); // []

    sb.emitHelper(node, options, sb.helpers.setInternalObjectProperty);
  }

}

// Output: [objectPrototypeVal, globalObjectVal]

class AddConstructorObjectHelper extends Helper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    }), _temp;
  }

  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [globalObjectVal, objectPrototypeVal]

    sb.emitOp(node, 'SWAP'); // [globalObjectVal, objectPrototypeVal, globalObjectVal]

    sb.emitOp(node, 'TUCK'); // [objectPrototypeVal, globalObjectVal, objectPrototypeVal, globalObjectVal]

    sb.emitOp(node, 'OVER');
    /* create constructor prototype */
    // [prototypeVal, objectPrototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createObject); // [prototypeVal, objectPrototypeVal, prototypeVal, globalObjectVal]

    sb.emitOp(node, 'TUCK'); // ['prototype', prototypeVal, objectPrototypeVal, prototypeVal, globalObjectVal]

    sb.emitPushString(node, 'prototype'); // [objectPrototypeVal, 'prototype', prototypeVal, prototypeVal, globalObjectVal]

    sb.emitOp(node, 'ROT'); // [prototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty); // [prototypeVal, globalObjectVal]

    this.addPrototypeProperties(sb, node, options);
    /* create object */
    // [objectVal, prototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createObject); // [objectVal, prototypeVal, objectVal, globalObjectVal]

    sb.emitOp(node, 'TUCK'); // [prototypeVal, objectVal, prototypeVal, objectVal, globalObjectVal]

    sb.emitOp(node, 'OVER'); // ['prototype', prototypeVal, objectVal, prototypeVal, objectVal, globalObjectVal]

    sb.emitPushString(node, 'prototype'); // [prototypeVal, 'prototype', objectVal, prototypeVal, objectVal, globalObjectVal]

    sb.emitOp(node, 'SWAP'); // [prototypeVal, objectVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty); // [objectVal, prototypeVal, objectVal, globalObjectVal]

    sb.emitOp(node, 'OVER'); // ['constructor', objectVal, prototypeVal, objectVal, globalObjectVal]

    sb.emitPushString(node, 'constructor'); // [objectVal, 'constructor', prototypeVal, objectVal, globalObjectVal]

    sb.emitOp(node, 'SWAP'); // [objectVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty); // [objectVal, globalObjectVal]

    this.addConstructorProperties(sb, node, options); // [name, objectVal, globalObjectVal]

    sb.emitPushString(node, this.name); // [objectVal, name, globalObjectVal]

    sb.emitOp(node, 'SWAP'); // [objectPrototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty);
  }

  addPrototypeProperties(sb, node, options) {// do nothing
  }

  addConstructorProperties(sb, node, options) {// do nothing
  }

  addMethod(sb, node, options, name, body) {
    // [prototypeVal, prototypeVal, globalObjectVal]
    sb.emitOp(node, 'DUP'); // [name, prototypeVal, prototypeVal, globalObjectVal]

    sb.emitPushString(node, name); // [farr, name, prototypeVal, prototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createFunctionArray({
      body: () => {
        sb.withScope(node, options, body);
        sb.emitHelper(node, options, sb.helpers.createNormalCompletion);
        sb.emitOp(node, 'RET');
      }
    })); // [fobjectVal, name, prototypeVal, prototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createFunctionObject({
      property: InternalFunctionProperties.CALL
    })); // [prototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty);
  }

}

// Input: [objectPrototypeVal, globalObjectVal]
// Output: [objectPrototypeVal, globalObjectVal]
class AddArrayObjectHelper extends AddConstructorObjectHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 'Array'
    }), _temp;
  }

  addPrototypeProperties(sb, node, options) {
    this.addMap(sb, node, options);
    this.addFilter(sb, node, options);
    this.addReduce(sb, node, options);
  }

  addConstructorProperties(sb, node, options) {
    // [objectVal, objectVal, globalObjectVal]
    sb.emitOp(node, 'DUP'); // ['construct', objectVal, objectVal, globalObjectVal]

    sb.emitPushString(node, InternalFunctionProperties.CONSTRUCT); // [func, 'construct', objectVal, objectVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createConstructArray({
      withoutScope: true,
      body: () => {
        // [argsarray, argsarray]
        sb.emitOp(node, 'DUP'); // [size, argsarray]

        sb.emitOp(node, 'ARRAYSIZE');
        sb.emitHelper(node, options, sb.helpers.case([{
          condition: () => {
            // [size, size, argsarray]
            sb.emitOp(node, 'DUP'); // [0, size, size, argsarray]

            sb.emitPushInt(node, 0); // [size === 0, size, argsarray]

            sb.emitOp(node, 'EQUAL');
          },
          whenTrue: () => {
            // [argsarray]
            sb.emitOp(node, 'DROP'); // []

            sb.emitOp(node, 'DROP'); // [length]

            sb.emitPushInt(node, 0); // [0, length]

            sb.emitPushInt(node, 0); // [array, length]

            sb.emitOp(node, 'NEWARRAY');
          }
        }, {
          condition: () => {
            // [size, size, argsarray]
            sb.emitOp(node, 'DUP'); // [1, size, size, argsarray]

            sb.emitPushInt(node, 1); // [size === 1, size, argsarray]

            sb.emitOp(node, 'EQUAL');
          },
          whenTrue: () => {
            // [argsarray]
            sb.emitOp(node, 'DROP'); // [0, argsarray]

            sb.emitPushInt(node, 0); // [lengthVal]

            sb.emitOp(node, 'PICKITEM'); // [length]

            sb.emitHelper(node, options, sb.helpers.getNumber); // [length, length]

            sb.emitOp(node, 'DUP'); // [0, length, length]

            sb.emitPushInt(node, 0); // [arr, length, length]

            sb.emitOp(node, 'NEWARRAY'); // [arr, length, arr, length]

            sb.emitOp(node, 'TUCK'); // [length, arr, arr, length]

            sb.emitOp(node, 'SWAP'); // [array, length]

            sb.emitHelper(node, options, sb.helpers.extendArray);
          }
        }], () => {
          // [array, length]
          sb.emitOp(node, 'SWAP');
        })); // [objectVal, arr, length]

        sb.scope.getThis(sb, node, options); // [objectVal, objectVal, arr, length]

        sb.emitOp(node, 'DUP'); // [arr, objectVal, objectVal, length]

        sb.emitOp(node, 'ROT'); // [objectVal, length]

        sb.emitHelper(node, options, sb.helpers.setArrayValue); // ['length', objectVal, length]

        sb.emitPushString(node, 'length'); // [length, 'length', objectVal]

        sb.emitOp(node, 'ROT'); // [lengthVal, 'length', objectVal]

        sb.emitHelper(node, options, sb.helpers.createNumber); // []

        sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty);
      }
    })); // [objectVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.setInternalObjectProperty);
  }

  addMap(sb, node, options) {
    this.addMapLike(sb, node, options, 'map', sb.helpers.arrMap);
  }

  addFilter(sb, node, options) {
    this.addMapLike(sb, node, options, 'filter', sb.helpers.arrFilter);
  }

  addReduce(sb, node, outerOptions) {
    this.addMethod(sb, node, outerOptions, 'reduce', options => {
      const func = sb.scope.addUnique();
      const accum = sb.scope.addUnique(); // [argsarr, argsarr]

      sb.emitOp(node, 'DUP'); // [0, argsarr, argsarr]

      sb.emitPushInt(node, 0); // [fObjectVal, argsarr]

      sb.emitOp(node, 'PICKITEM'); // [argsarr]

      sb.scope.set(sb, node, options, func); // [argsarr, argsarr]

      sb.emitOp(node, 'DUP'); // [size, argsarr]

      sb.emitOp(node, 'ARRAYSIZE'); // [val]

      sb.emitHelper(node, options, sb.helpers.if({
        condition: () => {
          // [2, size, argsarr]
          sb.emitPushInt(node, 2); // [size === 2, argsarr]

          sb.emitOp(node, 'NUMEQUAL');
        },
        whenTrue: () => {
          // [1, argsarr]
          sb.emitPushInt(node, 1); // [val]

          sb.emitOp(node, 'PICKITEM');
        },
        whenFalse: () => {
          // []
          sb.emitOp(node, 'DROP'); // [val]

          sb.emitHelper(node, options, sb.helpers.createUndefined);
        }
      })); // []

      sb.scope.set(sb, node, options, accum); // [arrayObjectVal]

      sb.scope.getThis(sb, node, options); // [arr]

      sb.emitHelper(node, options, sb.helpers.unwrapArray); // [arr]

      sb.emitHelper(node, options, sb.helpers.arrForEach({
        each: () => {
          // [accum, val, index]
          sb.scope.get(sb, node, options, accum); // [index, accum, val]

          sb.emitOp(node, 'ROT'); // [indexVal, accum, val]

          sb.emitHelper(node, options, sb.helpers.createNumber); // [accum, indexVal, val]

          sb.emitOp(node, 'SWAP'); // [val, accum, indexVal]

          sb.emitOp(node, 'ROT'); // [3, val, accum, indexVal]

          sb.emitPushInt(node, 3); // [argsarr]

          sb.emitOp(node, 'PACK'); // [fObjectVal, argsarr]

          sb.scope.get(sb, node, options, func); // [val]

          sb.emitHelper(node, options, sb.helpers.invokeCall()); // []

          sb.scope.set(sb, node, options, accum);
        },
        withIndex: true
      })); // [val]

      sb.scope.get(sb, node, options, accum);
    });
  }

  addMapLike(sb, node, outerOptions, name, helper) {
    this.addMethod(sb, node, outerOptions, name, options => {
      const func = sb.scope.addUnique(); // [0, argsarr]

      sb.emitPushInt(node, 0); // [fObjectVal]

      sb.emitOp(node, 'PICKITEM'); // []

      sb.scope.set(sb, node, options, func); // [arrayObjectVal]

      sb.scope.getThis(sb, node, options); // [arr]

      sb.emitHelper(node, options, sb.helpers.unwrapArray); // [arr]

      sb.emitHelper(node, options, helper({
        map: () => {
          // [index, val]
          sb.emitOp(node, 'SWAP'); // [indexVal, val]

          sb.emitHelper(node, options, sb.helpers.createNumber); // [val, indexVal]

          sb.emitOp(node, 'SWAP'); // [2, val, indexVal]

          sb.emitPushInt(node, 2); // [argsarr]

          sb.emitOp(node, 'PACK'); // [fObjectVal, argsarr]

          sb.scope.get(sb, node, options, func); // [val]

          sb.emitHelper(node, options, sb.helpers.invokeCall());
        },
        withIndex: true
      })); // [arrayObjectVal]

      sb.emitHelper(node, options, sb.helpers.wrapArray);
    });
  }

}

// Output: [objectPrototypeVal, globalObjectVal]

class AddBufferObjectHelper extends AddConstructorObjectHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 'Buffer'
    }), _temp;
  }

  addConstructorProperties(sb, node, options) {
    this.addConstructor(sb, node, options);
    this.addConcat(sb, node, options);
  }

  addConstructor(sb, node, options) {
    // [objectVal, objectVal, globalObjectVal]
    sb.emitOp(node, 'DUP'); // ['construct', objectVal, objectVal, globalObjectVal]

    sb.emitPushString(node, InternalFunctionProperties.CONSTRUCT); // [func, 'construct', objectVal, objectVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createConstructArray({
      withoutScope: true,
      body: () => {
        // Drop the args array
        // []
        sb.emitOp(node, 'DROP');
      }
    })); // [objectVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.setInternalObjectProperty);
  }

  addConcat(sb, node, outerOptions) {
    this.addMethod(sb, node, outerOptions, 'concat', options => {
      // [0, argsarr]
      sb.emitPushInt(node, 0); // [arrayObjectVal]

      sb.emitOp(node, 'PICKITEM'); // [array]

      sb.emitHelper(node, options, sb.helpers.unwrapArray); // [buffer, array]

      sb.emitOp(node, 'PUSH0');
      sb.emitHelper(node, options, sb.helpers.forLoop({
        condition: () => {
          // [array, buffer, array]
          sb.emitOp(node, 'OVER'); // [size, buffer, array]

          sb.emitOp(node, 'ARRAYSIZE'); // [0, size, buffer, array]

          sb.emitPushInt(node, 0); // [size > 0, buffer, array]

          sb.emitOp(node, 'GT');
        },
        each: () => {
          // [array, buffer, array]
          sb.emitOp(node, 'OVER'); // [0, array, buffer, array]

          sb.emitPushInt(node, 0); // [rightBufferVal, buffer, array]

          sb.emitOp(node, 'PICKITEM'); // [rightBuffer, buffer, array]

          sb.emitHelper(node, options, sb.helpers.unwrapBuffer); // [buffer + rightBuffer, array]

          sb.emitOp(node, 'CAT'); // [array, buffer, array]

          sb.emitOp(node, 'OVER'); // [0, array, buffer, array]

          sb.emitPushInt(node, 0); // [buffer, array]

          sb.emitOp(node, 'REMOVE');
        }
      })); // [buffer]

      sb.emitOp(node, 'NIP'); // [bufferVal]

      sb.emitHelper(node, options, sb.helpers.wrapBuffer);
    });
  }

}

// Output: [objectPrototypeVal, globalObjectVal]

class AddBooleanObjectHelper extends AddConstructorObjectHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 'Boolean'
    }), _temp;
  }

}

// Output: [objectPrototypeVal, globalObjectVal]

class AddErrorObjectHelper extends AddConstructorObjectHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 'Error'
    }), _temp;
  }

  addConstructorProperties(sb, node, options) {
    // [objectVal, objectVal, globalObjectVal]
    sb.emitOp(node, 'DUP'); // ['construct', objectVal, objectVal, globalObjectVal]

    sb.emitPushString(node, InternalFunctionProperties.CONSTRUCT); // [func, 'construct', objectVal, objectVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createConstructArray({
      withoutScope: true,
      body: () => {
        // Drop the args array
        // []
        sb.emitOp(node, 'DROP');
      }
    })); // [objectVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.setInternalObjectProperty);
  }

}

// Output: [objectPrototypeVal, globalObjectVal]

class AddModulesHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [globalObjectVal, objectPrototypeVal, globalObjectVal]

    sb.emitOp(node, 'OVER'); // ['modules', globalObjectVal, objectPrototypeVal, globalObjectVal]

    sb.emitPushString(node, InternalGlobalProperties.MODULES); // [0, 'modules', globalObjectVal, objectPrototypeVal, globalObjectVal]

    sb.emitPushInt(node, 0); // [arr, 'modules', globalObjectVal, objectPrototypeVal, globalObjectVal]

    sb.emitOp(node, 'NEWARRAY'); // [objectPrototypeVal, globalObjectVal]]

    sb.emitHelper(node, options, sb.helpers.setInternalObjectProperty);
  }

}

// Output: [objectPrototypeVal, globalObjectVal]

class AddNumberObjectHelper extends AddConstructorObjectHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 'Number'
    }), _temp;
  }

}

// Input: [globalObjectVal]
// Output: [objectPrototypeVal, globalObjectVal]
class AddObjectObjectHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [globalObjectVal, globalObjectVal]

    sb.emitOp(node, 'DUP');
    /* create object prototype */
    // TODO: Implement more of the prototype
    // [objectPrototypeVal, globalObjectVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createObject); // [objectPrototypeVal, objectPrototypeVal, globalObjectVal, globalObjectVal]

    sb.emitOp(node, 'DUP');
    /* create object */
    // [objectVal, objectPrototypeVal, objectPrototypeVal, globalObjectVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.createObject); // [objectVal, objectPrototypeVal, objectVal, objectPrototypeVal, globalObjectVal, globalObjectVal]

    sb.emitOp(node, 'TUCK'); // ['prototype', objectVal, objectPrototypeVal, objectVal, objectPrototypeVal, globalObjectVal, globalObjectVal]

    sb.emitPushString(node, 'prototype'); // [objectPrototypeVal, 'prototype', objectVal, objectVal, objectPrototypeVal, globalObjectVal, globalObjectVal]

    sb.emitOp(node, 'ROT'); // [objectVal, objectPrototypeVal, globalObjectVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty); // [objectVal, objectPrototypeVal, objectVal, globalObjectVal, globalObjectVal]

    sb.emitOp(node, 'TUCK'); // [objectPrototypeVal, objectVal, objectPrototypeVal, objectVal, globalObjectVal, globalObjectVal]

    sb.emitOp(node, 'OVER'); // ['constructor', objectPrototypeVal, objectVal, objectPrototypeVal, objectVal, globalObjectVal, globalObjectVal]

    sb.emitPushString(node, 'constructor'); // [objectVal, 'constructor', objectPrototypeVal, objectPrototypeVal, objectVal, globalObjectVal, globalObjectVal]

    sb.emitOp(node, 'ROT'); // [objectPrototypeVal, objectVal, globalObjectVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty); // [globalObjectVal, objectPrototypeVal, objectVal, globalObjectVal]

    sb.emitOp(node, 'ROT'); // ['Object', globalObjectVal, objectPrototypeVal, objectVal, globalObjectVal]

    sb.emitPushString(node, 'Object'); // ['Object', globalObjectVal, objectPrototypeVal, objectVal, globalObjectVal]

    sb.emitPushInt(node, 3); // [objectVal, 'Object', globalObjectVal, objectPrototypeVal, globalObjectVal]

    sb.emitOp(node, 'ROLL'); // [objectPrototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty);
  }

}

// Output: [objectPrototypeVal, globalObjectVal]

class AddStringObjectHelper extends AddConstructorObjectHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 'String'
    }), _temp;
  }

}

// Output: [objectPrototypeVal, globalObjectVal]

class AddSymbolObjectHelper extends AddConstructorObjectHelper {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 'Symbol'
    }), _temp;
  }

}

// Input: []
// Output: [globalObjectVal]
class SetGlobalObjectHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [length, ...args]

    sb.emitOp(node, 'DEPTH'); // [argv]

    sb.emitOp(node, 'PACK'); // [globalObjectVal, argv]

    sb.emitHelper(node, options, sb.helpers.createObject); // [globalObjectVal, globalObjectVal, argv]

    sb.emitOp(node, 'DUP'); // [globalObjectVal, argv]

    sb.scope.setGlobal(sb, node, options); // [globalObjectVal, argv, globalObjectVal]

    sb.emitOp(node, 'TUCK'); // [argv, globalObjectVal, globalObjectVal]

    sb.emitOp(node, 'SWAP'); // [globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.addArguments); // [objectPrototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.addObjectObject); // [objectPrototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.addBooleanObject); // [objectPrototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.addNumberObject); // [objectPrototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.addStringObject); // [objectPrototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.addSymbolObject); // [objectPrototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.addArrayObject); // [objectPrototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.addBufferObject); // [objectPrototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.addErrorObject); // [objectPrototypeVal, globalObjectVal]

    sb.emitHelper(node, options, sb.helpers.addModules); // [globalObjectVal]

    sb.emitOp(node, 'DROP');

    if (!optionsIn.pushValue) {
      sb.emitOp(node, 'DROP');
    }
  }

}

// Output: [value]

class GetArgumentHelper extends TypedHelper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [globalObjectVal, numberVal]


    sb.scope.getGlobal(sb, node, options); // [arguments, globalObjectVal, numberVal]

    sb.emitPushString(node, InternalGlobalProperties.ARGUMENTS); // [argv, numberVal]

    sb.emitHelper(node, options, sb.helpers.getInternalObjectProperty); // [numberVal, argv]

    sb.emitOp(node, 'SWAP'); // TODO: This should really be toNumber
    // [number, argv]

    sb.emitHelper(node, options, sb.helpers.toNumber({
      type: this.type
    })); // [value]

    sb.emitOp(node, 'PICKITEM');
  }

}

// Input: []
// Output: [val]
class GetGlobalPropertyHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "property", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.property = options.property;
  }

  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [globalObjectVal]

    sb.scope.getGlobal(sb, node, options); // [propertyString, globalObjectVal]

    sb.emitPushString(node, this.property); // [val]

    sb.emitHelper(node, options, sb.helpers.getPropertyObjectProperty);

    if (!optionsIn.pushValue) {
      sb.emitOp(node, 'DROP');
    }
  }

}

// Input: []
// Output: [objectVal]
class CreateArrayHelper extends Helper {
  emit(sb, node, options) {
    if (options.pushValue) {
      // [Array]
      sb.emitHelper(node, options, sb.helpers.getGlobalProperty({
        property: 'Array'
      })); // [objectVal]

      sb.emitHelper(node, options, sb.helpers.new({
        noArgs: true
      }));
    }
  }

}

// Input: [indexNumber, objectVal]
// Output: [val]
class GetArrayIndexHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn);
    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [objectVal, indexNumber, objectVal]
        sb.emitOp(node, 'OVER'); // ['length', objectVal, indexNumber, objectVal]

        sb.emitPushString(node, 'length'); // [lengthNumberVal, indexNumber, objectVal]

        sb.emitHelper(node, options, sb.helpers.getPropertyObjectProperty); // [lengthNumber, indexNumber, objectVal]

        sb.emitHelper(node, options, sb.helpers.getNumber); // [indexNumber, lengthNumber, indexNumber, objectVal]

        sb.emitOp(node, 'OVER'); // [lessThanLength, indexNumber, objectVal]

        sb.emitOp(node, 'GT');
      },
      whenTrue: () => {
        // [objectVal, indexNumber]
        sb.emitOp(node, 'SWAP'); // [arr, indexNumber]

        sb.emitHelper(node, options, sb.helpers.getArrayValue); // [indexNumber, arr]

        sb.emitOp(node, 'SWAP'); // []

        sb.emitOp(node, 'PICKITEM');
      },
      whenFalse: () => {
        // [indexNumber]
        sb.emitOp(node, 'DROP'); // []

        sb.emitOp(node, 'DROP'); // [val]

        sb.emitHelper(node, options, sb.helpers.createUndefined);
      }
    }));
  }

}

let InternalArrayProperties;

(function (InternalArrayProperties) {
  InternalArrayProperties["DATA_ARRAY"] = "DataArray";
})(InternalArrayProperties || (InternalArrayProperties = {}));

// Output: [arr]

class GetArrayValueHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // ['DataArray', objectVal]


    sb.emitPushString(node, InternalArrayProperties.DATA_ARRAY); // [arr]

    sb.emitHelper(node, options, sb.helpers.getInternalObjectProperty);
  }

}

// Input: [val, indexNumber, objectVal]
// Output: []
class SetArrayIndexHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn);
    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [objectVal, val, indexNumber]
        sb.emitOp(node, 'ROT'); // [indexNumber, objectVal, val]

        sb.emitOp(node, 'ROT'); // [objectVal, indexNumber, objectVal, val]

        sb.emitOp(node, 'OVER'); // ['length', objectVal, indexNumber, objectVal, val]

        sb.emitPushString(node, 'length'); // [lengthNumberVal, indexNumber, objectVal, val]

        sb.emitHelper(node, options, sb.helpers.getPropertyObjectProperty); // [lengthNumber, indexNumber, objectVal, val]

        sb.emitHelper(node, options, sb.helpers.getNumber); // [indexNumber, lengthNumber, indexNumber, objectVal, val]

        sb.emitOp(node, 'OVER'); // [lessThanLength, indexNumber, objectVal, val]

        sb.emitOp(node, 'GT');
      },
      whenTrue: () => {
        // [objectVal, indexNumber, val]
        sb.emitOp(node, 'SWAP'); // []

        this.setIndex(sb, node, options);
      },
      whenFalse: () => {
        // [objectVal, indexNumber, objectVal, val]
        sb.emitOp(node, 'OVER'); // [arr, indexNumber, objectVal, val]

        sb.emitHelper(node, options, sb.helpers.getArrayValue); // [indexNumber, arr, indexNumber, objectVal, val]

        sb.emitOp(node, 'OVER'); // [indexNumber + 1, arr, indexNumber, objectVal, val]

        sb.emitOp(node, 'INC'); // [length, arr, length, indexNumber, objectVal, val]

        sb.emitOp(node, 'TUCK'); // [length, indexNumber, objectVal, val]

        sb.emitHelper(node, options, sb.helpers.extendArray); // [objectVal, length, indexNumber, val]

        sb.emitOp(node, 'ROT'); // [objectVal, length, objectVal, indexNumber, val]

        sb.emitOp(node, 'TUCK'); // ['length', objectVal, length, objectVal, indexNumber, val]

        sb.emitPushString(node, 'length'); // [length, 'length', objectVal, objectVal, indexNumber, val]

        sb.emitOp(node, 'ROT'); // [lengthVal, 'length', objectVal, objectVal, indexNumber, val]

        sb.emitHelper(node, options, sb.helpers.createNumber); // [objectVal, indexNumber, val]

        sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty); // []

        this.setIndex(sb, node, options);
      }
    }));
  }

  setIndex(sb, node, options) {
    // [arr, indexNumber, val]
    sb.emitHelper(node, options, sb.helpers.getArrayValue); // [indexNumber, arr, val]

    sb.emitOp(node, 'SWAP'); // [val, indexNumber, arr]

    sb.emitOp(node, 'ROT'); // []

    sb.emitOp(node, 'SETITEM');
  }

}

// Output: []

class SetArrayValueHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // ['DataArray', arr, objectVal]

    sb.emitPushString(node, InternalArrayProperties.DATA_ARRAY); // [arr, 'DataArray', objectVal]

    sb.emitOp(node, 'SWAP'); // []

    sb.emitHelper(node, options, sb.helpers.setInternalObjectProperty);
  }

}

// Input: [objectVal]
// Output: [arr]
class UnwrapArrayHelper extends Helper {
  emit(sb, node, optionsIn) {
    if (!optionsIn.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    const options = sb.pushValueOptions(optionsIn); // [arr]

    sb.emitHelper(node, options, sb.helpers.getArrayValue);
  }

}

// Input: [arr]
// Output: [objectVal]
class WrapArrayHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    const invokeArrayConstruct = () => {
      // [Array, argsarr]
      sb.emitHelper(node, options, sb.helpers.getGlobalProperty({
        property: 'Array'
      })); // [objectVal]

      sb.emitHelper(node, options, sb.helpers.new());
    };

    sb.emitHelper(node, options, sb.helpers.if({
      condition: () => {
        // [arr, arr]
        sb.emitOp(node, 'DUP'); // [size, arr]

        sb.emitOp(node, 'ARRAYSIZE'); // [1, size, arr]

        sb.emitPushInt(node, 1); // [size === 1, arr]

        sb.emitOp(node, 'EQUAL');
      },
      whenTrue: () => {
        // [0, arr]
        sb.emitPushInt(node, 0); // [val]

        sb.emitOp(node, 'PICKITEM'); // [1, val]

        sb.emitPushInt(node, 1); // [lengthVal, val]

        sb.emitHelper(node, options, sb.helpers.createNumber); // [1, lengthVal, val]

        sb.emitPushInt(node, 1); // [argsarr, val]

        sb.emitOp(node, 'PACK'); // [arrayObjectVal, val]

        invokeArrayConstruct(); // [arrayObjectVal, val, arrayObjectVal]

        sb.emitOp(node, 'TUCK'); // [0, arrayObjectVal, val, arrayObjectVal]

        sb.emitPushInt(node, 0); // [val, 0, arrayObjectVal, arrayObjectVal]

        sb.emitOp(node, 'ROT'); // [arrayObjectVal]

        sb.emitHelper(node, options, sb.helpers.setArrayIndex);
      },
      whenFalse: () => {
        // [arrayObjectVal]
        invokeArrayConstruct();
      }
    }));
  }

}

// Input: [globalObjectVal]
// Output: []
class AddEmptyModuleHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [modules]

    sb.emitHelper(node, options, sb.helpers.getModules); // [exports, modules]

    sb.emitOp(node, 'NEWMAP'); // []

    sb.emitOp(node, 'APPEND');
  }

}

// Input: [val, exports]
// Output: []
class ExportHelper extends Helper {
  constructor({
    name,
    defaultExport
  }) {
    super();
    Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "defaultExport", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.name = name;
    this.defaultExport = defaultExport || false;
  }

  emit(sb, node, optionsIn) {
    if (this.name != null) {
      sb.addExport(this.name); // [name, val, exports]

      sb.emitPushString(node, this.name);
    } else if (this.defaultExport) {
      // [name, val, exports]
      sb.emitPushString(node, 'default');
    } else {
      sb.reportUnsupported(node);
    } // [val, name, exports]


    sb.emitOp(node, 'SWAP'); // []

    sb.emitOp(node, 'SETITEM');
  }

}

// Input: [val]
// Output: []
class ExportSingleHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "options", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.options = options;
  }

  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [exports, val]

    sb.emitHelper(node, options, sb.helpers.getCurrentModule); // [val, exports]

    sb.emitOp(node, 'SWAP'); // []

    sb.emitHelper(node, options, sb.helpers.export(this.options));
  }

}

// Input: []
// Output: [exports]
class GetCurrentModuleHelper extends Helper {
  emit(sb, node, options) {
    if (options.pushValue) {
      // [globalObjectVal]
      sb.scope.getGlobal(sb, node, options); // [exports]

      sb.emitHelper(node, options, sb.helpers.getModule({
        moduleIndex: sb.moduleIndex
      }));
    }
  }

}

// Input: [globalObjectVal]
// Output: [exports]
class GetModuleHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "moduleIndex", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.moduleIndex = options.moduleIndex;
  }

  emit(sb, node, options) {
    if (options.pushValue) {
      // [modules, index]
      sb.emitHelper(node, options, sb.helpers.getModules); // [index, modules]

      sb.emitPushInt(node, this.moduleIndex); // [exports]

      sb.emitOp(node, 'PICKITEM');
    }
  }

}

// Output: [modules]

class GetModulesHelper extends Helper {
  emit(sb, node, options) {
    if (options.pushValue) {
      // ['modules', globalObjectVal]
      sb.emitPushString(node, InternalGlobalProperties.MODULES); // [modules]

      sb.emitHelper(node, options, sb.helpers.getInternalObjectProperty);
    }
  }

}

let InternalBlockchainInterfaceProperties;

(function (InternalBlockchainInterfaceProperties) {
  InternalBlockchainInterfaceProperties["BLOCKCHAIN_INTERFACE"] = "BlockchainInterface";
})(InternalBlockchainInterfaceProperties || (InternalBlockchainInterfaceProperties = {}));

// Input: [objectVal]
// Output: [boolean]
class IsBlockchainInterfaceHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.name = options.name;
  }

  emit(sb, node, optionsIn) {
    if (!optionsIn.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    const options = sb.pushValueOptions(optionsIn); // ['__brand', objectVal]

    sb.emitPushString(node, '__brand'); // [brandVal]

    sb.emitHelper(node, options, sb.helpers.getPropertyObjectProperty); // [brand]

    sb.emitHelper(node, options, sb.helpers.getString); // [name, brand]

    sb.emitPushString(node, this.name); // [boolean]

    sb.emitOp(node, 'EQUAL');
  }

}

// Output: [blockchainInterface]

class UnwrapBlockchainInterfaceHelper extends Helper {
  emit(sb, node, optionsIn) {
    if (!optionsIn.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    const options = sb.pushValueOptions(optionsIn); // ['blockchain_interface', objectVal]

    sb.emitPushString(node, InternalBlockchainInterfaceProperties.BLOCKCHAIN_INTERFACE); // [blockchainInterface]

    sb.emitHelper(node, options, sb.helpers.getInternalObjectProperty);
  }

}

// Input: [blockchainInterface]
// Output: [objectVal]
class WrapBlockchainInterfaceHelper extends Helper {
  constructor(options) {
    super();
    Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.name = options.name;
  }

  emit(sb, node, optionsIn) {
    if (!optionsIn.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    }

    const options = sb.pushValueOptions(optionsIn); // [objectVal, blockchainInterface]

    sb.emitHelper(node, options, sb.helpers.createObject); // [objectVal, blockchainInterface, objectVal]

    sb.emitOp(node, 'TUCK'); // ['__brand', objectVal, blockchainInterface, objectVal]

    sb.emitPushString(node, '__brand'); // [name, '__brand', objectVal, blockchainInterface, objectVal]

    sb.emitPushString(node, this.name); // [nameVal, '__brand', objectVal, blockchainInterface, objectVal]

    sb.emitHelper(node, options, sb.helpers.createString); // [blockchainInterface, objectVal]

    sb.emitHelper(node, options, sb.helpers.setDataPropertyObjectProperty); // [objectVal, blockchainInterface, objectVal]

    sb.emitOp(node, 'OVER'); // ['blockchain_interface', objectVal, blockchainInterface, objectVal]

    sb.emitPushString(node, InternalBlockchainInterfaceProperties.BLOCKCHAIN_INTERFACE); // [blockchainInterface, 'blockchain_interface', objectVal, objectVal]

    sb.emitOp(node, 'ROT'); // [objectVal]

    sb.emitHelper(node, options, sb.helpers.setInternalObjectProperty);
  }

}

// Input: []
// Output: [objectVal]
class CreateBufferHelper extends Helper {
  emit(sb, node, options) {
    if (options.pushValue) {
      // [Buffer]
      sb.emitHelper(node, options, sb.helpers.getGlobalProperty({
        property: 'Buffer'
      })); // [objectVal]

      sb.emitHelper(node, options, sb.helpers.new({
        noArgs: true
      }));
    }
  }

}

let InternalBufferProperties;

(function (InternalBufferProperties) {
  InternalBufferProperties["DATA"] = "Data";
})(InternalBufferProperties || (InternalBufferProperties = {}));

// Output: [byteArray]

class GetBufferValueHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // ['data', objectVal]

    sb.emitPushString(node, InternalBufferProperties.DATA); // [byteArray]

    sb.emitHelper(node, options, sb.helpers.getInternalObjectProperty);
  }

}

// Output: []

class SetBufferValueHelper extends Helper {
  emit(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // ['data', byteArray, objectVal]

    sb.emitPushString(node, InternalBufferProperties.DATA); // [byteArray, 'data', objectVal]

    sb.emitOp(node, 'SWAP'); // []

    sb.emitHelper(node, options, sb.helpers.setInternalObjectProperty);
  }

}

// Input: [objectVal]
// Output: [byteArray]
class UnwrapBufferHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [byteArray]


    sb.emitHelper(node, options, sb.helpers.getBufferValue);
  }

}

// Input: [byteArray]
// Output: [objectVal]
class WrapBufferHelper extends Helper {
  emit(sb, node, options) {
    if (!options.pushValue) {
      sb.emitOp(node, 'DROP');
      return;
    } // [objectVal, byteArray]


    sb.emitHelper(node, options, sb.helpers.createBuffer); // [objectVal, byteArray, objectVal]

    sb.emitOp(node, 'TUCK'); // [byteArray, objectVal, objectVal]

    sb.emitOp(node, 'SWAP'); // [objectVal]

    sb.emitHelper(node, options, sb.helpers.setBufferValue);
  }

}

const createHelpers = () => {
  const cache = {};

  function memoized(HelperClass) {
    return options => {
      const key = HelperClass.getKey(options);

      if (cache[key] == null) {
        cache[key] = new HelperClass(options);
      }

      return cache[key];
    };
  }

  return {
    arrFilter: options => new ArrFilterHelper(options),
    arrMap: options => new ArrMapHelper(options),
    arrForEach: options => new ArrForEachHelper(options),
    cloneArray: new CloneArrayHelper(),
    extendArray: new ExtendArrayHelper(),
    forType: options => new ForTypeHelper(options),
    genericDeserialize: new GenericDeserializeHelper(),
    genericSerialize: new GenericSerializeHelper(),
    equalsEqualsEquals: options => new EqualsEqualsEqualsHelper(options),
    equalsEqualsEqualsNumber: new EqualsEqualsEqualsNumberHelper(),
    equalsEqualsEqualsSameType: new EqualsEqualsEqualsSameTypeHelper(),
    equalsEqualsEqualsUnknown: new EqualsEqualsEqualsUnknownHelper(),
    equalsEquals: options => new EqualsEqualsHelper(options),
    lessThan: options => new LessThanHelper(options),
    processStatements: options => new ProcessStatementsHelper(options),
    args: new ArgumentsHelper(),
    bindFunctionObjectThis: options => new BindFunctionObjectThisHelper(options),
    bindFunctionThis: options => new BindFunctionThisHelper(options),
    call: new CallHelper(),
    cloneFunction: new CloneFunctionHelper(),
    cloneFunctionObject: options => new CloneFunctionObjectHelper(options),
    createCallArray: new CreateCallArrayHelper(),
    createConstructArray: options => new CreateConstructArrayHelper(options),
    createFunctionArray: options => new CreateFunctionArrayHelper(options),
    createFunctionObject: options => new CreateFunctionObjectHelper(options),
    function: options => new FunctionHelper(options),
    invokeCall: memoized(InvokeCallHelper),
    invokeConstruct: options => new InvokeConstructHelper(options),
    new: options => new NewHelper(options),
    parameters: new ParametersHelper(),
    forLoop: options => new ForLoopHelper(options),
    if: options => new IfHelper(options),
    case: (cases, defaultCase) => new CaseHelper(cases, defaultCase),
    createCompletion: new CreateCompletionHelper(),
    createNormalCompletion: new CreateNormalCompletionHelper(),
    createThrowCompletion: new CreateThrowCompletionHelper(),
    getCompletionError: new GetCompletionErrorHelper(),
    getCompletionVal: new GetCompletionValHelper(),
    handleCompletion: new HandleCompletionHelper(),
    pickCompletionVal: new PickCompletionValHelper(),
    throw: new ThrowHelper(),
    throwTypeError: new ThrowTypeErrorHelper(),
    createBoolean: new CreateBooleanHelper(),
    createNull: new CreateNullHelper(),
    createNumber: new CreateNumberHelper(),
    createObject: new CreateObjectHelper(),
    createString: new CreateStringHelper(),
    createSymbol: new CreateSymbolHelper(),
    createUndefined: new CreateUndefinedHelper(),
    isBoolean: new IsBooleanHelper(),
    isNull: new IsNullHelper(),
    isNumber: new IsNumberHelper(),
    isObject: new IsObjectHelper(),
    isString: new IsStringHelper(),
    isSymbol: new IsSymbolHelper(),
    isUndefined: new IsUndefinedHelper(),
    isNullOrUndefined: new IsNullOrUndefinedHelper(),
    isSameType: new IsSameTypeHelper(),
    getBoolean: new GetBooleanHelper(),
    getNumber: new GetNumberHelper(),
    getString: new GetStringHelper(),
    getSymbol: new GetSymbolHelper(),
    getObject: new GetObjectHelper(),
    toBoolean: options => new ToBooleanHelper(options),
    toString: options => new ToStringHelper(options),
    toNumber: options => new ToNumberHelper(options),
    toObject: options => new ToObjectHelper(options),
    toPrimitive: options => new ToPrimitiveHelper(options),
    getSymbolObject: new GetSymbolObjectHelper(),
    getSymbolObjectProperty: new GetSymbolObjectPropertyHelper(),
    setSymbolObjectProperty: new SetSymbolObjectPropertyHelper(),
    setDataSymbolObjectProperty: new SetDataSymbolObjectPropertyHelper(),
    setAccessorSymbolObjectProperty: options => new SetAccessorSymbolObjectPropertyHelper(options),
    getPropertyObject: new GetPropertyObjectHelper(),
    getPropertyObjectProperty: new GetPropertyObjectPropertyHelper(),
    setPropertyObjectProperty: new SetPropertyObjectPropertyHelper(),
    setDataPropertyObjectProperty: new SetDataPropertyObjectPropertyHelper(),
    setAccessorPropertyObjectProperty: options => new SetAccessorPropertyObjectPropertyHelper(options),
    getInternalObject: new GetInternalObjectHelper(),
    getInternalObjectProperty: new GetInternalObjectPropertyHelper(),
    setInternalObjectProperty: new SetInternalObjectPropertyHelper(),
    shallowCloneObject: new ShallowCloneObjectHelper(),
    shallowCloneObj: new ShallowCloneObjHelper(),
    elementAccess: new ElementAccessHelper(),
    unwrapType: new UnwrapTypeHelper(),
    unwrapVal: new UnwrapValHelper(),
    instanceof: new InstanceofHelper(),
    createPropertyObject: new CreatePropertyObjectHelper(),
    findObjectProperty: options => new FindObjectPropertyHelper(options),
    getArrayValue: new GetArrayValueHelper(),
    createArray: new CreateArrayHelper(),
    setArrayValue: new SetArrayValueHelper(),
    getArrayIndex: new GetArrayIndexHelper(),
    setArrayIndex: new SetArrayIndexHelper(),
    wrapArray: new WrapArrayHelper(),
    unwrapArray: new UnwrapArrayHelper(),
    createBuffer: new CreateBufferHelper(),
    getBufferValue: new GetBufferValueHelper(),
    setBufferValue: new SetBufferValueHelper(),
    unwrapBuffer: new UnwrapBufferHelper(),
    wrapBuffer: new WrapBufferHelper(),
    export: options => new ExportHelper(options),
    exportSingle: options => new ExportSingleHelper(options),
    getModule: options => new GetModuleHelper(options),
    getCurrentModule: new GetCurrentModuleHelper(),
    getModules: new GetModulesHelper(),
    addEmptyModule: new AddEmptyModuleHelper(),
    isBlockchainInterface: options => new IsBlockchainInterfaceHelper(options),
    wrapBlockchainInterface: options => new WrapBlockchainInterfaceHelper(options),
    unwrapBlockchainInterface: new UnwrapBlockchainInterfaceHelper(),
    addArguments: new AddArgumentsHelper(),
    addArrayObject: new AddArrayObjectHelper(),
    addBooleanObject: new AddBooleanObjectHelper(),
    addBufferObject: new AddBufferObjectHelper(),
    addErrorObject: new AddErrorObjectHelper(),
    addModules: new AddModulesHelper(),
    addNumberObject: new AddNumberObjectHelper(),
    addObjectObject: new AddObjectObjectHelper(),
    addStringObject: new AddStringObjectHelper(),
    addSymbolObject: new AddSymbolObjectHelper(),
    setGlobalObject: new SetGlobalObjectHelper(),
    getArgument: options => new GetArgumentHelper(options),
    getGlobalProperty: options => new GetGlobalPropertyHelper(options),
    globalProperties: GLOBAL_PROPERTIES
  };
};

class ClassDeclarationCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ClassDeclaration
    }), _temp;
  }

  visitNode(sb, decl, optionsIn) {
    let options = sb.pushValueOptions(sb.noSuperClassOptions(optionsIn));
    const name = sb.scope.add(decl.getNameOrThrow());
    const extendsExpr = decl.getExtends();
    let superClassIn;

    if (extendsExpr != null) {
      superClassIn = sb.scope.addUnique();
      options = sb.superClassOptions(options, superClassIn); // [superClass]

      sb.visit(extendsExpr.getExpression(), options); // []

      sb.scope.set(sb, extendsExpr, options, superClassIn);
    }

    const superClass = superClassIn;
    /* Create constructor function */
    // [farr]

    sb.emitHelper(decl, options, sb.helpers.createConstructArray({
      body: () => {
        // [argsarr]
        const ctorImpl = decl.getConstructors().find(ctor => ctor.isImplementation()); // Default value assignments

        if (ctorImpl != null) {
          // []
          sb.emitHelper(ctorImpl, options, sb.helpers.parameters); // Super call statement
        } else if (superClass != null && extendsExpr != null) {
          // [thisObjectVal, argsarr]
          sb.scope.getThis(sb, decl, options); // [ctor, thisObjectVal, argsarr]

          sb.scope.get(sb, decl, options, superClass); // []

          sb.emitHelper(decl, options, sb.helpers.invokeConstruct()); // Drop the argsarray, we must not use it
        } else {
          // []
          sb.emitOp(decl, 'DROP');
        } // Parameter property assignments
        // Member variable assignments
        // [thisObjectVal]


        sb.scope.getThis(sb, decl, options);
        decl.getInstanceProperties().filter(TypeGuards.isPropertyDeclaration).forEach(property => {
          const initializer = property.getInitializer();

          if (initializer != null) {
            sb.emitOp(decl, 'DUP'); // [prop, thisObjectVal, thisObjectVal]

            sb.emitPushString(initializer, property.getName()); // [init, prop, thisObjectVal, thisObjectVal]

            sb.visit(initializer, options); // [thisObjectVal]

            sb.emitHelper(initializer, options, sb.helpers.setDataPropertyObjectProperty);
          }
        }); // []

        sb.emitOp(decl, 'DROP'); // Constructor statements

        if (ctorImpl != null) {
          sb.visit(ctorImpl.getBodyOrThrow(), options);
        }
      }
    })); // [fobjectVal]

    sb.emitHelper(decl, options, sb.helpers.createFunctionObject({
      property: InternalFunctionProperties.CONSTRUCT
    }));
    /* Create prototype */
    // [fobjectVal, fobjectVal]

    sb.emitOp(decl, 'DUP'); // ['prototype', fobjectVal, fobjectVal]

    sb.emitPushString(decl, 'prototype'); // [fobjectVal, 'prototype', fobjectVal, fobjectVal]

    sb.emitOp(decl, 'OVER'); // [objectVal, fobjectVal, 'prototype', fobjectVal, fobjectVal]

    sb.emitHelper(decl, options, sb.helpers.createObject); // [objectVal, fobjectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

    sb.emitOp(decl, 'TUCK'); // ['constructor', objectVal, fobjectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

    sb.emitPushString(decl, 'constructor'); // [fobjectVal, 'constructor', objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

    sb.emitOp(decl, 'ROT'); // [objectVal, 'prototype', fobjectVal, fobjectVal]

    sb.emitHelper(decl, options, sb.helpers.setDataPropertyObjectProperty);
    decl.getInstanceMethods().forEach(method => {
      if (method.isImplementation()) {
        // [objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]
        sb.emitOp(method, 'DUP'); // [name, objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

        sb.emitPushString(method, method.getName()); // [farr, name, objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

        sb.emitHelper(method, options, sb.helpers.createCallArray); // [methodObjectVal, name, objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

        sb.emitHelper(decl, options, sb.helpers.createFunctionObject({
          property: InternalFunctionProperties.CALL
        })); // [objectVal, 'prototype', fobjectVal, fobjectVal]

        sb.emitHelper(method, options, sb.helpers.setDataPropertyObjectProperty);
      }
    });
    decl.getSetAccessors().filter(accessor => !accessor.isStatic()).forEach(accessor => {
      // [objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]
      sb.emitOp(accessor, 'DUP'); // [name, objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

      sb.emitPushString(accessor, accessor.getName()); // [farr, name, objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

      sb.emitHelper(accessor, options, sb.helpers.createCallArray); // [methodObjectVal, name, objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

      sb.emitHelper(decl, options, sb.helpers.createFunctionObject({
        property: InternalFunctionProperties.CALL
      }));
      const getAccessor = accessor.getGetAccessor();
      const hasGet = getAccessor != null;

      if (getAccessor != null) {
        sb.emitHelper(getAccessor, options, sb.helpers.createCallArray);
        sb.emitHelper(decl, options, sb.helpers.createFunctionObject({
          property: InternalFunctionProperties.CALL
        }));
      } // [objectVal, 'prototype', fobjectVal, fobjectVal]


      sb.emitHelper(accessor, options, sb.helpers.setAccessorPropertyObjectProperty({
        hasSet: true,
        hasGet
      }));
    });
    decl.getGetAccessors().filter(accessor => !accessor.isStatic() && accessor.getSetAccessor() == null).forEach(accessor => {
      // [objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]
      sb.emitOp(accessor, 'DUP'); // [name, objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

      sb.emitPushString(accessor, accessor.getName()); // [farr, name, objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

      sb.emitHelper(accessor, options, sb.helpers.createCallArray); // [methodObjectVal, name, objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

      sb.emitHelper(decl, options, sb.helpers.createFunctionObject({
        property: InternalFunctionProperties.CALL
      })); // [objectVal, 'prototype', fobjectVal, fobjectVal]

      sb.emitHelper(accessor, options, sb.helpers.setAccessorPropertyObjectProperty({
        hasSet: false,
        hasGet: true
      }));
    });
    /* Set superclass prototype */

    if (superClass != null && extendsExpr != null) {
      // [objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]
      sb.emitOp(extendsExpr, 'DUP'); // ['prototype', objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

      sb.emitPushString(extendsExpr, 'prototype'); // [superobjectVal, 'prototype', objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

      sb.scope.get(sb, extendsExpr, options, superClass); // ['prototype', superobjectVal, 'prototype', objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

      sb.emitPushString(extendsExpr, 'prototype'); // [superprototype, 'prototype', objectVal, objectVal, 'prototype', fobjectVal, fobjectVal]

      sb.emitHelper(extendsExpr, options, sb.helpers.getPropertyObjectProperty); // [objectVal, 'prototype', fobjectVal, fobjectVal]

      sb.emitHelper(extendsExpr, options, sb.helpers.setDataPropertyObjectProperty);
    } // [fobjectVal]


    sb.emitHelper(decl, options, sb.helpers.setDataPropertyObjectProperty);

    if (decl.isNamedExport() || decl.isDefaultExport()) {
      // [fobjectVal, fobjectVal]
      sb.emitOp(decl, 'DUP'); // [fobjectVal]

      sb.emitHelper(decl, options, sb.helpers.exportSingle({
        name: decl.isNamedExport() ? decl.getNameOrThrow() : undefined,
        defaultExport: decl.isDefaultExport()
      }));
    } // []


    sb.scope.set(sb, decl, options, name);
  }

}

class EnumDeclarationCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.EnumDeclaration
    }), _temp;
  }

  visitNode(sb, decl, options) {
    sb.reportUnsupported(decl);
  }

}

class EnumMemberCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.EnumMember
    }), _temp;
  }

  visitNode(sb, decl, options) {
    sb.reportUnsupported(decl);
  }

}

class ExportAssignmentCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ExportAssignment
    }), _temp;
  }

  visitNode(sb, node, optionsIn) {
    if (node.isExportEquals()) {
      sb.reportUnsupported(node);
    } else {
      const options = sb.pushValueOptions(optionsIn); // [val]

      sb.visit(node.getExpression(), options); // []

      sb.emitHelper(node, options, sb.helpers.exportSingle({
        defaultExport: true
      }));
    }
  }

}

class ExportDeclarationCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ExportDeclaration
    }), _temp;
  }

  visitNode(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn);

    const getName = namedExport => {
      let name = namedExport.getNameNode().getText();
      const alias = namedExport.getAliasIdentifier();

      if (alias != null) {
        name = alias.getText();
      }

      return name;
    };

    const moduleSpecifier = node.getModuleSpecifierSourceFile(); // [exports]

    sb.emitHelper(node, options, sb.helpers.getCurrentModule);

    if (moduleSpecifier == null) {
      node.getNamedExports().filter(namedExport => namedExport.getLocalTargetDeclarations().some(decl => !TypeGuards.isTypeAliasDeclaration(decl))).forEach(namedExport => {
        // [exports, exports]
        sb.emitOp(node, 'DUP'); // [val, exports, exports]

        sb.scope.get(sb, node, options, namedExport.getNameNode().getText()); // [exports]

        sb.emitHelper(node, options, sb.helpers.export({
          name: getName(namedExport)
        }));
      });
    } else {
      // [moduleExports, exports]
      sb.loadModule(moduleSpecifier);
      node.getNamedExports().filter(namedExport => sb.hasExport(moduleSpecifier, namedExport.getNameNode().getText())).forEach(namedExport => {
        // [exports, moduleExports]
        sb.emitOp(node, 'SWAP'); // [exports, moduleExports, exports]

        sb.emitOp(node, 'TUCK'); // [moduleExports, exports, moduleExports, exports]

        sb.emitOp(node, 'OVER'); // [name, moduleExports, exports, moduleExports, exports]

        sb.emitPushString(node, namedExport.getNameNode().getText()); // [val, exports, moduleExports, exports]

        sb.emitOp(node, 'PICKITEM'); // [moduleExports, exports]

        sb.emitHelper(node, options, sb.helpers.export({
          name: getName(namedExport)
        }));
      }); // [exports]

      sb.emitOp(node, 'DROP');
    } // []


    sb.emitOp(node, 'DROP');
  }

}

class FunctionDeclarationCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.FunctionDeclaration
    }), _temp;
  }

  visitNode(sb, decl, optionsIn) {
    const options = sb.pushValueOptions(optionsIn);
    const name = sb.scope.add(decl.getName()); // [callArray]

    sb.emitHelper(decl, options, sb.helpers.createCallArray); // [callObjectVal]

    sb.emitHelper(decl, options, sb.helpers.createFunctionObject({
      property: InternalFunctionProperties.CALL
    }));

    if (decl.isNamedExport() || decl.isDefaultExport()) {
      // [callObjectVal, callObjectVal]
      sb.emitOp(decl, 'DUP'); // [callObjectVal]

      sb.emitHelper(decl, options, sb.helpers.exportSingle({
        name: decl.isNamedExport() ? decl.getName() : undefined,
        defaultExport: decl.isDefaultExport()
      }));
    } // []


    sb.scope.set(sb, decl, options, name);
  }

}

class ImportDeclarationCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ImportDeclaration
    }), _temp;
  }

  visitNode(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [exports]

    sb.loadModule(node.getModuleSpecifierSourceFileOrThrow());
    const namespaceImport = node.getNamespaceImport();

    if (namespaceImport != null) {
      const name = namespaceImport.getText();
      sb.scope.add(name); // [objectVal]

      sb.emitHelper(node, options, sb.helpers.createPropertyObject); // []

      sb.scope.set(sb, node, options, name);
    } else {
      const defaultImport = node.getDefaultImport();
      const namedImports = node.getNamedImports().filter(namedImport => sb.hasExport(namedImport.getImportDeclaration().getModuleSpecifierSourceFileOrThrow(), namedImport.getName()));

      if (defaultImport != null) {
        if (namedImports.length > 0) {
          // [exports, exports]
          sb.emitOp(node, 'DUP');
        } // ['default', exports]


        sb.emitPushString(node, 'default'); // [val]

        sb.emitOp(node, 'PICKITEM');
        const name = defaultImport.getText();
        sb.scope.add(name); // []

        sb.scope.set(sb, node, options, name);
      }

      if (namedImports.length > 0) {
        for (const namedImport of namedImports) {
          // [exports, exports]
          sb.emitOp(node, 'DUP'); // [name, exports, exports]

          sb.emitPushString(node, namedImport.getName()); // [val, exports]

          sb.emitOp(node, 'PICKITEM');
          let name = namedImport.getName();
          const alias = namedImport.getAliasIdentifier();

          if (alias != null) {
            name = alias.getText();
          }

          sb.scope.add(name); // [exports]

          sb.scope.set(sb, node, options, name);
        }

        sb.emitOp(node, 'DROP');
      }
    }
  }

}

class TypeAliasDeclarationCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.TypeAliasDeclaration
    }), _temp;
  }

  visitNode(sb, node, optionsIn) {// do nothing
  }

}

class VariableDeclarationCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.VariableDeclaration
    }), _temp;
  }

  visitNode(sb, node, options) {
    const name = sb.scope.add(node.getName());
    const expr = node.getInitializer();

    if (expr != null) {
      sb.visit(expr, sb.pushValueOptions(options));
      sb.scope.set(sb, node, options, name);
    }
  }

}

class VariableDeclarationListCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.VariableDeclarationList
    }), _temp;
  }

  visitNode(sb, node, options) {
    node.getDeclarations().forEach(decl => {
      sb.visit(decl, options);
    });
  }

}

var declarations = [ClassDeclarationCompiler, EnumDeclarationCompiler, EnumMemberCompiler, ExportAssignmentCompiler, ExportDeclarationCompiler, FunctionDeclarationCompiler, ImportDeclarationCompiler, TypeAliasDeclarationCompiler, VariableDeclarationCompiler, VariableDeclarationListCompiler];

class DecoratorCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.Decorator
    }), _temp;
  }

  visitNode(sb, decl, options) {
    sb.reportUnsupported(decl);
  }

}

var decorator = [DecoratorCompiler];

class ArrayLiteralExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ArrayLiteralExpression
    }), _temp;
  }

  visitNode(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn);
    const elements = [...node.getElements()].reverse();

    for (const element of elements) {
      sb.visit(element, options);
    } // [length, ...vals]


    sb.emitPushInt(node, elements.length); // [valArr]

    sb.emitOp(node, 'PACK'); // [arrayObjectVal]

    sb.emitHelper(node, options, sb.helpers.wrapArray);

    if (!optionsIn.pushValue) {
      sb.emitOp(node, 'DROP');
    }
  }

}

class ArrowFunctionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ArrowFunction
    }), _temp;
  }

  visitNode(sb, expr, options) {
    if (options.pushValue) {
      // [this]
      sb.scope.getThis(sb, expr, options); // [callArray, this]

      sb.emitHelper(expr, options, sb.helpers.createCallArray); // [callArray]

      sb.emitHelper(expr, options, sb.helpers.bindFunctionThis({
        overwrite: true
      })); // [callObjectVal]

      sb.emitHelper(expr, options, sb.helpers.createFunctionObject({
        property: InternalFunctionProperties.CALL
      }));
    }
  }

}

class AsExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.AsExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    const type = sb.getType(expr);

    if (options.cast != null && isAnyType(type)) {
      sb.visit(expr.getExpression(), options);
    } else {
      sb.visit(expr.getExpression(), sb.castOptions(options, type));
    }
  }

}

class AwaitExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.AwaitExpression
    }), _temp;
  }

  visitNode(sb, expr) {
    sb.reportUnsupported(expr);
  }

}

class BinaryExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.BinaryExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    const kind = expr.getOperatorToken().getKind();

    switch (kind) {
      case SyntaxKind.EqualsToken:
      case SyntaxKind.PlusEqualsToken:
      case SyntaxKind.MinusEqualsToken:
      case SyntaxKind.AsteriskAsteriskEqualsToken:
      case SyntaxKind.AsteriskEqualsToken:
      case SyntaxKind.SlashEqualsToken:
      case SyntaxKind.PercentEqualsToken:
      case SyntaxKind.AmpersandEqualsToken:
      case SyntaxKind.BarEqualsToken:
      case SyntaxKind.CaretEqualsToken:
      case SyntaxKind.LessThanLessThanEqualsToken:
      case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
      case SyntaxKind.GreaterThanGreaterThanEqualsToken:
        this.visitAssignmentOperator(sb, kind, expr, options);
        break;

      case SyntaxKind.AsteriskToken:
      case SyntaxKind.SlashToken:
      case SyntaxKind.PercentToken:
      case SyntaxKind.PlusToken:
      case SyntaxKind.MinusToken:
      case SyntaxKind.GreaterThanGreaterThanToken:
      case SyntaxKind.LessThanLessThanToken:
      case SyntaxKind.LessThanToken:
      case SyntaxKind.LessThanEqualsToken:
      case SyntaxKind.GreaterThanToken:
      case SyntaxKind.GreaterThanEqualsToken:
      case SyntaxKind.ExclamationEqualsToken:
      case SyntaxKind.EqualsEqualsToken:
      case SyntaxKind.AmpersandToken:
      case SyntaxKind.BarToken:
      case SyntaxKind.CaretToken:
      case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
      case SyntaxKind.InKeyword:
      case SyntaxKind.InstanceOfKeyword:
      case SyntaxKind.CommaToken:
      case SyntaxKind.AsteriskAsteriskToken:
      case SyntaxKind.EqualsEqualsEqualsToken:
      case SyntaxKind.ExclamationEqualsEqualsToken:
        this.visitExpressionOperator(sb, kind, expr, options);
        break;

      case SyntaxKind.AmpersandAmpersandToken:
      case SyntaxKind.BarBarToken:
        this.visitLogicalExpressionOperator(sb, kind, expr, options);
        break;

      default:
        sb.assertUnreachable(kind);
    }
  }

  visitAssignmentOperator(sb, kind, expr, options) {
    const left = expr.getLeft();
    const right = expr.getRight();
    const token = expr.getOperatorToken();
    const pushValueOptions = sb.pushValueOptions(options);

    switch (kind) {
      case SyntaxKind.EqualsToken:
        sb.visit(expr.getRight(), pushValueOptions);
        break;

      case SyntaxKind.PlusEqualsToken:
        this.visitExpressionOperatorBase(sb, token, SyntaxKind.PlusToken, left, right, pushValueOptions);
        break;

      case SyntaxKind.MinusEqualsToken:
        this.visitExpressionOperatorBase(sb, token, SyntaxKind.MinusToken, left, right, pushValueOptions);
        break;

      case SyntaxKind.AsteriskAsteriskEqualsToken:
        this.visitExpressionOperatorBase(sb, token, SyntaxKind.AsteriskAsteriskToken, left, right, pushValueOptions);
        break;

      case SyntaxKind.AsteriskEqualsToken:
        this.visitExpressionOperatorBase(sb, token, SyntaxKind.AsteriskToken, left, right, pushValueOptions);
        break;

      case SyntaxKind.SlashEqualsToken:
        this.visitExpressionOperatorBase(sb, token, SyntaxKind.SlashToken, left, right, pushValueOptions);
        break;

      case SyntaxKind.PercentEqualsToken:
        this.visitExpressionOperatorBase(sb, token, SyntaxKind.PercentToken, left, right, pushValueOptions);
        break;

      case SyntaxKind.AmpersandEqualsToken:
        this.visitExpressionOperatorBase(sb, token, SyntaxKind.AmpersandToken, left, right, pushValueOptions);
        break;

      case SyntaxKind.BarEqualsToken:
        this.visitExpressionOperatorBase(sb, token, SyntaxKind.BarToken, left, right, pushValueOptions);
        break;

      case SyntaxKind.CaretEqualsToken:
        this.visitExpressionOperatorBase(sb, token, SyntaxKind.CaretToken, left, right, pushValueOptions);
        break;

      case SyntaxKind.LessThanLessThanEqualsToken:
        this.visitExpressionOperatorBase(sb, token, SyntaxKind.LessThanLessThanToken, left, right, pushValueOptions);
        break;

      case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
        this.visitExpressionOperatorBase(sb, token, SyntaxKind.GreaterThanGreaterThanGreaterThanToken, left, right, pushValueOptions);
        break;

      case SyntaxKind.GreaterThanGreaterThanEqualsToken:
        this.visitExpressionOperatorBase(sb, token, SyntaxKind.GreaterThanGreaterThanToken, left, right, pushValueOptions);
        break;

      default:
        sb.assertUnreachable(kind);
    }

    sb.visit(expr.getLeft(), sb.setValueOptions(options));
  }

  visitExpressionOperator(sb, kind, expr, options) {
    this.visitExpressionOperatorBase(sb, expr.getOperatorToken(), kind, expr.getLeft(), expr.getRight(), options);
  }

  visitLogicalExpressionOperator(sb, kind, expr, options) {
    this.visitLogicalExpressionOperatorBase(sb, expr.getOperatorToken(), kind, expr.getLeft(), expr.getRight(), options);
  }

  visitExpressionOperatorBase(sb, node, kind, left, right, options) {
    if (!options.pushValue) {
      sb.visit(left, options);
      sb.visit(right, options);
      return;
    }

    const visit = (leftHelper, rightHelper) => {
      sb.visit(left, options);
      sb.emitHelper(left, options, leftHelper({
        type: sb.getType(left)
      }));
      sb.visit(right, options);
      sb.emitHelper(right, options, (rightHelper || leftHelper)({
        type: sb.getType(right)
      }));
    };

    const visitNumeric = () => visit(sb.helpers.toNumber);

    const leftType = sb.getType(left);
    const rightType = sb.getType(right);
    const isBinaryNumeric = isOnlyNumber(leftType) && isOnlyNumber(rightType);

    switch (kind) {
      case SyntaxKind.AsteriskToken:
        visitNumeric();
        sb.emitOp(node, 'MUL');
        sb.emitHelper(node, options, sb.helpers.createNumber);
        break;

      case SyntaxKind.SlashToken:
        visitNumeric();
        sb.emitOp(node, 'DIV');
        sb.emitHelper(node, options, sb.helpers.createNumber);
        break;

      case SyntaxKind.PercentToken:
        visitNumeric();
        sb.emitOp(node, 'MOD');
        sb.emitHelper(node, options, sb.helpers.createNumber);
        break;

      case SyntaxKind.PlusToken:
        if (isBinaryNumeric) {
          visitNumeric();
          sb.emitOp(node, 'ADD');
          sb.emitHelper(node, options, sb.helpers.createNumber);
        } else if (isOnlyString(leftType) && isOnlyString(rightType)) {
          visit(() => sb.helpers.getString);
          sb.emitOp(node, 'CAT');
          sb.emitHelper(node, options, sb.helpers.createString);
        } else if (isOnlyString(leftType)) {
          visit(() => sb.helpers.getString, sb.helpers.toString);
          sb.emitOp(node, 'CAT');
          sb.emitHelper(node, options, sb.helpers.createString);
        } else if (isOnlyString(rightType)) {
          visit(sb.helpers.toString, () => sb.helpers.getString);
          sb.emitOp(node, 'CAT');
          sb.emitHelper(node, options, sb.helpers.createString);
        } else {
          // TODO: Add preferredType
          // [right, left]
          visit(sb.helpers.toPrimitive); // [left, right]

          sb.emitOp(node, 'SWAP'); // [left, right, left]

          sb.emitOp(node, 'TUCK'); // [right, left, right, left]

          sb.emitOp(node, 'TUCK'); // [isString, left, right, left]

          sb.emitHelper(node, options, sb.helpers.isString); // [left, isString, right, left]

          sb.emitOp(node, 'SWAP'); // [isString, isString, right, left]

          sb.emitHelper(node, options, sb.helpers.isString);
          sb.emitHelper(node, options, sb.helpers.if({
            condition: () => {
              // [isEitherString, right, left]
              sb.emitOp(node, 'BOOLOR');
            },
            whenTrue: () => {
              // [string0, left]
              sb.emitHelper(node, options, sb.helpers.toString({
                type: sb.getType(right)
              })); // [left, string0]

              sb.emitOp(node, 'SWAP'); // [string1, string0]

              sb.emitHelper(node, options, sb.helpers.toString({
                type: sb.getType(left)
              })); // [string0, string1]

              sb.emitOp(node, 'SWAP'); // [string]

              sb.emitOp(node, 'CAT'); // [string]

              sb.emitHelper(node, options, sb.helpers.createString);
            },
            whenFalse: () => {
              // [number0, left]
              sb.emitHelper(node, options, sb.helpers.toNumber({
                type: sb.getType(right)
              })); // [left, number0]

              sb.emitOp(node, 'SWAP'); // [number1, number0]

              sb.emitHelper(node, options, sb.helpers.toNumber({
                type: sb.getType(left)
              })); // [number0, number1]

              sb.emitOp(node, 'SWAP'); // [number]

              sb.emitOp(node, 'ADD'); // [number]

              sb.emitHelper(node, options, sb.helpers.createNumber);
            }
          }));
        }

        break;

      case SyntaxKind.MinusToken:
        visitNumeric();
        sb.emitOp(node, 'SUB');
        sb.emitHelper(node, options, sb.helpers.createNumber);
        break;
      // TODO: Should we try to make these match the js semantics?

      case SyntaxKind.GreaterThanGreaterThanToken:
        visitNumeric();
        sb.emitOp(node, 'SHR');
        sb.emitHelper(node, options, sb.helpers.createNumber);
        break;

      case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
        visitNumeric();
        sb.emitOp(node, 'SHR');
        sb.emitHelper(node, options, sb.helpers.createNumber);
        break;

      case SyntaxKind.LessThanLessThanToken:
        visitNumeric();
        sb.emitOp(node, 'SHL');
        sb.emitHelper(node, options, sb.helpers.createNumber);
        break;

      case SyntaxKind.LessThanToken:
        sb.emitHelper(node, options, sb.helpers.lessThan({
          leftFirst: true,
          left,
          right
        }));
        sb.emitHelper(node, options, sb.helpers.createBoolean);
        break;

      case SyntaxKind.LessThanEqualsToken:
        sb.emitHelper(node, options, sb.helpers.lessThan({
          leftFirst: false,
          left: right,
          right: left
        }));
        sb.emitOp(node, 'NOT');
        sb.emitHelper(node, options, sb.helpers.createBoolean);
        break;

      case SyntaxKind.GreaterThanToken:
        sb.emitHelper(node, options, sb.helpers.lessThan({
          leftFirst: false,
          left: right,
          right: left
        }));
        sb.emitHelper(node, options, sb.helpers.createBoolean);
        break;

      case SyntaxKind.GreaterThanEqualsToken:
        sb.emitHelper(node, options, sb.helpers.lessThan({
          leftFirst: true,
          left,
          right
        }));
        sb.emitOp(node, 'NOT');
        sb.emitHelper(node, options, sb.helpers.createBoolean);
        break;

      case SyntaxKind.ExclamationEqualsToken:
        sb.emitHelper(node, options, sb.helpers.equalsEquals({
          left,
          right
        }));
        sb.emitOp(node, 'NOT');
        sb.emitHelper(node, options, sb.helpers.createBoolean);
        break;

      case SyntaxKind.EqualsEqualsToken:
        sb.emitHelper(node, options, sb.helpers.equalsEquals({
          left,
          right
        }));
        sb.emitHelper(node, options, sb.helpers.createBoolean);
        break;

      case SyntaxKind.AmpersandToken:
        visitNumeric();
        sb.emitOp(node, 'AND');
        sb.emitHelper(node, options, sb.helpers.createNumber);
        break;

      case SyntaxKind.BarToken:
        visitNumeric();
        sb.emitOp(node, 'OR');
        sb.emitHelper(node, options, sb.helpers.createNumber);
        break;

      case SyntaxKind.CaretToken:
        visitNumeric();
        sb.emitOp(node, 'XOR');
        sb.emitHelper(node, options, sb.helpers.createNumber);
        break;

      case SyntaxKind.InKeyword:
        // TODO: Implement me
        sb.reportUnsupported(node);
        break;

      case SyntaxKind.InstanceOfKeyword:
        // TODO: Implement me
        sb.reportUnsupported(node);
        break;

      case SyntaxKind.CommaToken:
        sb.emitOp(node, 'DROP');
        break;

      case SyntaxKind.AsteriskAsteriskToken:
        // TODO: Implement me
        sb.reportUnsupported(node);
        break;

      case SyntaxKind.EqualsEqualsEqualsToken:
        sb.emitHelper(node, options, sb.helpers.equalsEqualsEquals({
          left,
          right
        }));
        sb.emitHelper(node, options, sb.helpers.createBoolean);
        break;

      case SyntaxKind.ExclamationEqualsEqualsToken:
        sb.emitHelper(node, options, sb.helpers.equalsEqualsEquals({
          left,
          right
        }));
        sb.emitOp(node, 'NOT');
        sb.emitHelper(node, options, sb.helpers.createBoolean);
        break;

      default:
        sb.assertUnreachable(kind);
    }
  }

  visitLogicalExpressionOperatorBase(sb, node, kind, left, right, options) {
    switch (kind) {
      case SyntaxKind.AmpersandAmpersandToken:
        {
          sb.emitHelper(node, options, sb.helpers.if({
            condition: () => {
              // [left]
              sb.visit(left, sb.pushValueOptions(options));

              if (options.pushValue) {
                // [left, left]
                sb.emitOp(left, 'DUP');
              } // [leftBoolean, ?left]


              sb.emitHelper(left, sb.pushValueOptions(options), sb.helpers.toBoolean({
                type: sb.getType(left)
              }));
            },
            whenTrue: () => {
              if (options.pushValue) {
                sb.emitOp(node, 'DROP');
              }

              sb.visit(right, options);
            }
          }));
          break;
        }

      case SyntaxKind.BarBarToken:
        {
          sb.emitHelper(node, options, sb.helpers.if({
            condition: () => {
              // [left]
              sb.visit(left, sb.pushValueOptions(options));

              if (options.pushValue) {
                // [left, left]
                sb.emitOp(left, 'DUP');
              } // [leftBoolean, ?left]


              sb.emitHelper(left, sb.pushValueOptions(options), sb.helpers.toBoolean({
                type: sb.getType(left)
              }));
            },
            whenFalse: () => {
              if (options.pushValue) {
                sb.emitOp(node, 'DROP');
              }

              sb.visit(right, options);
            }
          }));
          break;
        }

      default:
        sb.assertUnreachable(kind);
    }
  }

}

class BooleanLiteralCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "value", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    }), _temp;
  }

  visitNode(sb, expr, options) {
    if (options.pushValue) {
      sb.emitPushBoolean(expr, this.value);
      sb.emitHelper(expr, options, sb.helpers.createBoolean);
    }
  }

}
class TrueBooleanLiteralCompiler extends BooleanLiteralCompiler {
  constructor(...args) {
    var _temp2;

    return _temp2 = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.TrueKeyword
    }), Object.defineProperty(this, "value", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: true
    }), _temp2;
  }

}
class FalseBooleanLiteralCompiler extends BooleanLiteralCompiler {
  constructor(...args) {
    var _temp3;

    return _temp3 = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.FalseKeyword
    }), Object.defineProperty(this, "value", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: false
    }), _temp3;
  }

}

class SimpleSysCallType {
  constructor() {
    Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
  }

  toSignature() {
    return this.name;
  }

}

class VoidClass extends SimpleSysCallType {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 'void'
    }), _temp;
  }

  isOnlyType(sb, node, type) {
    return false;
  }

  isType(sb, node, type) {
    return false;
  }

  isRuntimeType(sb, node, options) {
    throw new Error('Should not check void at runtime');
  }

  handleArgument(sb, node, options, type) {
    throw new Error('void should not be an argument');
  }

  handleResult(sb, node, options, type, native = false) {
    sb.emitHelper(node, options, sb.helpers.createUndefined);
  }

}

const VoidValue = new VoidClass();

class NumberClass extends SimpleSysCallType {
  constructor(...args) {
    var _temp2;

    return _temp2 = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 'number'
    }), _temp2;
  }

  isOnlyType(sb, node, type) {
    return isOnlyNumber(type);
  }

  isType(sb, node, type) {
    return isNumber(type);
  }

  isRuntimeType(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.isNumber);
  }

  handleArgument(sb, node, options, type, native = false) {
    if (!native) {
      sb.emitHelper(node, options, sb.helpers.getNumber);
    }
  }

  handleResult(sb, node, options, type, native = false) {
    if (!native) {
      sb.emitHelper(node, options, sb.helpers.createNumber);
    }
  }

}

const NumberValue = new NumberClass();

class StringClass extends SimpleSysCallType {
  constructor(...args) {
    var _temp3;

    return _temp3 = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 'string'
    }), _temp3;
  }

  isOnlyType(sb, node, type) {
    return isOnlyString(type);
  }

  isType(sb, node, type) {
    return isString(type);
  }

  isRuntimeType(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.isString);
  }

  handleArgument(sb, node, options, type, native = false) {
    if (!native) {
      sb.emitHelper(node, options, sb.helpers.getString);
    }
  }

  handleResult(sb, node, options, type, native = false) {
    if (!native) {
      sb.emitHelper(node, options, sb.helpers.createString);
    }
  }

}

const StringValue = new StringClass();

class BooleanClass extends SimpleSysCallType {
  constructor(...args) {
    var _temp4;

    return _temp4 = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 'boolean'
    }), _temp4;
  }

  isOnlyType(sb, node, type) {
    return isOnlyBoolean(type);
  }

  isType(sb, node, type) {
    return isBoolean(type);
  }

  isRuntimeType(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.isBoolean);
  }

  handleArgument(sb, node, options, type, native = false) {
    if (!native) {
      sb.emitHelper(node, options, sb.helpers.getBoolean);
    }
  }

  handleResult(sb, node, options, type, native = false) {
    if (!native) {
      sb.emitHelper(node, options, sb.helpers.createBoolean);
    }
  }

}

const BooleanValue = new BooleanClass();

class BlockchainInterface extends SimpleSysCallType {
  constructor(name) {
    super();
    Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.name = name;
  }

  isOnlyType(sb, node, type) {
    return sb.isOnlyGlobal(node, type, this.name);
  }

  isType(sb, node, type) {
    return sb.isGlobal(node, type, this.name);
  }

  isRuntimeType(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.isBlockchainInterface({
      name: this.name
    }));
  }

  handleArgument(sb, node, options, type, native = false) {
    if (native) {
      throw new Error('BlockchainInterface should not be serialized/deserialized from storage');
    }

    sb.emitHelper(node, options, sb.helpers.unwrapBlockchainInterface);
  }

  handleResult(sb, node, options, type, native = false) {
    if (native) {
      throw new Error('BlockchainInterface should not be serialized/deserialized from storage');
    }

    sb.emitHelper(node, options, sb.helpers.wrapBlockchainInterface({
      name: this.name
    }));
  }

}

const AccountValue = new BlockchainInterface('AccountBase');
const AssetValue = new BlockchainInterface('AssetBase');
const AttributeValue = new BlockchainInterface('AttributeBase');
const BlockValue = new BlockchainInterface('BlockBase');
const ContractValue = new BlockchainInterface('ContractBase');
const HeaderValue = new BlockchainInterface('HeaderBase');
const InputValue = new BlockchainInterface('InputBase');
const OutputValue = new BlockchainInterface('OutputBase');
const TransactionValue = new BlockchainInterface('TransactionBase');
const ValidatorValue = new BlockchainInterface('ValidatorBase');
const StorageContextValue = new BlockchainInterface('StorageContextBase');
const StorageIteratorValue = new BlockchainInterface('StorageIteratorBase');
const BLOCKCHAIN_INTERFACES = [AccountValue, AssetValue, AttributeValue, BlockValue, ContractValue, HeaderValue, InputValue, OutputValue, TransactionValue, ValidatorValue, StorageContextValue, StorageIteratorValue].map(value => value.name);

class BufferClass extends SimpleSysCallType {
  constructor(...args) {
    var _temp5;

    return _temp5 = super(...args), Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 'Buffer'
    }), _temp5;
  }

  isOnlyType(sb, node, type) {
    return sb.isOnlyGlobal(node, type, this.name);
  }

  isType(sb, node, type) {
    return sb.isGlobal(node, type, this.name);
  }

  isRuntimeType(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.getGlobalProperty({
      property: this.name
    }));
    sb.emitHelper(node, options, sb.helpers.instanceof);
  }

  handleArgument(sb, node, options, type, native = false) {
    sb.emitHelper(node, options, sb.helpers.unwrapBuffer);

    if (native) {
      serializeType(sb, node, options, SerializableType.Buffer);
    }
  }

  handleResult(sb, node, options, type, native = false) {
    if (native) {
      deserializeType(sb, node, options);
    }

    sb.emitHelper(node, options, sb.helpers.wrapBuffer);
  }

}

const BufferValue = new BufferClass();

class ArrayValue extends SimpleSysCallType {
  constructor(valueType) {
    super();
    Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "valueType", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.name = `Array<${valueType.name}>`;
    this.valueType = typeof valueType === 'function' ? valueType : () => valueType;
  }

  isOnlyType(sb, node, type) {
    return isOnlyArray(type) && !isOnlyTuple(type) && type != null && this.valueType().isOnlyType(sb, node, type.getArrayType());
  }

  isType(sb, node, type) {
    return isArray(type) && !isTuple(type) && type != null && this.valueType().isType(sb, node, type.getArrayType());
  }

  isRuntimeType(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.getGlobalProperty({
      property: 'Array'
    }));
    sb.emitHelper(node, options, sb.helpers.instanceof);
  }

  handleArgument(sb, node, options, type, native = false) {
    sb.emitHelper(node, options, sb.helpers.unwrapArray);
    sb.emitHelper(node, options, sb.helpers.arrMap({
      map: () => {
        this.valueType().handleArgument(sb, node, options, type == null ? type : type.getArrayType(), native);
      }
    }));

    if (native) {
      serializeType(sb, node, options, SerializableType.Array);
    }
  }

  handleResult(sb, node, options, type, native = false) {
    if (native) {
      deserializeType(sb, node, options);
    }

    sb.emitHelper(node, options, sb.helpers.arrMap({
      map: () => {
        this.valueType().handleResult(sb, node, options, type == null ? type : type.getArrayType(), native);
      }
    }));
    sb.emitHelper(node, options, sb.helpers.wrapArray);
  }

}

class TupleValue extends SimpleSysCallType {
  constructor(valueType) {
    super();
    Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "valueType", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.name = 'any';
    this.valueType = typeof valueType === 'function' ? valueType : () => valueType;
  }

  isOnlyType(sb, node, type) {
    return isOnlyTuple(type) && type != null && type.getTupleElements().every(tupleType => this.valueType().isOnlyType(sb, node, tupleType));
  }

  isType(sb, node, type) {
    return isTuple(type) && type != null && type.getTupleElements().every(tupleType => this.valueType().isType(sb, node, tupleType));
  }

  isRuntimeType(sb, node, options) {
    sb.emitHelper(node, options, sb.helpers.getGlobalProperty({
      property: 'Array'
    }));
    sb.emitHelper(node, options, sb.helpers.instanceof);
  }

  handleArgument(sb, node, options, type, native = false) {
    throw new Error('Not Implemented');
  }

  handleResult(sb, node, options, type, native = false) {
    if (type == null) {
      sb.reportError(node, 'Syscall return type must be explicitly casted to expected type.', DiagnosticCode.UNKNOWN_TYPE);
    } else {
      // [length, ...value]
      sb.emitOp(node, 'UNPACK'); // [...value]

      sb.emitOp(node, 'DROP'); // [0, ...value]

      sb.emitPushInt(node, 0); // [arr, ...value]

      sb.emitOp(node, 'NEWARRAY');

      for (const tupleType of type.getTupleElements()) {
        // [arr, arr, ...value]
        sb.emitOp(node, 'DUP'); // [value, arr, arr, ...value]

        sb.emitOp(node, 'ROT'); // [val, arr, arr, ...value]

        this.valueType().handleResult(sb, node, options, tupleType, native); // [arr, ...value]

        sb.emitOp(node, 'APPEND');
      } // [arrayObjectValue]


      sb.emitHelper(node, options, sb.helpers.wrapArray);
    }
  }

}

class UnionValue extends SimpleSysCallType {
  constructor(valueTypes) {
    super();
    Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "valueTypes", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.name = valueTypes.map(valueType => valueType.name).join(' | ');
    this.valueTypes = valueTypes;
  }

  isOnlyType(sb, node, type) {
    return isUnion(type) && type != null && type.getUnionTypes().every(unionType => this.valueTypes.some(valueType => valueType.isOnlyType(sb, node, unionType))) || !isUnion(type) && type != null && this.valueTypes.some(valueType => valueType.isOnlyType(sb, node, type));
  }

  isType(sb, node, type) {
    return isUnion(type) && type != null && type.getUnionTypes().every(unionType => this.valueTypes.some(valueType => valueType.isType(sb, node, unionType))) || !isUnion(type) && type != null && this.valueTypes.some(valueType => valueType.isType(sb, node, type));
  }

  isRuntimeType(sb, node, options) {
    throw new Error('Union should not be checked at runtime');
  }

  handleArgument(sb, node, options, type, native = false) {
    const foundType = this.valueTypes.find(valueType => valueType.isOnlyType(sb, node, type));

    if (foundType == null) {
      if (native) {
        sb.emitHelper(node, options, sb.helpers.genericSerialize);
      } else {
        sb.emitHelper(node, options, sb.helpers.forType({
          types: this.valueTypes.map(valueType => ({
            isType: innerType => valueType.isType(sb, node, innerType),
            isRuntimeType: innerOptions => valueType.isRuntimeType(sb, node, innerOptions),
            process: innerOptions => valueType.handleArgument(sb, node, innerOptions, type, native)
          }))
        }));
      }
    } else {
      foundType.handleArgument(sb, node, options, type, native);
    }
  }

  handleResult(sb, node, options, type, native = false) {
    const foundType = this.valueTypes.find(valueType => valueType.isOnlyType(sb, node, type));

    if (foundType == null) {
      if (native) {
        sb.emitHelper(node, options, sb.helpers.genericDeserialize);
      } else {
        sb.reportError(node, 'Syscall return type must be explicitly casted to expected type.', DiagnosticCode.UNKNOWN_TYPE);
      }
    } else {
      foundType.handleResult(sb, node, options, type, native);
    }
  }

}

const StorageKey = new UnionValue([BufferValue, StringValue]);
const StorageValue = new UnionValue([BufferValue, NumberValue, StringValue, BooleanValue]);
class TypeAlias {
  constructor(name, declaration) {
    this.name = name;
    this.declaration = declaration;
    this.name = name;
    this.declaration = declaration;
  }

  toSignature() {
    return this.name;
  }

  toDeclaration() {
    return this.declaration;
  }

}
const SerializableValueArrayAlias = new TypeAlias('SerializableValueArray', 'interface SerializableValueArray extends Array<SerializableValue> { }');
const SerializableValueObjectAlias = new TypeAlias('SerializableValueObject', `interface SerializableValueObject {
  [key: string]: SerializableValue;
}`);
const SerializableValueAlias = new TypeAlias('SerializableValue', 'type SerializableValue = undefined | number | string | boolean | Buffer | ' + `${SerializableValueArrayAlias.toSignature()} | ${SerializableValueObjectAlias.toSignature()}`);

class Serializable extends SimpleSysCallType {
  constructor(shouldSerialize = false, shouldHandleNull = false) {
    super();
    this.shouldSerialize = shouldSerialize;
    this.shouldHandleNull = shouldHandleNull;
    Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.name = SerializableValueAlias.toSignature();
  }

  get type() {
    return new UnionValue([BooleanValue, StringValue, NumberValue, BufferValue, new ArrayValue(() => this.type)]);
  }

  toDeclaration() {
    return SerializableValueAlias.toDeclaration();
  }

  isOnlyType(sb, node, type) {
    return this.type.isOnlyType(sb, node, type);
  }

  isType(sb, node, type) {
    return this.type.isType(sb, node, type);
  }

  isRuntimeType(sb, node, options) {
    this.type.isRuntimeType(sb, node, options);
  }

  handleArgument(sb, node, options, type) {
    this.type.handleArgument(sb, node, options, type, true);

    if (this.shouldSerialize) {
      sb.emitSysCall(node, 'Neo.Runtime.Serialize');
    }
  }

  handleResult(sb, node, options, typeIn) {
    let type = typeIn;

    if (type != null && this.shouldHandleNull && type.isUnionType() && type.getUnionTypes().some(unionType => isOnlyUndefined(unionType))) {
      type = type.getUnionTypes().find(unionType => !isOnlyUndefined(unionType));
    }

    const handleValue = () => {
      if (this.shouldSerialize) {
        sb.emitSysCall(node, 'Neo.Runtime.Deserialize');
      }

      this.type.handleResult(sb, node, options, type, true);
    };

    if (this.shouldHandleNull) {
      sb.emitHelper(node, options, sb.helpers.if({
        condition: () => {
          // [value, value]
          sb.emitOp(node, 'DUP'); // [length, value]

          sb.emitOp(node, 'SIZE'); // [0, length, value]

          sb.emitPushInt(node, 0); // [length === 0, value]

          sb.emitOp(node, 'NUMEQUAL');
        },
        whenTrue: () => {
          // []
          sb.emitOp(node, 'DROP'); // [val]

          sb.emitHelper(node, options, sb.helpers.createUndefined);
        },
        whenFalse: () => {
          handleValue();
        }
      }));
    } else {
      handleValue();
    }
  }

  addSerialize() {
    return new Serializable(true, this.shouldHandleNull);
  }

  handleNull() {
    return new Serializable(this.shouldSerialize, true);
  }

}

const SerializableValue = new Serializable();
class SysCallArgument {
  constructor(name, type) {
    Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "type", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.name = name;
    this.type = type;
  }

  handleArgument(sb, node, options, type) {
    this.type.handleArgument(sb, node, options, type);
  }

  toSignature() {
    return `${this.name}: ${this.type.toSignature()}`;
  }

}
class SimpleSysCall {
  constructor(options) {
    Object.defineProperty(this, "name", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "args", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "returnType", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.name = options.name;
    this.args = options.args || [];
    this.returnType = options.returnType || VoidValue;
  }

  toDeclaration() {
    const args = [`name: '${this.name}'`].concat(this.args.map(arg => arg.toSignature()));
    return `function syscall(${args.join(', ')}): ${this.returnType.toSignature()};`;
  }

  handleCall(sb, node, optionsIn) {
    const options = sb.pushValueOptions(sb.noCastOptions(optionsIn));
    const args = [...node.getArguments().slice(1)].reverse();

    for (const [idx, arg] of args.entries()) {
      sb.visit(arg, options);
      this.args[args.length - idx - 1].handleArgument(sb, arg, options, sb.getType(arg));
    }

    sb.emitSysCall(node, this.name);

    if (optionsIn.pushValue) {
      this.returnType.handleResult(sb, node, options, optionsIn.cast);
    } else if (this.returnType !== VoidValue) {
      sb.emitOp(node, 'DROP');
    }
  }

}
const SYSCALLS = {
  'Neo.Runtime.GetTrigger': new SimpleSysCall({
    name: 'Neo.Runtime.GetTrigger',
    returnType: NumberValue
  }),
  'Neo.Runtime.CheckWitness': new SimpleSysCall({
    name: 'Neo.Runtime.CheckWitness',
    args: [new SysCallArgument('witness', BufferValue)],
    returnType: BooleanValue
  }),
  'Neo.Runtime.Notify': (() => {
    const name = 'Neo.Runtime.Notify';
    const valueType = new UnionValue([BufferValue, NumberValue, StringValue, BooleanValue]);
    const arrayType = new ArrayValue(valueType);
    const returnType = VoidValue;
    return {
      name,

      toDeclaration() {
        const sig = arrayType.toSignature();
        return `function syscall(name: '${name}', ...args: ${sig}): ${returnType.toSignature()};`;
      },

      handleCall(sb, node, optionsIn) {
        const options = sb.pushValueOptions(sb.noCastOptions(optionsIn));
        const args = [...node.getArguments().slice(1)].reverse();

        for (const arg of args) {
          sb.visit(arg, options);
          valueType.handleArgument(sb, arg, options, sb.getType(arg));
        } // [length, ...]


        sb.emitPushInt(node, args.length); // [arr]

        sb.emitOp(node, 'PACK');
        sb.emitSysCall(node, name);

        if (optionsIn.pushValue) {
          returnType.handleResult(sb, node, options, optionsIn.cast);
        }
      }

    };
  })(),
  'Neo.Runtime.Log': new SimpleSysCall({
    name: 'Neo.Runtime.Log',
    args: [new SysCallArgument('value', StringValue)]
  }),
  'Neo.Runtime.GetTime': new SimpleSysCall({
    name: 'Neo.Runtime.GetTime',
    returnType: NumberValue
  }),
  'Neo.Runtime.Serialize': new SimpleSysCall({
    name: 'Neo.Runtime.Serialize',
    args: [new SysCallArgument('value', SerializableValue)],
    returnType: BufferValue
  }),
  'Neo.Runtime.Deserialize': new SimpleSysCall({
    name: 'Neo.Runtime.Deserialize',
    args: [new SysCallArgument('value', BufferValue)],
    returnType: SerializableValue
  }),
  'Neo.Blockchain.GetHeight': new SimpleSysCall({
    name: 'Neo.Blockchain.GetHeight',
    returnType: NumberValue
  }),
  'Neo.Blockchain.GetHeader': new SimpleSysCall({
    name: 'Neo.Blockchain.GetHeader',
    args: [new SysCallArgument('hashOrIndex', new UnionValue([BufferValue, NumberValue]))],
    returnType: HeaderValue
  }),
  'Neo.Blockchain.GetBlock': new SimpleSysCall({
    name: 'Neo.Blockchain.GetBlock',
    args: [new SysCallArgument('hashOrIndex', new UnionValue([BufferValue, NumberValue]))],
    returnType: BlockValue
  }),
  'Neo.Blockchain.GetTransaction': new SimpleSysCall({
    name: 'Neo.Blockchain.GetTransaction',
    args: [new SysCallArgument('hash', BufferValue)],
    returnType: TransactionValue
  }),
  'Neo.Blockchain.GetAccount': new SimpleSysCall({
    name: 'Neo.Blockchain.GetAccount',
    args: [new SysCallArgument('hash', BufferValue)],
    returnType: AccountValue
  }),
  'Neo.Blockchain.GetValidators': new SimpleSysCall({
    name: 'Neo.Blockchain.GetValidators',
    returnType: new ArrayValue(BufferValue)
  }),
  'Neo.Blockchain.GetAsset': new SimpleSysCall({
    name: 'Neo.Blockchain.GetAsset',
    args: [new SysCallArgument('hash', BufferValue)],
    returnType: AssetValue
  }),
  'Neo.Blockchain.GetContract': new SimpleSysCall({
    name: 'Neo.Blockchain.GetContract',
    args: [new SysCallArgument('hash', BufferValue)],
    returnType: ContractValue
  }),
  'Neo.Header.GetHash': new SimpleSysCall({
    name: 'Neo.Header.GetHash',
    args: [new SysCallArgument('blockOrHeader', new UnionValue([BlockValue, HeaderValue]))],
    returnType: BufferValue
  }),
  'Neo.Header.GetVersion': new SimpleSysCall({
    name: 'Neo.Header.GetVersion',
    args: [new SysCallArgument('blockOrHeader', new UnionValue([BlockValue, HeaderValue]))],
    returnType: NumberValue
  }),
  'Neo.Header.GetPrevHash': new SimpleSysCall({
    name: 'Neo.Header.GetPrevHash',
    args: [new SysCallArgument('blockOrHeader', new UnionValue([BlockValue, HeaderValue]))],
    returnType: BufferValue
  }),
  'Neo.Header.GetIndex': new SimpleSysCall({
    name: 'Neo.Header.GetIndex',
    args: [new SysCallArgument('blockOrHeader', new UnionValue([BlockValue, HeaderValue]))],
    returnType: NumberValue
  }),
  'Neo.Header.GetMerkleRoot': new SimpleSysCall({
    name: 'Neo.Header.GetMerkleRoot',
    args: [new SysCallArgument('blockOrHeader', new UnionValue([BlockValue, HeaderValue]))],
    returnType: BufferValue
  }),
  'Neo.Header.GetTimestamp': new SimpleSysCall({
    name: 'Neo.Header.GetTimestamp',
    args: [new SysCallArgument('blockOrHeader', new UnionValue([BlockValue, HeaderValue]))],
    returnType: NumberValue
  }),
  'Neo.Header.GetConsensusData': new SimpleSysCall({
    name: 'Neo.Header.GetConsensusData',
    args: [new SysCallArgument('blockOrHeader', new UnionValue([BlockValue, HeaderValue]))],
    returnType: NumberValue
  }),
  'Neo.Header.GetNextConsensus': new SimpleSysCall({
    name: 'Neo.Header.GetNextConsensus',
    args: [new SysCallArgument('blockOrHeader', new UnionValue([BlockValue, HeaderValue]))],
    returnType: BufferValue
  }),
  'Neo.Block.GetTransactionCount': new SimpleSysCall({
    name: 'Neo.Block.GetTransactionCount',
    args: [new SysCallArgument('block', BlockValue)],
    returnType: NumberValue
  }),
  'Neo.Block.GetTransactions': new SimpleSysCall({
    name: 'Neo.Block.GetTransactions',
    args: [new SysCallArgument('block', BlockValue)],
    returnType: new ArrayValue(TransactionValue)
  }),
  'Neo.Block.GetTransaction': new SimpleSysCall({
    name: 'Neo.Block.GetTransaction',
    args: [new SysCallArgument('block', BlockValue), new SysCallArgument('index', NumberValue)],
    returnType: TransactionValue
  }),
  'Neo.Transaction.GetHash': new SimpleSysCall({
    name: 'Neo.Transaction.GetHash',
    args: [new SysCallArgument('transaction', TransactionValue)],
    returnType: BufferValue
  }),
  'Neo.Transaction.GetType': new SimpleSysCall({
    name: 'Neo.Transaction.GetType',
    args: [new SysCallArgument('transaction', TransactionValue)],
    returnType: NumberValue
  }),
  'Neo.Transaction.GetAttributes': new SimpleSysCall({
    name: 'Neo.Transaction.GetAttributes',
    args: [new SysCallArgument('transaction', TransactionValue)],
    returnType: new ArrayValue(AttributeValue)
  }),
  'Neo.Transaction.GetInputs': new SimpleSysCall({
    name: 'Neo.Transaction.GetInputs',
    args: [new SysCallArgument('transaction', TransactionValue)],
    returnType: new ArrayValue(InputValue)
  }),
  'Neo.Transaction.GetOutputs': new SimpleSysCall({
    name: 'Neo.Transaction.GetOutputs',
    args: [new SysCallArgument('transaction', TransactionValue)],
    returnType: new ArrayValue(OutputValue)
  }),
  'Neo.Transaction.GetReferences': new SimpleSysCall({
    name: 'Neo.Transaction.GetReferences',
    args: [new SysCallArgument('transaction', TransactionValue)],
    returnType: new ArrayValue(OutputValue)
  }),
  'Neo.Transaction.GetUnspentCoins': new SimpleSysCall({
    name: 'Neo.Transaction.GetUnspentCoins',
    args: [new SysCallArgument('transaction', TransactionValue)],
    returnType: new ArrayValue(OutputValue)
  }),
  'Neo.InvocationTransaction.GetScript': new SimpleSysCall({
    name: 'Neo.InvocationTransaction.GetScript',
    args: [new SysCallArgument('transaction', TransactionValue)],
    returnType: BufferValue
  }),
  'Neo.Attribute.GetUsage': new SimpleSysCall({
    name: 'Neo.Attribute.GetUsage',
    args: [new SysCallArgument('attribute', AttributeValue)],
    returnType: NumberValue
  }),
  'Neo.Attribute.GetData': new SimpleSysCall({
    name: 'Neo.Attribute.GetData',
    args: [new SysCallArgument('attribute', AttributeValue)],
    returnType: BufferValue
  }),
  'Neo.Input.GetHash': new SimpleSysCall({
    name: 'Neo.Input.GetHash',
    args: [new SysCallArgument('input', InputValue)],
    returnType: BufferValue
  }),
  'Neo.Input.GetIndex': new SimpleSysCall({
    name: 'Neo.Input.GetIndex',
    args: [new SysCallArgument('input', InputValue)],
    returnType: NumberValue
  }),
  'Neo.Output.GetAssetId': new SimpleSysCall({
    name: 'Neo.Output.GetAssetId',
    args: [new SysCallArgument('output', OutputValue)],
    returnType: BufferValue
  }),
  'Neo.Output.GetValue': new SimpleSysCall({
    name: 'Neo.Output.GetValue',
    args: [new SysCallArgument('output', OutputValue)],
    returnType: NumberValue
  }),
  'Neo.Output.GetScriptHash': new SimpleSysCall({
    name: 'Neo.Output.GetScriptHash',
    args: [new SysCallArgument('output', OutputValue)],
    returnType: BufferValue
  }),
  'Neo.Account.GetScriptHash': new SimpleSysCall({
    name: 'Neo.Account.GetScriptHash',
    args: [new SysCallArgument('account', AccountValue)],
    returnType: BufferValue
  }),
  'Neo.Account.GetVotes': new SimpleSysCall({
    name: 'Neo.Account.GetVotes',
    args: [new SysCallArgument('account', AccountValue)],
    returnType: new ArrayValue(BufferValue)
  }),
  'Neo.Account.GetBalance': new SimpleSysCall({
    name: 'Neo.Account.GetBalance',
    args: [new SysCallArgument('account', AccountValue), new SysCallArgument('assetHash', BufferValue)],
    returnType: NumberValue
  }),
  'Neo.Asset.GetAssetId': new SimpleSysCall({
    name: 'Neo.Asset.GetAssetId',
    args: [new SysCallArgument('asset', AssetValue)],
    returnType: BufferValue
  }),
  'Neo.Asset.GetAssetType': new SimpleSysCall({
    name: 'Neo.Asset.GetAssetType',
    args: [new SysCallArgument('asset', AssetValue)],
    returnType: NumberValue
  }),
  'Neo.Asset.GetAmount': new SimpleSysCall({
    name: 'Neo.Asset.GetAmount',
    args: [new SysCallArgument('asset', AssetValue)],
    returnType: NumberValue
  }),
  'Neo.Asset.GetAvailable': new SimpleSysCall({
    name: 'Neo.Asset.GetAvailable',
    args: [new SysCallArgument('asset', AssetValue)],
    returnType: NumberValue
  }),
  'Neo.Asset.GetPrecision': new SimpleSysCall({
    name: 'Neo.Asset.GetPrecision',
    args: [new SysCallArgument('asset', AssetValue)],
    returnType: NumberValue
  }),
  'Neo.Asset.GetOwner': new SimpleSysCall({
    name: 'Neo.Asset.GetOwner',
    args: [new SysCallArgument('asset', AssetValue)],
    returnType: BufferValue
  }),
  'Neo.Asset.GetAdmin': new SimpleSysCall({
    name: 'Neo.Asset.GetAdmin',
    args: [new SysCallArgument('asset', AssetValue)],
    returnType: BufferValue
  }),
  'Neo.Asset.GetIssuer': new SimpleSysCall({
    name: 'Neo.Asset.GetIssuer',
    args: [new SysCallArgument('asset', AssetValue)],
    returnType: BufferValue
  }),
  'Neo.Contract.GetScript': new SimpleSysCall({
    name: 'Neo.Contract.GetScript',
    args: [new SysCallArgument('contract', ContractValue)],
    returnType: BufferValue
  }),
  'Neo.Storage.GetContext': new SimpleSysCall({
    name: 'Neo.Storage.GetContext',
    returnType: StorageContextValue
  }),
  'Neo.Storage.Get': new SimpleSysCall({
    name: 'Neo.Storage.Get',
    args: [new SysCallArgument('context', StorageContextValue), new SysCallArgument('key', StorageKey)],
    returnType: SerializableValue.addSerialize().handleNull()
  }),
  'Neo.Storage.Find': new SimpleSysCall({
    name: 'Neo.Storage.Find',
    args: [new SysCallArgument('context', StorageContextValue), new SysCallArgument('prefix', StorageKey)],
    returnType: StorageIteratorValue
  }),
  'Neo.Iterator.Next': new SimpleSysCall({
    name: 'Neo.Iterator.Next',
    args: [new SysCallArgument('iterator', StorageIteratorValue)],
    returnType: BooleanValue
  }),
  'Neo.Iterator.Key': new SimpleSysCall({
    name: 'Neo.Iterator.Key',
    args: [new SysCallArgument('iterator', StorageIteratorValue)],
    returnType: StorageKey
  }),
  'Neo.Iterator.Value': new SimpleSysCall({
    name: 'Neo.Iterator.Value',
    args: [new SysCallArgument('iterator', StorageIteratorValue)],
    returnType: StorageValue
  }),
  'Neo.Account.SetVotes': new SimpleSysCall({
    name: 'Neo.Account.SetVotes',
    args: [new SysCallArgument('account', AccountValue), new SysCallArgument('votes', new ArrayValue(BufferValue))]
  }),
  'Neo.Validator.Register': new SimpleSysCall({
    name: 'Neo.Validator.Register',
    args: [new SysCallArgument('publicKey', BufferValue)],
    returnType: ValidatorValue
  }),
  'Neo.Asset.Create': new SimpleSysCall({
    name: 'Neo.Asset.Create',
    args: [new SysCallArgument('assetType', NumberValue), new SysCallArgument('assetName', StringValue), new SysCallArgument('amount', NumberValue), new SysCallArgument('precision', NumberValue), new SysCallArgument('owner', BufferValue), new SysCallArgument('admin', BufferValue), new SysCallArgument('issuer', BufferValue)],
    returnType: AssetValue
  }),
  'Neo.Asset.Renew': new SimpleSysCall({
    name: 'Neo.Asset.Renew',
    args: [new SysCallArgument('asset', AssetValue), new SysCallArgument('years', NumberValue)],
    returnType: NumberValue
  }),
  'Neo.Contract.Create': new SimpleSysCall({
    name: 'Neo.Contract.Create',
    args: [new SysCallArgument('script', BufferValue), new SysCallArgument('parameterList', BufferValue), new SysCallArgument('returnType', NumberValue), new SysCallArgument('properties', NumberValue), new SysCallArgument('contractName', StringValue), new SysCallArgument('codeVersion', StringValue), new SysCallArgument('author', StringValue), new SysCallArgument('email', StringValue), new SysCallArgument('description', StringValue)],
    returnType: ContractValue
  }),
  'Neo.Contract.Migrate': new SimpleSysCall({
    name: 'Neo.Contract.Migrate',
    args: [new SysCallArgument('script', BufferValue), new SysCallArgument('parameterList', BufferValue), new SysCallArgument('returnType', NumberValue), new SysCallArgument('properties', NumberValue), new SysCallArgument('contractName', StringValue), new SysCallArgument('codeVersion', StringValue), new SysCallArgument('author', StringValue), new SysCallArgument('email', StringValue), new SysCallArgument('description', StringValue)],
    returnType: ContractValue
  }),
  'Neo.Contract.GetStorageContext': new SimpleSysCall({
    name: 'Neo.Contract.GetStorageContext',
    args: [new SysCallArgument('contract', ContractValue)],
    returnType: StorageContextValue
  }),
  'Neo.Contract.Destroy': new SimpleSysCall({
    name: 'Neo.Contract.Destroy'
  }),
  'Neo.Storage.Put': new SimpleSysCall({
    name: 'Neo.Storage.Put',
    args: [new SysCallArgument('context', StorageContextValue), new SysCallArgument('key', StorageKey), new SysCallArgument('value', SerializableValue.addSerialize())]
  }),
  'Neo.Storage.Delete': new SimpleSysCall({
    name: 'Neo.Storage.Delete',
    args: [new SysCallArgument('context', StorageContextValue), new SysCallArgument('key', StorageKey)]
  }),
  'System.ExecutionEngine.GetScriptContainer': new SimpleSysCall({
    name: 'System.ExecutionEngine.GetScriptContainer',
    returnType: TransactionValue
  }),
  'System.ExecutionEngine.GetExecutingScriptHash': new SimpleSysCall({
    name: 'System.ExecutionEngine.GetExecutingScriptHash',
    returnType: BufferValue
  }),
  'System.ExecutionEngine.GetCallingScriptHash': new SimpleSysCall({
    name: 'System.ExecutionEngine.GetCallingScriptHash',
    returnType: BufferValue
  }),
  'System.ExecutionEngine.GetEntryScriptHash': new SimpleSysCall({
    name: 'System.ExecutionEngine.GetEntryScriptHash',
    returnType: BufferValue
  }),
  'Neo.Runtime.Return': (() => {
    const name = 'Neo.Runtime.Return';
    const valueType = new UnionValue([BufferValue, NumberValue, StringValue, BooleanValue]);
    const returnType = VoidValue;
    return {
      name,

      toDeclaration() {
        const sig = valueType.toSignature();
        return `function syscall(name: '${name}', value: ${sig}): ${returnType.toSignature()};`;
      },

      handleCall(sb, node, optionsIn) {
        const options = sb.pushValueOptions(sb.noCastOptions(optionsIn));
        const arg = node.getArguments()[1];
        sb.visit(arg, options);
        valueType.handleArgument(sb, arg, options, sb.getType(arg));
      }

    };
  })(),
  'Neo.Runtime.GetArgument': (() => {
    const name = 'Neo.Runtime.GetArgument';
    const valueType = NumberValue;
    const returnType = new UnionValue([BufferValue, BooleanValue, NumberValue, StringValue, new ArrayValue(() => returnType), new TupleValue(() => returnType)]);
    return {
      name,

      toDeclaration() {
        const sig = valueType.toSignature();
        return `function syscall(name: '${name}', idx: ${sig}): any;`;
      },

      handleCall(sb, node, optionsIn) {
        const options = sb.pushValueOptions(sb.noCastOptions(optionsIn));
        const arg = node.getArguments()[1];
        sb.visit(arg, options);
        sb.emitHelper(arg, options, sb.helpers.getArgument({
          type: sb.getType(arg)
        }));

        if (optionsIn.pushValue) {
          returnType.handleResult(sb, node, optionsIn, optionsIn.cast);
        } else {
          sb.emitOp(node, 'DROP');
        }
      }

    };
  })()
};

class CallExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.CallExpression
    }), _temp;
  }

  visitNode(sb, expr, optionsIn) {
    const func = expr.getExpression();

    if (TypeGuards.isIdentifier(func) && sb.isGlobalSymbol(func, sb.getSymbol(func), 'syscall')) {
      this.handleSysCall(sb, expr, optionsIn);
      return;
    }

    const options = sb.pushValueOptions(sb.noCastOptions(optionsIn)); // [argsarr]

    sb.emitHelper(expr, options, sb.helpers.args);

    if (TypeGuards.isSuperExpression(func)) {
      this.handleSuperConstruct(sb, expr, options);
      return;
    }

    let bindThis;

    if (TypeGuards.isElementAccessExpression(func) || TypeGuards.isPropertyAccessExpression(func)) {
      bindThis = true;
      const lhs = func.getExpression();

      if (TypeGuards.isSuperExpression(lhs)) {
        // [thisValue, argsarr]
        sb.scope.getThis(sb, lhs, options); // [superPrototype, thisValue, argsarr]

        sb.visit(lhs, options);
      } else {
        // [expr, argsarr]
        sb.visit(lhs, options); // [expr, expr, argsarr]

        sb.emitOp(func, 'DUP');
      }

      if (TypeGuards.isElementAccessExpression(func)) {
        // [objectVal, expr, argsarr]
        sb.emitHelper(func, options, sb.helpers.elementAccess);
      } else {
        // [name, expr, expr, argsarr]
        sb.emitPushString(func.getNameNode(), func.getName()); // [objectVal, expr, argsarr]

        sb.emitHelper(expr, options, sb.helpers.getPropertyObjectProperty);
      }
    } else {
      bindThis = false; // [objectVal, argsarr]

      sb.visit(func, options);
    }

    sb.emitHelper(expr, options, sb.helpers.invokeCall({
      bindThis
    }));

    if (!optionsIn.pushValue) {
      sb.emitOp(expr, 'DROP');
    }
  }

  handleSysCall(sb, node, options) {
    const sysCallName = node.getArguments()[0];

    const reportError = () => {
      sb.reportError(node, 'First argument to syscall must be a string literal corresponding to a NEO syscall.', DiagnosticCode.INVALID_SYS_CALL);
    };

    if (sysCallName == null || !TypeGuards.isStringLiteral(sysCallName)) {
      reportError();
      return;
    }

    const sysCallKey = sysCallName.getLiteralValue();
    const sysCall = SYSCALLS[sysCallKey];

    if (sysCall == null) {
      reportError();
    } else {
      sysCall.handleCall(sb, node, options);
    }
  }

  handleSuperConstruct(sb, node, options) {
    const superClass = options.superClass;

    if (superClass == null) {
      throw new Error('Something went wrong, expected super class to be defined.');
    } // [thisValue, argsarr]


    sb.scope.getThis(sb, node, options); // [ctor, thisValue, argsarr]

    sb.scope.get(sb, node, options, superClass); // []

    sb.emitHelper(node, options, sb.helpers.invokeConstruct());
  }

}

class CommaListExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.CommaListExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    // TODO: What is this??
    sb.reportUnsupported(expr);
  }

}

class ConditionalExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ConditionalExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.emitHelper(expr, options, sb.helpers.if({
      condition: () => {
        // [val]
        sb.visit(expr.getCondition(), sb.pushValueOptions(options)); // [boolean]

        sb.emitHelper(expr.getCondition(), sb.pushValueOptions(options), sb.helpers.toBoolean({
          type: sb.getType(expr.getCondition())
        }));
      },
      whenTrue: () => {
        sb.visit(expr.getWhenTrue(), options);
      },
      whenFalse: () => {
        sb.visit(expr.getWhenFalse(), options);
      }
    }));
  }

}

class DeleteExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.DeleteExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class ElementAccessExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ElementAccessExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    const value = expr.getExpression(); // [val]

    sb.visit(value, sb.pushValueOptions(sb.noSetValueOptions(options))); // [val]

    sb.emitHelper(expr, options, sb.helpers.elementAccess);
  }

}

class FunctionExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.FunctionExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class IdentifierCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.Identifier
    }), _temp;
  }

  visitNode(sb, expr, options) {
    if (options.setValue) {
      sb.scope.set(sb, expr, sb.noSetValueOptions(options), expr.getText());
    }

    if (options.pushValue) {
      if (expr.compilerNode.originalKeywordKind != null && expr.compilerNode.originalKeywordKind === SyntaxKind.UndefinedKeyword) {
        sb.emitHelper(expr, options, sb.helpers.createUndefined);
      } else {
        sb.scope.get(sb, expr, options, expr.getText());
      }
    }
  }

}

class ImportExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ImportKeyword
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class MetaPropertyCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.MetaProperty
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class NewExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.NewExpression
    }), _temp;
  }

  visitNode(sb, expr, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [argsarr]

    sb.emitHelper(expr, options, sb.helpers.args); // [objectVal, argsarr]

    sb.visit(expr.getExpression(), options); // [thisVal]

    sb.emitHelper(expr, options, sb.helpers.new());
  }

}

class NonNullExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.NonNullExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class NoSubstitutionTemplateLiteralCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.NoSubstitutionTemplateLiteral
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class NullLiteralCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.NullKeyword
    }), _temp;
  }

  visitNode(sb, expr, options) {
    if (options.pushValue) {
      sb.emitHelper(expr, options, sb.helpers.createNull);
    }
  }

}

class NumericLiteralCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.NumericLiteral
    }), _temp;
  }

  visitNode(sb, expr, options) {
    if (options.pushValue) {
      sb.emitPushInt(expr, expr.getLiteralValue());
      sb.emitHelper(expr, options, sb.helpers.createNumber);
    }
  }

}

class ObjectLiteralExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ObjectLiteralExpression
    }), _temp;
  }

  visitNode(sb, node, optionsIn) {
    const options = sb.pushValueOptions(optionsIn); // [objectVal]

    sb.emitHelper(node, options, sb.helpers.createObject);
    node.getProperties().forEach(prop => {
      // [objectVal, objectVal]
      sb.emitOp(node, 'DUP');

      if (TypeGuards.isPropertyAssignment(prop) || TypeGuards.isShorthandPropertyAssignment(prop) || TypeGuards.isMethodDeclaration(prop)) {
        // [propString, objectVal, objectVal]
        sb.emitPushString(prop, prop.getName());

        if (TypeGuards.isPropertyAssignment(prop)) {
          // [val, propString, objectVal, objectVal]
          sb.visit(prop.getInitializerOrThrow(), options);
        } else if (TypeGuards.isShorthandPropertyAssignment(prop)) {
          // [val, propString, objectVal, objectVal]
          sb.visit(prop.getNameNode(), options);
        } else if (TypeGuards.isMethodDeclaration(prop)) {
          // [callArr, propString, objectVal, objectVal]
          sb.emitHelper(prop, options, sb.helpers.createCallArray); // [callObj, propString, objectVal, objectVal]

          sb.emitHelper(prop, options, sb.helpers.createFunctionObject({
            property: InternalFunctionProperties.CALL
          }));
        } else {
          // TODO: Support get/set accessors
          sb.reportUnsupported(prop);
        } // [objectVal]


        sb.emitHelper(prop, options, sb.helpers.setDataPropertyObjectProperty);
      } else {
        sb.reportUnsupported(prop);
      }
    });

    if (!optionsIn.pushValue) {
      sb.emitOp(node, 'DROP');
    }
  }

}

class OmittedExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.OmittedExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class ParenthesizedExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ParenthesizedExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.visit(expr.getExpression(), options);
  }

}

class PartiallyEmittedExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.PartiallyEmittedExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class PostfixUnaryExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.PostfixUnaryExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.visit(expr.getOperand(), sb.noSetValueOptions(sb.pushValueOptions(options)));
    const token = expr.getOperatorToken();

    switch (token) {
      case SyntaxKind.PlusPlusToken:
      case SyntaxKind.MinusMinusToken:
        this.visitAssignment(sb, token, expr, options);
        break;

      default:
        sb.assertUnreachable(token);
    }
  }

  visitAssignment(sb, token, expr, options) {
    if (options.pushValue) {
      sb.emitOp(expr, 'DUP');
    }

    switch (token) {
      case SyntaxKind.PlusPlusToken:
        sb.emitHelper(expr, sb.pushValueOptions(options), sb.helpers.toNumber({
          type: sb.getType(expr)
        }));
        sb.emitOp(expr, 'INC');
        sb.emitHelper(expr, sb.pushValueOptions(options), sb.helpers.createNumber);
        break;

      case SyntaxKind.MinusMinusToken:
        sb.emitHelper(expr, sb.pushValueOptions(options), sb.helpers.toNumber({
          type: sb.getType(expr)
        }));
        sb.emitOp(expr, 'DEC');
        sb.emitHelper(expr, sb.pushValueOptions(options), sb.helpers.createNumber);
        break;

      default:
        sb.assertUnreachable(token);
    }

    sb.visit(expr.getOperand(), sb.noPushValueOptions(sb.setValueOptions(options)));
  }

}

class PrefixUnaryExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.PrefixUnaryExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    const token = expr.getOperatorToken();

    switch (token) {
      case SyntaxKind.PlusPlusToken:
      case SyntaxKind.MinusMinusToken:
        this.visitAssignment(sb, token, expr, options);
        break;

      case SyntaxKind.PlusToken:
      case SyntaxKind.MinusToken:
      case SyntaxKind.TildeToken:
      case SyntaxKind.ExclamationToken:
        this.visitValue(sb, token, expr, options);
        break;

      default:
        sb.assertUnreachable(token);
    }
  }

  visitAssignment(sb, token, expr, options) {
    sb.visit(expr.getOperand(), sb.noSetValueOptions(sb.pushValueOptions(options)));

    switch (token) {
      case SyntaxKind.PlusPlusToken:
        sb.emitHelper(expr, sb.pushValueOptions(options), sb.helpers.toNumber({
          type: sb.getType(expr)
        }));
        sb.emitOp(expr, 'INC');
        sb.emitHelper(expr, sb.pushValueOptions(options), sb.helpers.createNumber);
        break;

      case SyntaxKind.MinusMinusToken:
        sb.emitHelper(expr, sb.pushValueOptions(options), sb.helpers.toNumber({
          type: sb.getType(expr)
        }));
        sb.emitOp(expr, 'DEC');
        sb.emitHelper(expr, sb.pushValueOptions(options), sb.helpers.createNumber);
        break;

      default:
        sb.assertUnreachable(token);
    }

    sb.visit(expr.getOperand(), sb.setValueOptions(options));
  }

  visitValue(sb, token, expr, options) {
    const operand = expr.getOperand();
    sb.visit(operand, sb.noSetValueOptions(sb.pushValueOptions(options)));

    if (!options.pushValue) {
      sb.emitOp(expr, 'DROP');
      return;
    }

    switch (token) {
      case SyntaxKind.PlusToken:
        sb.emitHelper(expr, options, sb.helpers.toNumber({
          type: sb.getType(expr)
        }));
        sb.emitHelper(expr, options, sb.helpers.createNumber);
        break;

      case SyntaxKind.MinusToken:
        sb.emitHelper(expr, options, sb.helpers.toNumber({
          type: sb.getType(expr)
        }));
        sb.emitOp(expr, 'NEGATE');
        sb.emitHelper(expr, options, sb.helpers.createNumber);
        break;

      case SyntaxKind.TildeToken:
        sb.emitHelper(expr, options, sb.helpers.toNumber({
          type: sb.getType(expr)
        }));
        sb.emitOp(expr, 'INVERT');
        sb.emitHelper(expr, options, sb.helpers.createNumber);
        break;

      case SyntaxKind.ExclamationToken:
        sb.emitHelper(operand, options, sb.helpers.toBoolean({
          type: sb.getType(operand)
        }));
        sb.emitOp(expr, 'NOT');
        sb.emitHelper(operand, options, sb.helpers.createBoolean);
        break;

      default:
        sb.assertUnreachable(token);
    }
  }

}

class PropertyAccessExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.PropertyAccessExpression
    }), _temp;
  }

  visitNode(sb, expr, optionsIn) {
    const options = sb.pushValueOptions(sb.noSetValueOptions(optionsIn));
    const expression = expr.getExpression(); // [val]

    sb.visit(expression, options); // [objectVal]

    sb.emitHelper(expression, options, sb.helpers.toObject({
      type: sb.getType(expression)
    }));

    if (optionsIn.setValue) {
      if (optionsIn.pushValue) {
        // [objectVal, value, objectVal]
        sb.emitOp(expression, 'TUCK');
      } // [name, objectVal, value, objectVal]


      sb.emitPushString(expr, expr.getName()); // [value, name, objectVal, objectVal]

      sb.emitOp(expr, 'ROT'); // [objectVal]

      sb.emitHelper(expr, options, sb.helpers.setPropertyObjectProperty);
    }

    if (optionsIn.pushValue || !optionsIn.setValue) {
      // [name, objectVal]
      sb.emitPushString(expr, expr.getName()); // [value]

      sb.emitHelper(expr, options, sb.helpers.getPropertyObjectProperty);

      if (!optionsIn.pushValue) {
        sb.emitOp(expr, 'DROP');
      }
    }
  }

}

class RegularExpressionLiteralCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.RegularExpressionLiteral
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class SpreadElementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.SpreadElement
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class StringLiteralCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.StringLiteral
    }), _temp;
  }

  visitNode(sb, expr, options) {
    if (options.pushValue) {
      sb.emitPushString(expr, expr.getLiteralValue());
      sb.emitHelper(expr, options, sb.helpers.createString);
    }
  }

}

class SuperExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.SuperKeyword
    }), _temp;
  }

  visitNode(sb, expr, options) {
    if (options.pushValue) {
      const superClass = options.superClass;

      if (superClass == null) {
        throw new Error('Something went wrong, expected super class to be defined.');
      } // [superClass]


      sb.scope.get(sb, expr, options, superClass); // ['prototype', superClass]

      sb.emitPushString(expr, 'prototype'); // [superPrototype]

      sb.emitHelper(expr, options, sb.helpers.getPropertyObjectProperty);
    }
  }

}

class TaggedTemplateExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.TaggedTemplateExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class ThisExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ThisKeyword
    }), _temp;
  }

  visitNode(sb, expr, options) {
    if (options.pushValue) {
      sb.scope.getThis(sb, expr, options);
    }
  }

}

class TypeAssertionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.TypeAssertionExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class TypeOfExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.TypeOfExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

class VoidExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.VoidExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    if (options.pushValue) {
      sb.emitHelper(expr, options, sb.helpers.createUndefined);
    }
  }

}

class YieldExpressionCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.YieldExpression
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.reportUnsupported(expr);
  }

}

var expression = [ArrayLiteralExpressionCompiler, ArrowFunctionCompiler, AsExpressionCompiler, AwaitExpressionCompiler, BinaryExpressionCompiler, TrueBooleanLiteralCompiler, FalseBooleanLiteralCompiler, CallExpressionCompiler, CommaListExpressionCompiler, ConditionalExpressionCompiler, DeleteExpressionCompiler, ElementAccessExpressionCompiler, FunctionExpressionCompiler, IdentifierCompiler, ImportExpressionCompiler, MetaPropertyCompiler, NewExpressionCompiler, NonNullExpressionCompiler, NoSubstitutionTemplateLiteralCompiler, NullLiteralCompiler, NumericLiteralCompiler, ObjectLiteralExpressionCompiler, OmittedExpressionCompiler, ParenthesizedExpressionCompiler, PartiallyEmittedExpressionCompiler, PostfixUnaryExpressionCompiler, PrefixUnaryExpressionCompiler, PropertyAccessExpressionCompiler, RegularExpressionLiteralCompiler, SpreadElementCompiler, StringLiteralCompiler, SuperExpressionCompiler, TaggedTemplateExpressionCompiler, ThisExpressionCompiler, TypeAssertionCompiler, TypeOfExpressionCompiler, VoidExpressionCompiler, YieldExpressionCompiler];

class SourceFileCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.SourceFile
    }), _temp;
  }

  visitNode(sb, node, options) {
    node.getImportDeclarations().forEach(decl => {
      sb.visit(decl, options);
    });
    sb.emitHelper(node, options, sb.helpers.processStatements({
      createScope: false
    }));
    node.getExportDeclarations().forEach(decl => {
      sb.visit(decl, options);
    });
    node.getExportAssignments().forEach(assignment => {
      sb.visit(assignment, options);
    });
  }

}

var file = [SourceFileCompiler];

class BlockCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.Block
    }), _temp;
  }

  visitNode(sb, expr, options) {
    sb.emitHelper(expr, options, sb.helpers.processStatements({
      createScope: true
    }));
  }

}

class BreakStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.BreakStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    const label = node.getLabel();

    if (label != null) {
      sb.reportUnsupported(label);
    }

    if (options.breakPC == null) {
      sb.reportError(node, 'Something went wrong. Expected a break jump location.', DiagnosticCode.SOMETHING_WENT_WRONG);
    } else {
      sb.emitPushInt(node, BREAK_COMPLETION);
      sb.emitJmp(node, 'JMP', options.breakPC);
    }
  }

}

class CaseBlockCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.CaseBlock
    }), _temp;
  }

  visitNode(sb, node, options) {
    node.getClauses().forEach(clause => {
      sb.visit(clause, options);
    });
  }

}

class CaseClauseCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.CaseClause
    }), _temp;
  }

  visitNode(sb, node, options) {
    sb.reportUnsupported(node);
  }

}

class CatchClauseCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.CatchClause
    }), _temp;
  }

  visitNode(sb, node, options) {
    const variable = node.getVariableDeclaration();

    if (variable == null) {
      sb.visit(node.getBlock(), options);
    } else {
      sb.withScope(node, options, innerOptions => {
        sb.visit(variable, innerOptions);
        sb.visit(node.getBlock(), innerOptions);
      });
    }
  }

}

class ContinueStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ContinueStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    const label = node.getLabel();

    if (label != null) {
      sb.reportUnsupported(label);
    }

    if (options.continuePC == null) {
      sb.reportError(node, 'Something went wrong. Expected a continue jump location.', DiagnosticCode.SOMETHING_WENT_WRONG);
    } else {
      sb.emitPushInt(node, CONTINUE_COMPLETION);
      sb.emitJmp(node, 'JMP', options.continuePC);
    }
  }

}

class DebuggerStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.DebuggerStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    sb.reportUnsupported(node);
  }

}

class DefaultClauseCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.DefaultClause
    }), _temp;
  }

  visitNode(sb, node, options) {
    sb.emitOp(node, 'DROP');
    sb.emitHelper(node, options, sb.helpers.processStatements({
      createScope: false
    }));
  }

}

class DoStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.DoStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    sb.withProgramCounter(pc => {
      sb.withProgramCounter(innerPC => {
        sb.visit(node.getStatement(), sb.breakPCOptions(sb.continuePCOptions(options, innerPC.getLast()), pc.getLast()));
      });
      sb.emitHelper(node.getExpression(), options, sb.helpers.if({
        condition: () => {
          sb.visit(node.getExpression(), sb.pushValueOptions(options));
        },
        whenTrue: () => {
          sb.emitJmp(node, 'JMP', pc.getFirst());
        }
      }));
    });
  }

}

class EmptyStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.EmptyStatement
    }), _temp;
  }

  visitNode(sb, node, options) {// tslint:disable-line
  }

}

class ExpressionStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ExpressionStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    sb.visit(node.getExpression(), sb.noPushValueOptions(options));
  }

}

class ForInStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ForInStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    sb.reportUnsupported(node);
  }

}

class ForOfStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ForOfStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    sb.reportUnsupported(node);
  }

}

class ForStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ForStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    let initializer;
    const exprInitializer = node.getInitializer();

    if (exprInitializer != null) {
      initializer = () => {
        sb.visit(exprInitializer, sb.noPushValueOptions(options));
      };
    }

    let condition;
    const exprCondition = node.getCondition();

    if (exprCondition != null) {
      condition = () => {
        sb.visit(exprCondition, sb.pushValueOptions(options));
        sb.emitHelper(exprCondition, sb.pushValueOptions(options), sb.helpers.toBoolean({
          type: sb.getType(exprCondition)
        }));
      };
    }

    let incrementor;
    const exprIncrementor = node.getIncrementor();

    if (exprIncrementor != null) {
      incrementor = () => {
        sb.visit(exprIncrementor, sb.noPushValueOptions(options));
      };
    }

    sb.emitHelper(node, options, sb.helpers.forLoop({
      initializer,
      condition,
      incrementor,
      each: innerOptions => {
        sb.visit(node.getStatement(), sb.noPushValueOptions(innerOptions));
      }
    }));
  }

}

class IfStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.IfStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    const condition = () => {
      const cond = node.getExpression();
      sb.visit(cond, sb.pushValueOptions(options));
      sb.emitHelper(cond, sb.pushValueOptions(options), sb.helpers.toBoolean({
        type: sb.getType(cond)
      }));
    };

    const whenTrue = () => {
      sb.visit(node.getThenStatement(), options);
    };

    let whenFalse;
    const nodeWhenFalse = node.getElseStatement();

    if (nodeWhenFalse != null) {
      whenFalse = () => {
        sb.visit(nodeWhenFalse, options);
      };
    }

    sb.emitHelper(node, options, sb.helpers.if({
      condition,
      whenTrue,
      whenFalse
    }));
  }

}

class LabeledStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.LabeledStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    sb.reportUnsupported(node);
  }

}

class NotEmittedStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.NotEmittedStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    sb.reportUnsupported(node);
  }

}

class ReturnStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ReturnStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    const expr = node.getExpression();

    if (expr == null) {
      sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.createUndefined);
    } else {
      sb.visit(expr, sb.pushValueOptions(options));
    }

    sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.createNormalCompletion);
    sb.emitOp(node, 'RET');
  }

}

class SwitchStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.SwitchStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    sb.withProgramCounter(pc => {
      sb.visit(node.getExpression(), sb.pushValueOptions(options));
      sb.visit(node.getCaseBlock(), sb.breakPCOptions(options, pc.getLast()));
    });
  }

}

class ThrowStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ThrowStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    const expr = node.getExpression();
    sb.visit(expr, sb.pushValueOptions(options));
    sb.emitHelper(node, options, sb.helpers.throw);
  }

}

class TryStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.TryStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    const catchClause = node.getCatchClause();

    if (catchClause == null) {
      sb.visit(node.getTryBlock(), options);
    } else {
      sb.withProgramCounter(pc => {
        sb.withProgramCounter(innerPC => {
          sb.visit(node.getTryBlock(), sb.catchPCOptions(options, innerPC.getLast()));
          sb.emitJmp(node, 'JMP', pc.getLast());
        });
        sb.visit(catchClause, options);
      });
    }

    const finallyBlock = node.getFinallyBlock();

    if (finallyBlock != null) {
      sb.reportUnsupported(finallyBlock);
    }
  }

}

class VariableStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.VariableStatement
    }), _temp;
  }

  visitNode(sb, node, optionsIn) {
    sb.visit(node.getDeclarationList(), optionsIn);

    if (node.isNamedExport()) {
      const options = sb.pushValueOptions(optionsIn); // [exports]

      sb.emitHelper(node, options, sb.helpers.getCurrentModule);
      node.getDeclarationList().getDeclarations().forEach(decl => {
        // [exports, exports]
        sb.emitOp(node, 'DUP'); // [val, exports, exports]

        sb.scope.get(sb, node, options, decl.getName()); // [exports]

        sb.emitHelper(node, options, sb.helpers.export({
          name: decl.getName()
        }));
      }); // []

      sb.emitOp(node, 'DROP');
    }
  }

}

class WhileStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.WhileStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    sb.withProgramCounter(pc => {
      sb.visit(node.getExpression(), sb.pushValueOptions(options));
      sb.emitJmp(node, 'JMPIFNOT', pc.getLast());
      sb.visit(node.getStatement(), sb.breakPCOptions(sb.continuePCOptions(options, pc.getFirst()), pc.getLast()));
      sb.emitJmp(node, 'JMP', pc.getFirst());
    });
  }

}

class WithStatementCompiler extends NodeCompiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.WithStatement
    }), _temp;
  }

  visitNode(sb, node, options) {
    sb.reportUnsupported(node);
  }

}

var statement = [BlockCompiler, BreakStatementCompiler, CaseBlockCompiler, CaseClauseCompiler, CatchClauseCompiler, ContinueStatementCompiler, DebuggerStatementCompiler, DefaultClauseCompiler, DoStatementCompiler, EmptyStatementCompiler, ExpressionStatementCompiler, ForInStatementCompiler, ForOfStatementCompiler, ForStatementCompiler, IfStatementCompiler, LabeledStatementCompiler, NotEmittedStatementCompiler, ReturnStatementCompiler, SwitchStatementCompiler, ThrowStatementCompiler, TryStatementCompiler, VariableStatementCompiler, WhileStatementCompiler, WithStatementCompiler];

const MAX_JUMP = 32767;
const JUMP_OFFSET = 20000;

class CodePoint {
  constructor() {
    Object.defineProperty(this, "length", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "sources", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: new Set()
    });
    Object.defineProperty(this, "pcInternal", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "prevInternal", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "nextInternal", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
  }

  get pc() {
    return this.resolvePC();
  }

  resolvePC() {
    if (this.pcInternal == null) {
      this.pcInternal = 0;

      if (this.prev == null) {
        this.pcInternal = 0;
      } else {
        this.pcInternal = this.prev.pc + this.prev.length;
      }
    }

    return this.pcInternal;
  }

  resetPC() {
    if (this.pcInternal != null) {
      this.pcInternal = undefined;
      let next = this.next;

      while (next != null) {
        next.pcInternal = undefined;
        next = next.next;
      }
    }
  }

  get totalLength() {
    let length = this.length;
    let next = this.next;

    while (next != null) {
      length += next.length;
      next = next.next;
    }

    return length;
  }

  get prev() {
    return this.prevInternal;
  }

  set prev(prev) {
    this.resetPC();
    this.prevInternal = prev;
  }

  get next() {
    return this.nextInternal;
  }

  set next(next) {
    this.nextInternal = next;
  }

  insertJumps(targets) {
    let self = this;
    let skipJump = false;
    let ret = this;

    while (self != null) {
      const target = targets[0];

      if (target == null) {
        return ret;
      }

      let length = 0;

      if (self.next != null && !skipJump) {
        length = 3;
      }

      let next = self.next;
      let nextSkipJump = false;

      if (target.isMax && self.pc + self.length + length > target.pc + target.getPostOffset() || !target.isMax && self.pc >= target.pc + target.getPostOffset() - length) {
        next = self;

        if (skipJump) {
          const resolved = target.resolve();
          self.insertBefore(resolved);

          if (self === this) {
            ret = resolved;
          }
        } else {
          const resolved = target.resolve();
          const jump = new JumpCodePoint('JMP', self);
          self.insertBefore(jump);
          jump.insertAfter(resolved);

          if (self === this) {
            ret = resolved;
          }
        }

        nextSkipJump = true;
        targets.shift();
      }

      self = next;
      skipJump = nextSkipJump;
    }

    if (targets.length > 0) {
      throw new Error(`Failed to insert all targets. Something went wrong. Remaining: ${targets.length}`);
    }

    return ret;
  }

  insertBefore(point) {
    if (this.prev != null) {
      this.prev.next = point;
      point.prev = this.prev;
    }

    this.prev = point;
    point.next = this;
  }

  insertAfter(point) {
    if (this.next != null) {
      this.next.prev = point;
      point.next = this.next;
    }

    this.next = point;
    point.prev = this;
  }

  replace(point) {
    if (this.prev != null) {
      this.prev.next = point;
      point.prevInternal = this.prev;
    }

    if (this.next != null) {
      if (point.length === this.length) {
        this.next.prevInternal = point;
      } else {
        this.next.prev = point;
      }

      point.next = this.next;
    }
  }

}

class JumpCodePoint extends CodePoint {
  constructor(type, targetInternal) {
    super();
    this.type = type;
    this.targetInternal = targetInternal;
    Object.defineProperty(this, "length", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 3
    });
  }

  get target() {
    if (this.targetInternal == null) {
      throw new Error('Target not set');
    }

    return this.targetInternal;
  }

  set target(target) {
    this.targetInternal = target;
  }

  get isForwardJump() {
    return this.target.pc > this.pc;
  }

  get isReverseJump() {
    return this.target.pc < this.pc;
  }

  get offset() {
    if (this.target.pc === this.pc) {
      throw new Error('Something went wrong. Found equal target pc and current pc.');
    }

    return this.target.pc - this.pc;
  }

}

class BufferCodePoint extends CodePoint {
  constructor(value) {
    super();
    this.value = value;
    Object.defineProperty(this, "length", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.length = value.length;
  }

}

class NewJump {
  constructor(pc, isMax, target) {
    this.pc = pc;
    this.isMax = isMax;
    this.target = target;
    Object.defineProperty(this, "length", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 3
    });
    Object.defineProperty(this, "sourceInternal", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "internalPostOffset", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
  }

  get source() {
    if (this.sourceInternal == null) {
      throw new Error('NewJump source is not set');
    }

    return this.sourceInternal;
  }

  set source(source) {
    this.sourceInternal = source;
  }

  resolve() {
    const jump = new JumpCodePoint('JMP', this.target);
    this.source.target = jump;

    if (this.target instanceof NewJump) {
      this.target.source = jump;
    } else {
      this.target.sources.add(jump);
    }

    if (this.source instanceof JumpCodePoint) {
      jump.sources.add(this.source);
    }

    return jump;
  }

  get isForwardJump() {
    return this.isMax;
  }

  get isReverseJump() {
    return !this.isMax;
  }

  get offset() {
    if (this.target.pc === this.pc) {
      throw new Error('Something went wrong. Found equal target pc and current pc.');
    }

    return this.target.pc - this.pc;
  }

  getPostOffset() {
    if (this.internalPostOffset == null) {
      throw new Error('Not resolved');
    }

    return this.internalPostOffset;
  }

  resolvePostOffset(targets) {
    const sourcePC = this.source.pc;

    if (this.isMax) {
      this.internalPostOffset = targets.filter(target => sourcePC < target.pc && target.pc < this.pc).reduce(acc => acc - 6, 0);
    } else {
      this.internalPostOffset = targets.filter(target => this.pc < target.pc && target.pc < sourcePC).reduce(acc => acc + 6, 0);
    }
  }

}

class JumpResolver {
  process(bytecode) {
    let first = this.getCodePoint(bytecode);
    let newTargets = []; // TODO: We do this in a loop in case there's a math problem in inserting
    //       new jumps, might not be necessary.
    // TODO: Optimize and fix this crazy logic.

    do {
      this.resolvePC(first);
      const result = this.processOne(first);
      first = result[0];
      newTargets = result[1];

      const sortedNewTargets = _.sortBy(newTargets, target => target.pc);

      sortedNewTargets.forEach(target => target.resolvePostOffset(sortedNewTargets));
      first = first.insertJumps(sortedNewTargets);
    } while (newTargets.length > 0);

    this.resolvePC(first);
    let current = first;
    const out = [];

    while (current != null) {
      if (current instanceof JumpCodePoint) {
        const pc = new KnownProgramCounter(current.target.pc);

        if (current.type === 'CALL') {
          out.push(new Call(pc));
        } else {
          out.push(new Jmp(current.type, pc));
        }
      } else if (current instanceof BufferCodePoint) {
        out.push(current.value);
      } else {
        throw new Error('Something went wrong.');
      }

      current = current.next;
    }

    return out;
  }

  processOne(codePoint) {
    const newTargets = [];
    let ret = codePoint;
    let value = codePoint;

    while (value != null) {
      if (value instanceof JumpCodePoint) {
        const result = this.getTarget(value);

        if (result == null) {
          value = value.next;
        } else {
          const [newValue, newValueTargets] = result;
          value.replace(newValue);

          if (value === codePoint) {
            ret = newValue;
          }

          newTargets.push(...newValueTargets);
          value = newValue.next;
        }
      } else {
        value = value.next;
      }
    }

    return [ret, newTargets];
  }

  getTarget(value) {
    if (value.isForwardJump && value.offset > MAX_JUMP || value.isReverseJump && value.offset < -MAX_JUMP) {
      const isMax = value.isForwardJump;
      const newOffset = isMax ? JUMP_OFFSET : -JUMP_OFFSET;

      if (value.target instanceof NewJump) {
        throw new Error('Something went wrong. Unexpected jump target.');
      }

      const newValueTargets = this.getNewTarget(new NewJump(value.pc + newOffset, isMax, value.target));
      const newValueTarget = newValueTargets[0];
      const newValue = new JumpCodePoint(value.type, newValueTarget);
      newValueTarget.source = newValue;
      value.target.sources.delete(value);
      [...value.sources].forEach(source => {
        source.target = newValue;
        newValue.sources.add(source);
      });
      return [newValue, newValueTargets];
    }

    return undefined;
  }

  getNewTarget(value) {
    if (value.isForwardJump && value.offset > MAX_JUMP || value.isReverseJump && value.offset < -MAX_JUMP) {
      const isMax = value.isForwardJump;
      const newOffset = isMax ? JUMP_OFFSET : -JUMP_OFFSET;

      if (value.target instanceof NewJump) {
        throw new Error('Something went wrong. Unexpected jump target.');
      }

      const newValueTarget = new NewJump(value.pc + newOffset, isMax, value.target);
      value.target = newValueTarget;
      newValueTarget.source = value;
      const newTargets = this.getNewTarget(newValueTarget);
      return [value].concat(newTargets);
    }

    return [value];
  }

  getCodePoint(bytecode) {
    const sources = {};
    const codePoints = {};
    const firstBytecode = bytecode[0];
    let first;

    if (firstBytecode instanceof Jump) {
      const jumpCodePoint = new JumpCodePoint(firstBytecode.op);
      sources[firstBytecode.pc.getPC()] = [jumpCodePoint];
      first = jumpCodePoint;
    } else {
      first = new BufferCodePoint(firstBytecode);
    }

    codePoints[0] = first;
    let pc = first.length;
    let prev = first;

    for (const value of bytecode.slice(1)) {
      let codePoint;

      if (value instanceof Jump) {
        const targetPC = value.pc.getPC();
        let jumpCodePoint;

        if (targetPC < pc) {
          jumpCodePoint = new JumpCodePoint(value.op, codePoints[targetPC]);
          codePoints[targetPC].sources.add(jumpCodePoint);
        } else {
          jumpCodePoint = new JumpCodePoint(value.op);

          if (sources[targetPC] == null) {
            sources[targetPC] = [];
          }

          sources[targetPC].push(jumpCodePoint);
        }

        codePoint = jumpCodePoint;
      } else {
        codePoint = new BufferCodePoint(value);
      }

      const pcSources = sources[pc];

      if (pcSources != null) {
        delete sources[pc];
        pcSources.forEach(source => {
          source.target = codePoint;
          codePoint.sources.add(source);
        });
      }

      codePoints[pc] = codePoint;
      pc += codePoint.length;
      codePoint.prev = prev;
      prev.next = codePoint;
      prev = codePoint;
    }

    return first;
  }

  resolvePC(codePoint) {
    codePoint.resetPC();
    let current = codePoint;

    while (current != null) {
      current.resolvePC();
      current = current.next;
    }
  }

}

const compilers = [declarations, decorator, expression, file, statement];
class BaseScriptBuilder {
  constructor(context, helpers, ast, sourceFile, allHelpers = []) {
    this.context = context;
    this.helpers = helpers;
    this.ast = ast;
    this.sourceFile = sourceFile;
    this.allHelpers = allHelpers;
    Object.defineProperty(this, "jumpTable", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: new JumpTable()
    });
    Object.defineProperty(this, "currentScope", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "compilers", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "bytecode", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "pc", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "jumpTablePC", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: new DeferredProgramCounter()
    });
    Object.defineProperty(this, "capturedBytecode", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: undefined
    });
    Object.defineProperty(this, "nodes", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: new Map()
    });
    Object.defineProperty(this, "moduleMap", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: {}
    });
    Object.defineProperty(this, "reverseModuleMap", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: {}
    });
    Object.defineProperty(this, "exportMap", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: {}
    });
    Object.defineProperty(this, "nextModuleIndex", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 0
    });
    Object.defineProperty(this, "currentModuleIndex", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 0
    });
    this.bytecode = [];
    this.pc = 0;
    this.currentScope = undefined;
    this.compilers = compilers.reduce((acc, kindCompilers) => acc.concat(kindCompilers), []).reduce((acc, KindCompiler) => {
      const kindCompiler = new KindCompiler();

      if (acc[kindCompiler.kind] != null) {
        throw new Error(`Found duplicate compiler for kind ${kindCompiler.kind}`);
      }

      acc[kindCompiler.kind] = kindCompiler;
      return acc;
    }, {});
  }

  get scope() {
    if (this.currentScope == null) {
      throw new Error('Scope has not been set');
    }

    return this.currentScope;
  }

  get moduleIndex() {
    return this.currentModuleIndex;
  }

  process() {
    const sourceFile = this.sourceFile;
    const {
      bytecode
    } = this.capture(() => {
      this.moduleMap[sourceFile.getFilePath()] = this.nextModuleIndex;
      this.reverseModuleMap[this.nextModuleIndex] = sourceFile.getFilePath();
      this.currentModuleIndex = this.nextModuleIndex;
      this.nextModuleIndex += 1;
      this.currentScope = this.createScope(sourceFile, 0, undefined);
      this.nodes.set(sourceFile, 0);
      const options = {};
      this.currentScope.emit(this, sourceFile, options, innerOptions => {
        // []
        this.emitHelper(sourceFile, this.pushValueOptions(options), this.helpers.setGlobalObject); // [globalObjectVal]

        this.scope.getGlobal(this, sourceFile, this.pushValueOptions(options)); // []

        this.emitHelper(sourceFile, this.pushValueOptions(options), this.helpers.addEmptyModule); // []

        this.allHelpers.forEach(helper => {
          helper.emitGlobal(this, sourceFile, innerOptions);
        });
        this.visit(sourceFile, innerOptions);
      });
    });
    this.withProgramCounter(pc => {
      this.emitJmp(sourceFile, 'JMP', pc.getLast());
      this.jumpTablePC.setPC(pc.getCurrent());
      this.jumpTable.emitTable(this, sourceFile);
    });
    this.emitBytecode(bytecode);
  }

  getFinalBytecode() {
    const bytecode = new JumpResolver().process(this.bytecode.map(([_$$1, value]) => value));
    let pc = 0;
    const buffers = bytecode.map(valueIn => {
      let value = valueIn;

      if (value instanceof Jump) {
        const offsetPC = new BN(value.pc.getPC()).sub(new BN(pc)); // @ts-ignore

        const jumpPC = offsetPC.toTwos(16);
        const byteCodeBuffer = BYTECODE_TO_BYTECODE_BUFFER[OPCODE_TO_BYTECODE[value.op]];

        if (byteCodeBuffer == null) {
          throw new Error('Something went wrong, could not find bytecode buffer');
        }

        value = Buffer.concat([byteCodeBuffer, jumpPC.toArrayLike(Buffer, 'le', 2)]);
      }

      pc += value.length;
      return value;
    });
    return Buffer.concat(buffers);
  }

  visit(node, options) {
    const compiler = this.compilers[node.compilerNode.kind];

    if (compiler == null) {
      this.reportUnsupported(node);
    } else {
      compiler.visitNode(this, node, options);
    }
  }

  withScope(node, options, func) {
    let index = this.nodes.get(node);

    if (index == null) {
      index = 0;
    } else {
      index += 1;
    }

    this.nodes.set(node, index);
    const currentScope = this.currentScope;
    this.currentScope = this.createScope(node, index, currentScope);
    this.currentScope.emit(this, node, options, func);
    this.currentScope = currentScope;
  }

  withProgramCounter(func) {
    const pc = new ProgramCounterHelper(() => this.pc);
    func(pc);
    pc.setLast();
  }

  emitOp(node, code, buffer) {
    const bytecode = OPCODE_TO_BYTECODE[code];

    if (bytecode == null) {
      throw new UnknownOpError(code);
    }

    this.emitOpByte(node, bytecode, buffer);
  }

  emitPushInt(node, valueIn) {
    const value = new BN(valueIn);

    if (value.eq(utils.NEGATIVE_ONE)) {
      return this.emitOp(node, 'PUSHM1');
    } else if (value.eq(utils.ZERO)) {
      // TODO: Empty byte breaks equality with 0. Not sure if it's a bug in the vm or
      //       we need to explicitly push a buffer with one 0 byte rather than PUSH0
      // this.emitOp(node, 'PUSH0');
      return this.emitPush(node, utils.toSignedBuffer(value));
    } else if (value.gt(utils.ZERO) && value.lt(utils.SIXTEEN)) {
      return this.emitOpByte(node, OPCODE_TO_BYTECODE.PUSH1 - 1 + value.toNumber());
    }

    return this.emitPush(node, utils.toSignedBuffer(value));
  }

  emitPushBoolean(node, value) {
    this.emitOp(node, value ? 'PUSH1' : 'PUSH0');
  }

  emitPushString(node, value) {
    return this.emitPush(node, this.toBuffer(value));
  }

  emitJmp(node, code, pc) {
    this.emitJump(node, new Jmp(code, pc));
  }

  emitHelper(node, options, helper) {
    helper.emit(this, node, options);
  }

  emitBytecode(bytecode) {
    const pc = this.pc;
    bytecode.forEach(([node, code]) => {
      if (code instanceof Call) {
        this.emitJump(node, code);
      } else if (code instanceof Jmp) {
        this.emitJump(node, code.plus(pc));
      } else if (code instanceof Jump) {
        throw new Error('Something went wrong.');
      } else {
        this.emitRaw(node, code);
      }
    });
  }

  emitCall(node) {
    this.emitJump(node, new Call(this.jumpTablePC));
  }

  emitSysCall(node, name) {
    const sysCallBuffer = Buffer.from(name, 'ascii');
    const writer = new BinaryWriter();
    writer.writeVarBytesLE(sysCallBuffer);
    this.emitOp(node, 'SYSCALL', writer.toBuffer());
  }

  loadModule(sourceFile) {
    const options = {};
    let moduleIndex = this.moduleMap[sourceFile.getFilePath()];

    if (moduleIndex == null) {
      moduleIndex = this.nextModuleIndex;
      this.nextModuleIndex += 1;
      this.moduleMap[sourceFile.getFilePath()] = moduleIndex;
      this.reverseModuleMap[moduleIndex] = sourceFile.getFilePath();
      const currentScope = this.currentScope;
      this.currentScope = this.createScope(sourceFile, 0, undefined);
      const currentModuleIndex = this.currentModuleIndex;
      this.currentModuleIndex = moduleIndex; // [globalObjectVal]

      this.scope.getGlobal(this, sourceFile, this.pushValueOptions(options)); // [globalObjectVal, globalObjectVal]

      this.emitOp(sourceFile, 'DUP'); // [globalObjectVal]

      this.emitHelper(sourceFile, this.pushValueOptions(options), this.helpers.addEmptyModule);
      this.currentScope.emit(this, sourceFile, options, innerOptions => {
        // []
        this.scope.setGlobal(this, sourceFile, options);
        this.visit(sourceFile, innerOptions);
      });
      this.currentScope = currentScope;
      this.currentModuleIndex = currentModuleIndex;
    } // [globalObjectVal]


    this.scope.getGlobal(this, sourceFile, this.pushValueOptions(options)); // [exports]

    this.emitHelper(sourceFile, this.pushValueOptions(options), this.helpers.getModule({
      moduleIndex
    }));
  }

  capture(func) {
    const originalCapturedBytecode = this.capturedBytecode;
    this.capturedBytecode = [];
    const originalPC = this.pc;
    this.pc = 0;
    func();
    const capturedBytecode = this.capturedBytecode;
    this.capturedBytecode = originalCapturedBytecode;
    const capturedLength = this.pc;
    this.pc = originalPC;
    return {
      length: capturedLength,
      bytecode: capturedBytecode
    };
  }

  toBuffer(value) {
    return Buffer.from(value, 'utf8');
  }

  plainOptions(options) {
    return _objectSpread({}, options, {
      pushValue: false,
      setValue: false,
      catchPC: undefined
    });
  }

  pushValueOptions(options) {
    return _objectSpread({}, options, {
      pushValue: true
    });
  }

  noPushValueOptions(options) {
    return _objectSpread({}, options, {
      pushValue: false
    });
  }

  setValueOptions(options) {
    return _objectSpread({}, options, {
      setValue: true
    });
  }

  noSetValueOptions(options) {
    return _objectSpread({}, options, {
      setValue: false
    });
  }

  noValueOptions(options) {
    return _objectSpread({}, options, {
      pushValue: false,
      setValue: false
    });
  }

  breakPCOptions(options, pc) {
    return _objectSpread({}, options, {
      breakPC: pc
    });
  }

  continuePCOptions(options, pc) {
    return _objectSpread({}, options, {
      continuePC: pc
    });
  }

  catchPCOptions(options, pc) {
    return _objectSpread({}, options, {
      catchPC: pc
    });
  }

  castOptions(options, cast) {
    return _objectSpread({}, options, {
      cast
    });
  }

  noCastOptions(options) {
    return _objectSpread({}, options, {
      cast: undefined
    });
  }

  superClassOptions(options, superClass) {
    return _objectSpread({}, options, {
      superClass
    });
  }

  noSuperClassOptions(options) {
    return _objectSpread({}, options, {
      superClass: undefined
    });
  }

  reportError(node, message, code) {
    this.context.reportError(node, message, code);
  }

  reportUnsupported(node) {
    this.context.reportUnsupported(node);
  }

  getType(node, required = false) {
    return this.context.getType(node, required);
  }

  getSymbol(node, required = false) {
    return this.context.getSymbol(node, required);
  }

  isOnlyGlobal(node, type, name) {
    return this.context.isOnlyGlobal(node, type, name);
  }

  isGlobal(node, type, name) {
    return this.context.isGlobal(node, type, name);
  }

  isGlobalSymbol(node, symbol, name) {
    return this.context.isGlobalSymbol(node, symbol, name);
  }

  hasExport(sourceFile, name) {
    return (this.exportMap[sourceFile.getFilePath()] || new Set()).has(name);
  }

  addExport(name) {
    const filePath = this.assertNotNull(this.reverseModuleMap[this.currentModuleIndex]);
    let fileExports = this.exportMap[filePath];

    if (fileExports == null) {
      fileExports = new Set();
      this.exportMap[filePath] = fileExports;
    }

    fileExports.add(name);
  }

  assertUnreachable(value) {
    throw new Error('Should not be reached.');
  }

  assertNotNull(value) {
    return this.context.assertNotNull(value);
  }

  filterNotNull(value) {
    return value != null;
  }

  emitPush(node, value) {
    if (value.length <= OPCODE_TO_BYTECODE.PUSHBYTES75) {
      this.emitOpByte(node, value.length, value);
    } else if (value.length < 0x100) {
      this.emitOp(node, 'PUSHDATA1', new ScriptBuilder().emitUInt8(value.length).emit(value).build());
    } else if (value.length < 0x10000) {
      this.emitOp(node, 'PUSHDATA2', new ScriptBuilder().emitUInt16LE(value.length).emit(value).build()); // TODO: Check this condition if (data.Length < 0x100000000L)
    } else {
      this.emitOp(node, 'PUSHDATA4', new ScriptBuilder().emitUInt32LE(value.length).emit(value).build());
    }
  }

  emitOpByte(node, byteCodeIn, buffer) {
    const byteCode = `${byteCodeIn == null ? '' : byteCodeIn}`;
    const byteCodeBuffer = BYTECODE_TO_BYTECODE_BUFFER[byteCode];

    if (byteCodeBuffer == null) {
      throw new UnknownOpError(byteCode);
    }

    let value = byteCodeBuffer;

    if (buffer != null) {
      value = Buffer.concat([byteCodeBuffer, buffer]);
    }

    this.emitRaw(node, value);
  }

  emitRaw(node, value) {
    this.push(node, value);
    this.pc += value.length;
  }

  emitJump(node, jump) {
    this.push(node, jump);
    this.pc += 3;
  }

  push(node, value) {
    if (this.capturedBytecode != null) {
      this.capturedBytecode.push([node, value]);
    } else {
      this.bytecode.push([node, value]);
    }
  }

}

class IdentifierName {
  constructor(value) {
    this.value = value;
    Object.defineProperty(this, "nameBrand", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 0
    });
  }

}

class ResolvedScope {
  constructor(variableCount, parent) {
    this.variableCount = variableCount;
    this.parent = parent;
    Object.defineProperty(this, "position", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 0
    });
    Object.defineProperty(this, "variables", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: {}
    });
    Object.defineProperty(this, "uniqueVariables", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: new Map()
    });
    Object.defineProperty(this, "scopeLength", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "addScope", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    Object.defineProperty(this, "scopeCount", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });

    if (this.parent == null) {
      this.addScope = true;
      this.scopeCount = 1;
      this.scopeLength = 1;
    } else {
      this.addScope = variableCount > 0;
      this.scopeCount = this.addScope ? 1 : 0;
      this.scopeLength = this.parent.scopeLength + this.scopeCount;
    }
  }

  add(name) {
    const identifier = new IdentifierName(name);
    const existing = this.variables[name];

    if (existing != null) {
      return identifier;
    }

    this.variables[identifier.value] = this.position;
    this.position += 1;

    if (this.position > this.variableCount) {
      throw new Error(`Something went wrong. Name: ${name} Position: ${this.position} Count: ${this.variableCount}`);
    }

    return identifier;
  }

  addUnique() {
    const name = {
      nameBrand: 0
    };
    this.uniqueVariables.set(name, this.position);
    this.position += 1;

    if (this.position > this.variableCount) {
      throw new Error(`Something went wrong. Position: ${this.position} Count: ${this.variableCount}`);
    }

    return name;
  } // [value]


  set(sb, node, optionsIn, name, scopeLength = this.scopeLength, scopePosition = 0) {
    const options = sb.pushValueOptions(optionsIn);
    const position = this.getPosition(name);

    if (position == null) {
      if (this.parent == null) {
        sb.reportError(node, `Unknown reference: ${name}`, DiagnosticCode.REFERENCE_ERROR);
      } else {
        this.parent.set(sb, node, options, name, scopeLength, scopePosition + this.scopeCount);
      }
    } else {
      // [normal]
      sb.emitHelper(node, options, sb.helpers.createNormalCompletion); // [scope, normal]

      this.loadScope(sb, node, scopeLength, scopePosition); // [position, scope, normal]

      sb.emitPushInt(node, position); // [normal, position, scope]

      sb.emitOp(node, 'ROT'); // []

      sb.emitOp(node, 'SETITEM');
    }
  }

  get(sb, node, options, name, scopeLength = this.scopeLength, scopePosition = 0) {
    const position = this.getPosition(name);

    if (position == null) {
      if (this.parent == null) {
        if (typeof name === 'string' && sb.helpers.globalProperties.has(name)) {
          // [val]
          sb.emitHelper(node, options, sb.helpers.getGlobalProperty({
            property: name
          }));
        } else {
          sb.reportError(node, `Unknown reference: ${name}`, DiagnosticCode.REFERENCE_ERROR);
        }
      } else {
        this.parent.get(sb, node, options, name, scopeLength, scopePosition + this.scopeCount);
      }
    } else {
      this.loadScope(sb, node, scopeLength, scopePosition);
      sb.emitPushInt(node, position);
      sb.emitOp(node, 'PICKITEM');
      sb.emitHelper(node, options, sb.helpers.pickCompletionVal);
    }
  }

  getThis(sb, node, options) {
    // [[scopes, this]]
    this.loadAll(sb, node); // [1, [scopes, this]]

    sb.emitPushInt(node, 1); // [this]

    sb.emitOp(node, 'PICKITEM');
  }

  setThis(sb, node, options) {
    // [[scopes, this], val]
    this.loadAll(sb, node); // [1, [scopes, this], val]

    sb.emitPushInt(node, 1); // [val, 1, [scopes, this]]

    sb.emitOp(node, 'ROT'); // []

    sb.emitOp(node, 'SETITEM');
  }

  getGlobal(sb, node, options) {
    if (this.parent == null) {
      // [[scopes, this, global]]
      this.loadAll(sb, node); // [2, [scopes, this, global]]

      sb.emitPushInt(node, 2); // [this]

      sb.emitOp(node, 'PICKITEM');
    } else {
      this.parent.getGlobal(sb, node, options);
    }
  }

  setGlobal(sb, node, options) {
    if (this.parent == null) {
      // [[scopes, this, global], val]
      this.loadAll(sb, node); // [[scopes, this, global], val, [scopes, this, global]]

      sb.emitOp(node, 'TUCK'); // [val, [scopes, this, global], val, [scopes, this, global]]

      sb.emitOp(node, 'OVER'); // [2, val, [scopes, this, global], val, [scopes, this, global]]

      sb.emitPushInt(node, 2); // [val, 2, [scopes, this, global], val, [scopes, this, global]]

      sb.emitOp(node, 'SWAP'); // [val, [scopes, this, global]]

      sb.emitOp(node, 'SETITEM'); // [1, val, [scopes, this, global]]

      sb.emitPushInt(node, 1); // [val, 1, [scopes, this, global]]

      sb.emitOp(node, 'SWAP'); // []

      sb.emitOp(node, 'SETITEM');
    } else {
      this.parent.setGlobal(sb, node, options);
    }
  }

  hasBinding(name) {
    return this.variables[name] != null || this.parent != null && this.parent.hasBinding(name);
  }

  pushAll(sb, node, options) {
    sb.emitOp(node, 'DUPFROMALTSTACK');
  }

  emit(sb, node, options, func) {
    if (this.addScope) {
      this.surround(sb, node, options, func);
    } else {
      func(options);
    }
  }

  surround(sb, node, options, func) {
    if (this.parent == null) {
      // [global]
      sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.createUndefined); // [this, global]

      sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.createUndefined); // [0, this, global]

      sb.emitPushInt(node, 0); // [scopes, this, global]

      sb.emitOp(node, 'NEWSTRUCT'); // [3, scopes, this, global]

      sb.emitPushInt(node, 3); // [[scopes, this, global]]

      sb.emitOp(node, 'PACK'); // [[scopes, this, global], [scopes, this, global]]

      sb.emitOp(node, 'DUP'); // [[scopes, this, global]]

      sb.emitOp(node, 'TOALTSTACK');
    } else {
      // [[scopes, this]]
      sb.emitOp(node, 'DUPFROMALTSTACK');
    } // [0, [scopes, this]]


    sb.emitPushInt(node, 0); // [scopes]

    sb.emitOp(node, 'PICKITEM'); // [0, scopes]

    sb.emitPushInt(node, 0); // [scope, scopes]

    sb.emitOp(node, 'NEWARRAY'); // [idx, scope, scopes]

    sb.emitPushInt(node, 0); // TODO: Should we just loop at compile time?

    sb.withProgramCounter(loopPC => {
      // [idx, idx, scope, scopes]
      sb.emitOp(node, 'DUP'); // [count, idx, idx, scope, scopes]

      sb.emitPushInt(node, this.variableCount); // [idx < count, idx, scope, scopes]

      sb.emitOp(node, 'LT'); // [idx, scope, scopes]

      sb.emitJmp(node, 'JMPIFNOT', loopPC.getLast()); // [scope, idx, scope, scopes]

      sb.emitOp(node, 'OVER'); // TODO: throw ReferenceError once it's defined on global

      sb.emitPushString(node, 'Referenced variable before it was defined'); // [error, scope, idx, scope, scopes]

      sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.createString); // [throw, scope, idx, scope, scopes]

      sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.createThrowCompletion); // [idx, scope, scopes]

      sb.emitOp(node, 'APPEND'); // [idx, scope, scopes]

      sb.emitOp(node, 'INC'); // [idx, scope, scopes]

      sb.emitJmp(node, 'JMP', loopPC.getFirst());
    }); // [scope, scopes]

    sb.emitOp(node, 'DROP'); // []

    sb.emitOp(node, 'APPEND');
    const {
      breakPC,
      continuePC,
      catchPC
    } = options;
    const nonLocal = breakPC != null || continuePC != null || catchPC != null;
    sb.withProgramCounter(pc => {
      let innerOptions = options;

      if (breakPC != null) {
        innerOptions = sb.breakPCOptions(innerOptions, pc.getLast());
      }

      if (continuePC != null) {
        innerOptions = sb.continuePCOptions(innerOptions, pc.getLast());
      }

      if (catchPC != null) {
        innerOptions = sb.catchPCOptions(innerOptions, pc.getLast());
      }

      func(innerOptions);

      if (nonLocal) {
        sb.emitPushInt(node, NORMAL_COMPLETION);
      }
    });

    if (this.parent == null) {
      // [[scopes, undefined]]
      sb.emitOp(node, 'FROMALTSTACK');
      sb.emitOp(node, 'DROP');
    } else {
      // [[scopes, undefined]]
      sb.emitOp(node, 'DUPFROMALTSTACK'); // [0, [scopes, undefined]]

      sb.emitPushInt(node, 0); // [scopes]

      sb.emitOp(node, 'PICKITEM'); // [scopes, scopes]

      sb.emitOp(node, 'DUP'); // [size, scopes]

      sb.emitOp(node, 'ARRAYSIZE'); // [size - 1, scopes]

      sb.emitOp(node, 'DEC'); // []

      sb.emitOp(node, 'REMOVE');
    }

    this.emitNonLocal(sb, node, BREAK_COMPLETION, breakPC);
    this.emitNonLocal(sb, node, CONTINUE_COMPLETION, continuePC);
    this.emitNonLocal(sb, node, CATCH_COMPLETION, catchPC);

    if (nonLocal) {
      sb.emitOp(node, 'DROP');
    }
  }

  emitNonLocal(sb, node, completion, pc) {
    if (pc != null) {
      sb.withProgramCounter(innerPC => {
        sb.emitOp(node, 'DUP');
        sb.emitPushInt(node, completion);
        sb.emitOp(node, 'NUMEQUAL');
        sb.emitJmp(node, 'JMPIF', pc);
      });
    }
  }

  getPosition(name) {
    if (typeof name === 'string') {
      return this.variables[name];
    } else if (name instanceof IdentifierName) {
      return this.variables[name.value];
    }

    return this.uniqueVariables.get(name);
  }

  loadScope(sb, node, scopeLength, scopePosition) {
    this.loadAll(sb, node); // [0,[scopes, this]]

    sb.emitPushInt(node, 0); // [scopes]

    sb.emitOp(node, 'PICKITEM'); // [scopeIndex, scopes]

    sb.emitPushInt(node, scopeLength - scopePosition - 1); // [scope]

    sb.emitOp(node, 'PICKITEM');
  }

  loadAll(sb, node) {
    // [[scopes, this]]
    sb.emitOp(node, 'DUPFROMALTSTACK');
  }

}

class CapturingScope {
  constructor(node, index, parent) {
    this.node = node;
    this.index = index;
    this.parent = parent;
    Object.defineProperty(this, "variableCount", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: 0
    });
    Object.defineProperty(this, "bindings", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: new Set()
    });
  }

  add(name) {
    this.variableCount += 1;
    this.bindings.add(name);
    return {
      nameBrand: 0
    };
  }

  addUnique() {
    this.variableCount += 1;
    return {
      nameBrand: 0
    };
  }

  set(sb, node) {
    sb.emitOp(node, 'NOP');
  }

  get(sb, node) {
    sb.emitOp(node, 'NOP');
  }

  getThis(sb, node) {
    sb.emitOp(node, 'NOP');
  }

  setThis(sb, node) {
    sb.emitOp(node, 'NOP');
  }

  getGlobal(sb, node) {
    sb.emitOp(node, 'NOP');
  }

  setGlobal(sb, node) {
    sb.emitOp(node, 'NOP');
  }

  hasBinding(name) {
    return this.bindings.has(name) || this.parent != null && this.parent.hasBinding(name);
  }

  pushAll(sb, node) {
    sb.emitOp(node, 'NOP');
  }

  emit(sb, node, options, func) {
    sb.emitOp(node, 'NOP');
    func(options);
    sb.emitOp(node, 'NOP');
  }

  resolve(parent) {
    return new ResolvedScope(this.variableCount, parent);
  }

}

class ScopeCapturingScriptBuilder extends BaseScriptBuilder {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "scopes", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: []
    }), Object.defineProperty(this, "resolvedScopes", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: new Map()
    }), _temp;
  }

  process() {
    super.process();
    this.resolveScopes();
  }

  getScopes() {
    return this.resolvedScopes;
  }

  createScope(node, index, parent) {
    const scope = new CapturingScope(node, index, parent);
    this.scopes.push(scope);
    return scope;
  }

  resolveScopes() {
    this.scopes.forEach(scope => {
      this.resolveScope(scope);
    });
  }

  resolveScope(scope) {
    let forNode = this.resolvedScopes.get(scope.node);

    if (forNode == null) {
      forNode = new Map();
      this.resolvedScopes.set(scope.node, forNode);
    }

    let resolved = forNode.get(scope.index);

    if (resolved == null) {
      const parent = scope.parent;

      if (parent == null) {
        resolved = scope.resolve();
      } else {
        resolved = scope.resolve(this.resolveScope(parent));
      }

      forNode.set(scope.index, resolved);
    }

    return resolved;
  }

}

class EmittingScriptBuilder extends BaseScriptBuilder {
  constructor({
    context,
    scopes,
    helpers,
    ast,
    sourceFile,
    allHelpers
  }) {
    super(context, helpers, ast, sourceFile, allHelpers);
    Object.defineProperty(this, "scopes", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.scopes = scopes;
  }

  createScope(node, index) {
    return this.assertNotNull(this.assertNotNull(this.scopes.get(node)).get(index));
  }

}

class HelperCapturingScriptBuilder extends ScopeCapturingScriptBuilder {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "capturedHelpersSet", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: new Set()
    }), Object.defineProperty(this, "capturedHelpers", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: []
    }), _temp;
  }

  getHelpers() {
    return [...this.capturedHelpers];
  }

  emitHelper(node, options, helper) {
    if (!this.capturedHelpersSet.has(helper)) {
      this.capturedHelpersSet.add(helper);
      this.capturedHelpers.push(helper);
      helper.emitGlobal(this, node, options);
    }

    helper.emit(this, node, options);
  }

}

class CompilerDiagnostic {
  constructor(node, messageText, code, category) {
    this.node = node;
    this.messageText = messageText;
    this.code = code;
    this.category = category;
  }

  get file() {
    return this.node.getSourceFile().compilerNode;
  }

  get start() {
    return this.node.getStart();
  }

  get length() {
    return this.node.getWidth();
  }

  get source() {
    return this.node.getText();
  }

}

// tslint:disable ban-types
class Context {
  constructor(globals, libs, libAliases) {
    this.globals = globals;
    this.libs = libs;
    this.libAliases = libAliases;
    Object.defineProperty(this, "diagnostics", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: []
    });
  }

  reportError(node, message, code) {
    this.diagnostics.push(new CompilerDiagnostic(node, message, code, DiagnosticCategory.Error));
  }

  reportWarning(node, message, code) {
    this.diagnostics.push(new CompilerDiagnostic(node, message, code, DiagnosticCategory.Warning));
  }

  reportUnsupported(node) {
    this.reportError(node, 'Unsupported syntax', DiagnosticCode.UNSUPPORTED_SYNTAX);
  }

  reportTypeError(node) {
    this.reportError(node, 'Could not infer type. Please add an explicit type annotation.', DiagnosticCode.UNKNOWN_TYPE);
  }

  reportTypeWarning(node) {
    this.reportWarning(node, 'Could not infer type. Deoptimized implementation will be used. Add an explicit type annotation ' + 'to optimize the output.', DiagnosticCode.UNKNOWN_TYPE);
  }

  getType(node, required = false) {
    let type = this.getNotAnyType(node.getType());

    if (type == null && TypeGuards.isExpression(node)) {
      type = this.getNotAnyType(node.getContextualType());
    }

    if (type == null) {
      if (required) {
        this.reportTypeError(node);
      } else {
        this.reportTypeWarning(node);
      }
    }

    return type;
  }

  getTypeOfSymbol(symbol, node, required = false) {
    if (symbol == null) {
      return undefined;
    }

    const type = this.getNotAnyType(symbol.getTypeAtLocation(node));

    if (type == null) {
      if (required) {
        this.reportTypeError(node);
      } else {
        this.reportTypeWarning(node);
      }
    }

    return type;
  }

  getSymbol(node, required = false) {
    const symbol = node.getSymbol();

    if (symbol == null) {
      const message = 'Could not determine source symbol.';

      if (required) {
        this.reportError(node, message, DiagnosticCode.UNKNOWN_SYMBOL);
      } else {
        this.reportWarning(node, message, DiagnosticCode.UNKNOWN_SYMBOL);
      }

      return undefined;
    }

    const aliased = symbol.getAliasedSymbol();

    if (aliased != null) {
      return aliased;
    }

    return symbol;
  }

  getSymbolForType(node, type, required = false) {
    if (type == null) {
      return undefined;
    }

    const symbol = type.getSymbol();

    if (symbol == null) {
      const message = `Could not determine source symbol for type: ${type.getText()}.`;

      if (required) {
        this.reportError(node, message, DiagnosticCode.UNKNOWN_SYMBOL);
      } else {
        this.reportWarning(node, message, DiagnosticCode.UNKNOWN_SYMBOL);
      }

      return undefined;
    }

    const aliased = symbol.getAliasedSymbol();

    if (aliased != null) {
      return aliased;
    }

    return symbol;
  }

  assertUnreachable(value) {
    throw new Error('Should not be reached.');
  }

  assertNotNull(value) {
    if (value == null) {
      throw new Error('Something went wrong. Unexpected null.');
    }

    return value;
  }

  isOnlyGlobal(node, type, name) {
    return this.isSymbolic(type) && this.isGlobalSymbol(node, this.getSymbolForType(node, type), name);
  } // TODO: This should check unions


  isGlobal(node, type, name) {
    return this.isSymbolic(type) && this.isGlobalSymbol(node, this.getSymbolForType(node, type), name);
  }

  isGlobalSymbol(node, symbol, name) {
    return symbol === this.globals[name];
  }

  isOnlyLib(node, type, name) {
    return this.isSymbolic(type) && this.isLibSymbol(node, this.getSymbolForType(node, type), name);
  }

  isLibSymbol(node, symbol, name) {
    return symbol === this.libs[name];
  }

  isLibAlias(identifier, name) {
    if (identifier == null) {
      return false;
    }

    return this.libAliases[name].has(identifier);
  }

  isSymbolic(type) {
    return type == null || !isLiteral(type) && !isPrimitive(type) && !isTuple(type) && !isUnion(type) && !isIntersection(type);
  }

  getNotAnyType(type) {
    // tslint:disable-next-line no-bitwise
    if (type == null || (type.getFlags() & TypeFlags.Any) !== 0) {
      return undefined;
    }

    return type;
  }

}

// tslint:disable ban-types no-bitwise

const findInterfaceFile = (ast, name) => {
  const files = ast.getSourceFiles();
  return files.find(file => {
    if (!file.isDeclarationFile()) {
      return false;
    }

    let bufferInterface = file.getInterface(name);
    const globalNamespace = file.getNamespace('global');
    let isGlobalAugmentation = false;

    if (bufferInterface == null && globalNamespace != null) {
      bufferInterface = globalNamespace.getInterface(name);
      isGlobalAugmentation = true;
    }

    if (bufferInterface == null) {
      return false;
    }

    return isGlobalAugmentation || (bufferInterface.compilerNode.flags & ts.NodeFlags.GlobalAugmentation) !== 0;
  });
};

const getGlobals = ast => {
  let bufferFile = findInterfaceFile(ast, 'Buffer');

  if (bufferFile == null) {
    bufferFile = ast.addExistingSourceFileIfExists(require.resolve('@types/node/index.d.ts'));
  }

  if (bufferFile == null) {
    throw new Error('Could not find Buffer');
  }

  const buffer = bufferFile.getInterfaceOrThrow('Buffer');
  const typeChecker = ast.getTypeChecker().compilerObject; // @ts-ignore

  const array = new Symbol$1( // @ts-ignore
  ast.global, typeChecker.createArrayType(typeChecker.getAnyType()).symbol).getDeclaredType();
  let neoFile = findInterfaceFile(ast, 'AccountBase');

  if (neoFile == null) {
    ast.addExistingSourceFiles(path__default.join(path__default.dirname(require.resolve('@neo-one/smart-contract')), '**', '*.ts'));
  }

  neoFile = findInterfaceFile(ast, 'AccountBase');

  if (neoFile == null) {
    throw new Error('Could not find NEO type definition file');
  }

  const neoGlobal = neoFile.getNamespaceOrThrow('global');
  return {
    Array: array.getSymbolOrThrow(),
    Buffer: buffer.getSymbolOrThrow(),
    process: bufferFile.getVariableDeclarationOrThrow('process').getSymbolOrThrow(),
    AccountBase: neoGlobal.getInterfaceOrThrow('AccountBase').getSymbolOrThrow(),
    AssetBase: neoGlobal.getInterfaceOrThrow('AssetBase').getSymbolOrThrow(),
    AttributeBase: neoGlobal.getInterfaceOrThrow('AttributeBase').getSymbolOrThrow(),
    BlockBase: neoGlobal.getInterfaceOrThrow('BlockBase').getSymbolOrThrow(),
    ContractBase: neoGlobal.getInterfaceOrThrow('ContractBase').getSymbolOrThrow(),
    HeaderBase: neoGlobal.getInterfaceOrThrow('HeaderBase').getSymbolOrThrow(),
    InputBase: neoGlobal.getInterfaceOrThrow('InputBase').getSymbolOrThrow(),
    OutputBase: neoGlobal.getInterfaceOrThrow('OutputBase').getSymbolOrThrow(),
    TransactionBase: neoGlobal.getInterfaceOrThrow('TransactionBase').getSymbolOrThrow(),
    ValidatorBase: neoGlobal.getInterfaceOrThrow('ValidatorBase').getSymbolOrThrow(),
    StorageContextBase: neoGlobal.getInterfaceOrThrow('StorageContextBase').getSymbolOrThrow(),
    StorageIteratorBase: neoGlobal.getInterfaceOrThrow('StorageIteratorBase').getSymbolOrThrow(),
    syscall: neoGlobal.getFunctionOrThrow('syscall').getSymbolOrThrow()
  };
};

const findLibFile = ast => {
  const files = ast.getSourceFiles();
  return files.find(file => file.getClass('MapStorage') != null);
};

const getLibs = ast => {
  let libFileIn = findLibFile(ast);

  if (libFileIn == null) {
    ast.addExistingSourceFiles(path__default.join(path__default.dirname(require.resolve('@neo-one/smart-contract')), '**', '*.ts'));
  }

  libFileIn = findLibFile(ast);

  if (libFileIn == null) {
    throw new Error('Could not find NEO lib file');
  }

  const libFile = libFileIn;
  return {
    get SmartContract() {
      return libFile.getClassOrThrow('SmartContract').getSymbolOrThrow();
    },

    get MapStorage() {
      return libFile.getClassOrThrow('MapStorage').getSymbolOrThrow();
    },

    get SetStorage() {
      return libFile.getClassOrThrow('SetStorage').getSymbolOrThrow();
    },

    get Fixed() {
      return libFile.getTypeAliasOrThrow('Fixed').getSymbolOrThrow();
    },

    get constant() {
      return libFile.getFunctionOrThrow('constant').getSymbolOrThrow();
    },

    get verify() {
      return libFile.getFunctionOrThrow('verify').getSymbolOrThrow();
    }

  };
};
const getLibAliases = ast => {
  let libFileIn = findLibFile(ast);

  if (libFileIn == null) {
    ast.addExistingSourceFiles(path__default.join(path__default.dirname(require.resolve('@neo-one/smart-contract')), '**', '*.ts'));
  }

  libFileIn = findLibFile(ast);

  if (libFileIn == null) {
    throw new Error('Could not find NEO lib file');
  }

  const libFile = libFileIn;
  return {
    get Address() {
      return new Set(libFile.getTypeAliasOrThrow('Address').getReferencingNodes());
    },

    get Hash256() {
      return new Set(libFile.getTypeAliasOrThrow('Hash256').getReferencingNodes());
    },

    get Signature() {
      return new Set(libFile.getTypeAliasOrThrow('Signature').getReferencingNodes());
    },

    get PublicKey() {
      return new Set(libFile.getTypeAliasOrThrow('PublicKey').getReferencingNodes());
    }

  };
};

const compile = ({
  ast,
  sourceFile,
  context: contextIn
}) => {
  const context = contextIn || new Context(getGlobals(ast), getLibs(ast), getLibAliases(ast));
  const helpers = createHelpers();
  const helperScriptBuilder = new HelperCapturingScriptBuilder(context, helpers, ast, sourceFile);
  helperScriptBuilder.process();
  const scopeScriptBuilder = new ScopeCapturingScriptBuilder(context, helpers, ast, sourceFile, helperScriptBuilder.getHelpers());
  scopeScriptBuilder.process();
  const emittingScriptBuilder = new EmittingScriptBuilder({
    context,
    scopes: scopeScriptBuilder.getScopes(),
    ast,
    sourceFile,
    helpers,
    allHelpers: helperScriptBuilder.getHelpers()
  });
  emittingScriptBuilder.process();
  return {
    code: emittingScriptBuilder.getFinalBytecode(),
    context
  };
};

// tslint:disable ban-types

const findRoot = async (dir, filename) => {
  let start = dir;

  if (typeof start === 'string') {
    if (start[start.length - 1] !== sep) {
      start += sep;
    }

    start = start.split(sep);
  }

  if (!start.length) {
    throw new Error('tsconfig.json not found in path');
  }

  start.pop();
  const currentDir = start.join(sep);
  const file = join(currentDir, filename);
  const exists = await pathExists(file);

  if (exists) {
    return file;
  }

  return findRoot(start, filename);
};

const makeAst = async dir => {
  const tsConfigFilePath = await findRoot(dir, 'tsconfig.json');
  const res = ts.readConfigFile(tsConfigFilePath, value => readFileSync(value, 'utf8'));
  const parseConfigHost = {
    fileExists: existsSync,
    readDirectory: ts.sys.readDirectory,
    readFile: ts.sys.readFile,
    useCaseSensitiveFileNames: true
  };
  const parsed = ts.parseJsonConfigFileContent(res.config, parseConfigHost, dirname(tsConfigFilePath));
  return new Ast({
    compilerOptions: parsed.options
  });
};
const getAst = async dir => {
  const ast = await makeAst(dir);
  ast.addExistingSourceFiles(join(dir, '**', '*.ts')); // For some reason this forces Ast to resolve references. Do not remove.

  ast.getPreEmitDiagnostics();
  return ast;
};

const compileScript = async scriptPath => {
  const ast = await getAst(path__default.dirname(scriptPath));
  const sourceFile = ast.getSourceFileOrThrow(scriptPath);
  return compile({
    ast,
    sourceFile
  });
};

class NodeTranspiler {
  constructor() {
    Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
  }

}

const DEPLOY_METHOD = 'deploy';
class ClassDeclarationTranspiler extends NodeTranspiler {
  constructor(...args) {
    var _temp;

    return _temp = super(...args), Object.defineProperty(this, "kind", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: SyntaxKind.ClassDeclaration
    }), _temp;
  }

  visitNode(transpiler, node) {
    if (transpiler.isSmartContract(node)) {
      this.transpileSmartContract(transpiler, node);
    }
  }

  transpileSmartContract(transpiler, node) {
    transpiler.visit(node.getBaseClass());
    this.transpileDeploy(transpiler, node);
  } // TODO: Lots of edge cases to handle here. E.g. readonly constructor properties


  transpileDeploy(transpiler, node) {
    const existingDeploy = node.getMethod(DEPLOY_METHOD);

    if (existingDeploy != null) {
      transpiler.reportError(existingDeploy, 'The deploy method is reserved in SmartContract instances.', DiagnosticCode.UNSUPPORTED_SYNTAX);
      return;
    }

    const ctor = node.getConstructors().find(ctorDecl => ctorDecl.isImplementation());
    let bodyText = '';
    let parameters = [];

    if (ctor == null) {
      const baseDeploy = this.getBaseDeploy(transpiler, node);

      if (baseDeploy != null) {
        bodyText = `
          super.deploy(${baseDeploy.getParameters().map(param => param.getName()).join(', ')});
        `;
        parameters = baseDeploy.getParameters();
      }
    } else {
      const firstStatement = ctor.getStatements()[0];

      if (firstStatement != null && TypeGuards.isExpressionStatement(firstStatement)) {
        const callExpr = firstStatement.getExpression();

        if (TypeGuards.isCallExpression(callExpr)) {
          const lhsrExpr = callExpr.getExpression();

          if (TypeGuards.isSuperExpression(lhsrExpr)) {
            // TODO: Handle case where constructor needs keep some statements
            firstStatement.replaceWithText(`super.deploy(${callExpr.getArguments().map(arg => arg.getText()).join(', ')});`);
          }
        }
      }

      bodyText = ctor.getStatements().map(statement => statement.getText()).join('\n');
      parameters = ctor.getParameters();
    }

    const deploy = node.addMethod({
      name: DEPLOY_METHOD,
      returnType: 'boolean',
      bodyText,
      parameters: parameters.map(param => {
        const initializer = param.getInitializer();
        let type = param.getType().getText();
        const typeNode = param.getTypeNode();

        if (typeNode != null) {
          type = typeNode.getText();
        }

        return {
          name: param.getNameOrThrow(),
          type,
          initializer: initializer == null ? undefined : initializer.getText(),
          hasQuestionToken: param.hasQuestionToken(),
          isRestParameter: param.isRestParameter()
        };
      }),
      scope: Scope.Public
    });
    node.getInstanceProperties().forEach(property => {
      if (TypeGuards.isPropertyDeclaration(property) && !property.isAbstract() || TypeGuards.isParameterDeclaration(property)) {
        const name = TypeGuards.isPropertyDeclaration(property) ? property.getName() : property.getNameOrThrow();
        const type = property.getType();
        const typeNode = property.getTypeNode();

        if (type == null || typeNode == null) {
          transpiler.reportError(property, 'Could not determine type of property.', DiagnosticCode.UNKNOWN_TYPE);
        } else if (isOnlyPrimitive(type) || transpiler.isFixedType(property, type) || transpiler.isOnlyGlobal(property, type, 'Buffer')) {
          if (TypeGuards.isParameterDeclaration(property)) {
            deploy.addStatements(`
              this.${property.getName()} = ${property.getName()};
            `);
          }

          const init = property.getInitializer();
          let addAccessors = true;

          if (TypeGuards.isPropertyDeclaration(property) && init != null) {
            if (property.isReadonly()) {
              addAccessors = false;
            } else {
              deploy.addStatements(`
                this.${property.getName()} = ${init.getText()};
              `);
            }
          }

          if (addAccessors) {
            node.addGetAccessor({
              name,
              returnType: typeNode.getText(),
              bodyText: `
              return syscall('Neo.Storage.Get', syscall('Neo.Storage.GetContext'), '${name}') as ${typeNode.getText()};
              `,
              scope: property.getScope()
            });
            node.addSetAccessor({
              name,
              parameters: [{
                name,
                type: typeNode.getText()
              }],
              bodyText: `
              syscall('Neo.Storage.Put', syscall('Neo.Storage.GetContext'), '${name}', ${name});
              `,
              scope: property.getScope()
            });
            property.remove();
          }
        } else if (transpiler.isOnlyLib(property, type, 'MapStorage')) {
          property.setInitializer(`new MapStorage(syscall('Neo.Runtime.Serialize', '${name}'))`);
        } else if (transpiler.isOnlyLib(property, type, 'SetStorage')) {
          property.setInitializer(`new SetStorage(syscall('Neo.Runtime.Serialize', '${name}'))`);
        } else {
          transpiler.reportError(property, 'Unsupported SmartContract property.', DiagnosticCode.UNSUPPORTED_SYNTAX);
        }
      }
    });
    deploy.addStatements(`
      return true;
    `);

    if (ctor != null) {
      // TODO: Handle case where constructor needs keep some statements
      ctor.remove();
    }
  }

  getBaseDeploy(transpiler, node) {
    const baseClass = node.getBaseClass();

    if (baseClass == null) {
      return undefined;
    }

    const deploy = baseClass.getInstanceMethod('deploy');

    if (deploy == null) {
      return this.getBaseDeploy(transpiler, baseClass);
    }

    return deploy;
  }

}

var declarations$1 = [ClassDeclarationTranspiler];

const isPublic = (node // tslint:disable-next-line no-bitwise
) => (node.getCombinedModifierFlags() & ts.ModifierFlags.Public) !== 0;

const transpilers = [declarations$1];
class NEOTranspiler {
  constructor(context, ast, smartContract) {
    this.context = context;
    this.ast = ast;
    this.smartContract = smartContract;
    Object.defineProperty(this, "transpilers", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: void 0
    });
    this.transpilers = transpilers.reduce((acc, kindCompilers) => acc.concat(kindCompilers), []).reduce((acc, KindCompiler) => {
      const kindCompiler = new KindCompiler();

      if (acc[kindCompiler.kind] != null) {
        throw new Error(`Found duplicate compiler for kind ${kindCompiler.kind}`);
      }

      acc[kindCompiler.kind] = kindCompiler;
      return acc;
    }, {});
  }

  process() {
    const file = this.smartContract.getSourceFile();
    this.visit(file);
    const smartContract = file.getClassOrThrow(this.smartContract.getNameOrThrow());
    const methods = smartContract.getType().getProperties().map(symbol => this.processProperty(symbol)).reduce((acc, values) => acc.concat(values), []);
    const verifySwitches = [];
    const applicationSwitches = [];
    const functions = [];

    for (const [method, func] of methods) {
      const name = TypeGuards.isParameterDeclaration(method) ? method.getNameOrThrow() : method.getName();
      let methodSwitch;

      if (TypeGuards.isMethodDeclaration(method)) {
        let argsStatement = '';
        let args = '';

        if (method.getParameters().length > 0) {
          const argsTypes = method.getParameters().map(param => this.getTypeText(param, this.getType(param))).join(',');
          argsStatement = `const args = syscall('Neo.Runtime.GetArgument', 1) as [${argsTypes}];\n`;
          args = method.getParameters().map((param, idx) => `args[${idx}]`).join(', ');
        }

        let call = `contract.${name}(${args})`;

        if (!isVoid(method.getReturnType())) {
          call = `syscall('Neo.Runtime.Return', ${call})`;
        }

        methodSwitch = `
          if (method === '${name}') {
            ${argsStatement}${call};
          }
        `;
      } else if (TypeGuards.isGetAccessorDeclaration(method) || TypeGuards.isPropertyDeclaration(method) || TypeGuards.isParameterDeclaration(method)) {
        methodSwitch = `
          if (method === '${name}') {
            syscall('Neo.Runtime.Return', contract.${name});
          }
        `;
      } else {
        const param = method.getParameters()[0];
        const typeText = this.getTypeText(param, this.getType(param));
        methodSwitch = `
          if (method === 'set${name[0].toUpperCase()}${name.slice(1)}') {
            contract.${name} = (syscall('Neo.Runtime.GetArgument', 1) as [${typeText}])[0];
          }
        `;
      }

      applicationSwitches.push(methodSwitch);

      if (func.verify) {
        verifySwitches.push(methodSwitch);
      }

      functions.push(func);
    }

    const applicationFallback = applicationSwitches.length === 0 ? 'throw new Error(' : ` else {
        throw new Error('Unknown method');
      }`;
    let verifyFallback = `
      if (!syscall('Neo.Runtime.CheckWitness', contract.owner)) {
        throw new Error('Invalid witness');
      }
    `;

    if (verifySwitches.length > 0) {
      verifyFallback = `else {
        ${verifyFallback}
      }`;
    }

    const statements = `
      const contract = new ${this.smartContract.getName()}();
      const method = syscall('Neo.Runtime.GetArgument', 0) as string;
      if (syscall('Neo.Runtime.GetTrigger') === 0x10) {
        ${applicationSwitches.join(' else ')}
        ${applicationFallback}
      } else if (syscall('Neo.Runtime.GetTrigger') === 0x00) {
        ${verifySwitches.join(' else ')}
        ${verifyFallback}
      } else {
        throw new Error('Unsupported trigger');
      }
    `;
    file.addStatements(statements);
    return {
      ast: this.ast,
      sourceFile: file,
      abi: {
        functions
      },
      context: this.context
    };
  }

  visit(node) {
    if (node == null) {
      return;
    }

    const transpiler = this.transpilers[node.compilerNode.kind];

    if (transpiler == null) {
      node.getChildren().forEach(child => {
        this.visit(child);
      });
    } else {
      transpiler.visitNode(this, node);
    }
  }

  addEvent(node, name, parameters) {// TODO: Change how events work.
    // if (this.events[name] != null) {
    //   this.reportError(node, 'Duplicate event.', DiagnosticCode.UNSUPPORTED_SYNTAX);
    // }
    // this.events[name] = parameters;
  }

  isSmartContract(node) {
    return node === this.smartContract || node.getDerivedClasses().some(derived => this.isSmartContract(derived));
  }

  getType(node) {
    return this.context.getType(node);
  }

  getTypeOfSymbol(symbol, node) {
    return this.context.getTypeOfSymbol(symbol, node);
  }

  getSymbol(node) {
    return this.context.getSymbol(node);
  }

  isOnlyGlobal(node, type, name) {
    return this.context.isOnlyGlobal(node, type, name);
  }

  isLibSymbol(node, symbol, name) {
    return this.context.isLibSymbol(node, symbol, name);
  }

  isOnlyLib(node, type, name) {
    return this.context.isOnlyLib(node, type, name);
  }

  isLibAlias(identifier, name) {
    return this.context.isLibAlias(identifier, name);
  }

  isFixedType(node, type) {
    if (type == null) {
      return false;
    }

    return this.isLibSymbol(node, type.getAliasSymbol() || type.getSymbol(), 'Fixed');
  }

  reportError(node, message, code) {
    this.context.reportError(node, message, code);
  }

  reportUnsupported(node) {
    this.context.reportUnsupported(node);
  }

  assertNotNull(value) {
    return this.context.assertNotNull(value);
  }

  filterNotNull(value) {
    return value != null;
  }

  processProperty(symbol) {
    const decls = symbol.getDeclarations().filter(symbolDecl => !TypeGuards.isMethodDeclaration(symbolDecl) || symbolDecl.isImplementation());

    if (!(decls.length === 1 || decls.length === 2 && decls.some(accessor => TypeGuards.isGetAccessorDeclaration(accessor)) && decls.some(accessor => TypeGuards.isSetAccessorDeclaration(accessor)))) {
      this.reportError(symbol.getDeclarations()[0], 'Invalid contract function. Resolved to multiple implementation declarations.', DiagnosticCode.INVALID_CONTRACT_METHOD);
      return [];
    }

    const decl = decls[0];

    if (!(TypeGuards.isMethodDeclaration(decl) || TypeGuards.isPropertyDeclaration(decl) || TypeGuards.isGetAccessorDeclaration(decl) || TypeGuards.isSetAccessorDeclaration(decl) || TypeGuards.isParameterDeclaration(decl))) {
      return [];
    }

    const name = symbol.getName();
    const type = this.getTypeOfSymbol(symbol, decl);

    if (type == null) {
      return [];
    }

    if (TypeGuards.isGetAccessorDeclaration(decl) || TypeGuards.isSetAccessorDeclaration(decl)) {
      const getDecl = TypeGuards.isGetAccessorDeclaration(decl) ? decl : decl.getGetAccessor();
      const setDecl = TypeGuards.isSetAccessorDeclaration(decl) ? decl : decl.getSetAccessor();
      const result = [];

      if (getDecl != null && isPublic(getDecl)) {
        result.push([getDecl, {
          name,
          constant: true,
          verify: this.hasVerify(getDecl),
          returnType: this.toABIReturn(getDecl, type, this.getIdentifier(getDecl.getReturnTypeNode())) || {
            type: 'ByteArray'
          }
        }]);
      }

      if (setDecl != null && isPublic(setDecl)) {
        result.push([setDecl, {
          name,
          constant: false,
          verify: this.hasVerify(setDecl),
          parameters: [_objectSpread({
            name: setDecl.getParameters()[0].getNameOrThrow()
          }, this.toABIReturn(setDecl, type, this.getIdentifier(setDecl.getParameters()[0].getTypeNode())) || {
            type: 'ByteArray'
          })],
          returnType: {
            type: 'Void'
          }
        }]);
      }

      return result;
    }

    if (!isPublic(decl)) {
      return [];
    }

    const verify = this.hasVerify(decl);

    if (TypeGuards.isMethodDeclaration(decl)) {
      const callSignatures = type.getCallSignatures();

      if (callSignatures.length !== 1) {
        this.reportError(decl, 'Invalid contract function. Resolved to multiple call signatures.', DiagnosticCode.INVALID_CONTRACT_METHOD);
        return [];
      }

      const callSignature = callSignatures[0];
      const parameters = callSignature.getParameters().map(parameter => this.toABIParameter(parameter)).filter(this.filterNotNull);
      const returnType = this.toABIReturn(decl, callSignature.getReturnType(), this.getIdentifier(decl.getReturnTypeNode()));
      const constant = this.hasDecorator(decl, 'constant');
      const func = {
        name,
        constant,
        verify,
        parameters,
        returnType: returnType || {
          type: 'ByteArray'
        }
      };
      return [[decl, func]];
    } else {
      const returnType = this.toABIReturn(decl, type, this.getIdentifier(decl.getTypeNode()));
      const func = {
        name,
        constant: true,
        verify,
        returnType: returnType || {
          type: 'ByteArray'
        }
      };
      return [[decl, func]];
    }
  }

  hasVerify(decl) {
    return this.hasDecorator(decl, 'verify');
  }

  hasDecorator(decl, name) {
    return decl.getDecorators().some(decorator => this.isOnlyLib(decorator.getExpression(), this.getType(decorator.getExpression()), name));
  }

  toABIParameter(param) {
    const decl = this.assertNotNull(param.getDeclarations()[0]);
    const id = TypeGuards.isParameterDeclaration(decl) ? this.getIdentifier(decl.getTypeNode()) : undefined;
    const type = this.toABIReturn(decl, this.getTypeOfSymbol(param, decl), id);

    if (type == null) {
      return undefined;
    }

    return _objectSpread({}, type, {
      name: param.getName()
    });
  }

  toABIReturn(node, resolvedType, typeIdentifier) {
    if (resolvedType == null && typeIdentifier == null) {
      this.reportError(node, 'Could not detect ABI, unknown type.', DiagnosticCode.UNKNOWN_TYPE);
      return undefined;
    }

    if (isOnlyBoolean(resolvedType)) {
      return {
        type: 'Boolean'
      };
    } else if (this.isLibAlias(typeIdentifier, 'Address')) {
      return {
        type: 'Hash160'
      };
    } else if (this.isLibAlias(typeIdentifier, 'Hash256')) {
      return {
        type: 'Hash256'
      };
    } else if (this.isLibAlias(typeIdentifier, 'Signature')) {
      return {
        type: 'Signature'
      };
    } else if (this.isLibAlias(typeIdentifier, 'PublicKey')) {
      return {
        type: 'PublicKey'
      };
    } else if (isVoid(resolvedType)) {
      return {
        type: 'Void'
      };
    } else if (isOnlyString(resolvedType)) {
      return {
        type: 'String'
      };
    } else if (isOnlyNumberLiteral(resolvedType)) {
      return {
        type: 'Integer',
        decimals: 0
      };
    } else if (this.isFixedType(node, resolvedType) && resolvedType != null) {
      const decimals = this.getFixedDecimals(resolvedType);
      return {
        type: 'Integer',
        decimals
      };
    } else if (isOnlyNumber(resolvedType)) {
      return {
        type: 'Integer',
        decimals: 0
      };
    } else if (isOnlyArray(resolvedType) && resolvedType != null) {
      const value = this.toABIReturn(node, resolvedType.getTypeArguments()[0]);

      if (value != null) {
        return {
          type: 'Array',
          value
        };
      }
    } else if (this.isOnlyGlobal(node, resolvedType, 'Buffer')) {
      return {
        type: 'ByteArray'
      };
    } else {
      this.reportError(node, 'Invalid contract type.', DiagnosticCode.INVALID_CONTRACT_TYPE);
    }

    return undefined;
  }

  getFixedDecimals(type) {
    return type.getUnionTypes()[1].getIntersectionTypes()[1].compilerType.value;
  }

  getIdentifier(node) {
    return node == null ? node : node.getFirstChildByKind(SyntaxKind.Identifier);
  }

  getTypeText(node, type) {
    let typeText = 'any';

    if (type == null) {
      this.reportError(node, 'Unknown type', DiagnosticCode.UNKNOWN_TYPE);
    } else if (this.isFixedType(node, type)) {
      typeText = 'number';
    } else {
      typeText = type.getText();
    }

    return typeText;
  }

}

const transpile = ({
  ast,
  smartContract,
  context: contextIn
}) => {
  const context = contextIn || new Context(getGlobals(ast), getLibs(ast), getLibAliases(ast));
  const transpiler = new NEOTranspiler(context, ast, smartContract);
  return transpiler.process();
};

const compileContract = async ({
  dir,
  filePath,
  name
}) => {
  const ast = await getAst(dir);
  const smartContract = ast.getSourceFileOrThrow(filePath).getClassOrThrow(name);
  const {
    ast: transpiledAst,
    sourceFile,
    abi,
    context
  } = transpile({
    ast,
    smartContract
  });
  const {
    code,
    context: finalContext
  } = compile({
    ast: transpiledAst,
    sourceFile,
    context
  });
  return {
    code,
    diagnostics: finalContext.diagnostics,
    abi
  };
};

const executeScript = async (monitor, ast, sourceFile, prelude = Buffer.alloc(0, 0)) => {
  const blockchain = await Blockchain.create({
    log: () => {// tslint:disable-next-line
    },
    settings: test,
    storage: levelUpStorage({
      context: {
        messageMagic: test.messageMagic
      },
      db: levelup( // @ts-ignore
      memdown())
    }),
    vm,
    monitor
  });
  const {
    code: compiledCode,
    context
  } = compile({
    ast,
    sourceFile
  });
  const error = context.diagnostics.filter(diagnostic => diagnostic.category === DiagnosticCategory.Error)[0];

  if (error != null) {
    throw new Error(`Compilation error: ${error.messageText} at ${error.source}`);
  }

  const result = await blockchain.invokeScript(Buffer.concat([prelude, compiledCode]), monitor);
  return result;
};

const scan = async dir => {
  const ast = await getAst(dir);
  const libs = getLibs(ast);
  const smartContract = libs.SmartContract.getDeclarations()[0];
  return smartContract.getDerivedClasses().reduce((acc, derived) => {
    if (!derived.isAbstract()) {
      const file = derived.getSourceFile().getFilePath();

      if (acc[file] == null) {
        acc[file] = [];
      }

      acc[file].push(derived.getNameOrThrow());
    }

    return acc;
  }, {});
};

const findContract = async (dir, name) => {
  const contracts = await scan(dir);
  const found = Object.entries(contracts).map(([path, contractNames]) => ({
    path,
    contractNames: contractNames.filter(contractName => name === contractName)
  })).filter(({
    contractNames
  }) => contractNames.length > 0);

  if (found.length > 1) {
    throw new Error(`Found multiple contracts with name ${name}`);
  } else if (found.length === 0) {
    throw new Error(`Cound not find contract with name ${name}`);
  }

  return {
    filePath: found[0].path,
    name
  };
};

export { compile, compileScript, compileContract, executeScript, findContract, scan };
//# sourceMappingURL=index.es.js.map